reorg pkg/ to prepare to support chains other than ethereumm

pkg/eth/blockchain.go

@@ -29,9 +29,9 @@ import (
 	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 var ErrEmptyHeader = errors.New("empty header returned over RPC")

pkg/eth/blockchain_test.go

@@ -28,9 +28,9 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	vulcCore "github.com/vulcanize/vulcanizedb/pkg/core"
 	"github.com/vulcanize/vulcanizedb/pkg/eth"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	vulcCore "github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("Geth blockchain", func() {

pkg/eth/cold_import/importer.go

@@ -17,9 +17,9 @@
 package cold_import
 
 import (
-	"github.com/vulcanize/vulcanizedb/pkg/datastore"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/ethereum"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/ethereum"
 )
 
 type ColdImporter struct {

pkg/eth/cold_import/importer_test.go

@@ -20,10 +20,10 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/cold_import"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("Geth cold importer", func() {

pkg/eth/cold_import/node_builder.go

@@ -21,8 +21,8 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/vulcanize/vulcanizedb/pkg/core"
-	"github.com/vulcanize/vulcanizedb/pkg/crypto"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/crypto"
 	"github.com/vulcanize/vulcanizedb/pkg/fs"
 )
 

pkg/eth/cold_import/node_builder_test.go

@@ -23,7 +23,7 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/cold_import"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("Cold importer node builder", func() {

pkg/eth/contract_watcher/full/converter/converter.go

@@ -0,0 +1,117 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter
+
+import (
+	"fmt"
+	"math/big"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+// ConverterInterface is used to convert watched event logs to
+// custom logs containing event input name => value maps
+type ConverterInterface interface {
+	Convert(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error)
+	Update(info *contract.Contract)
+}
+
+// Converter is the underlying struct for the ConverterInterface
+type Converter struct {
+	ContractInfo *contract.Contract
+}
+
+// Update configures the converter for a specific contract
+func (c *Converter) Update(info *contract.Contract) {
+	c.ContractInfo = info
+}
+
+// Convert converts the given watched event log into a types.Log for the given event
+func (c *Converter) Convert(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error) {
+	boundContract := bind.NewBoundContract(common.HexToAddress(c.ContractInfo.Address), c.ContractInfo.ParsedAbi, nil, nil, nil)
+	values := make(map[string]interface{})
+	log := helpers.ConvertToLog(watchedEvent)
+	err := boundContract.UnpackLogIntoMap(values, event.Name, log)
+	if err != nil {
+		return nil, err
+	}
+
+	strValues := make(map[string]string, len(values))
+	seenAddrs := make([]interface{}, 0, len(values))
+	seenHashes := make([]interface{}, 0, len(values))
+	for fieldName, input := range values {
+		// Postgres cannot handle custom types, resolve to strings
+		switch input.(type) {
+		case *big.Int:
+			b := input.(*big.Int)
+			strValues[fieldName] = b.String()
+		case common.Address:
+			a := input.(common.Address)
+			strValues[fieldName] = a.String()
+			seenAddrs = append(seenAddrs, a)
+		case common.Hash:
+			h := input.(common.Hash)
+			strValues[fieldName] = h.String()
+			seenHashes = append(seenHashes, h)
+		case string:
+			strValues[fieldName] = input.(string)
+		case bool:
+			strValues[fieldName] = strconv.FormatBool(input.(bool))
+		case []byte:
+			b := input.([]byte)
+			strValues[fieldName] = hexutil.Encode(b)
+			if len(b) == 32 { // collect byte arrays of size 32 as hashes
+				seenHashes = append(seenHashes, common.HexToHash(strValues[fieldName]))
+			}
+		case byte:
+			b := input.(byte)
+			strValues[fieldName] = string(b)
+		default:
+			return nil, fmt.Errorf("error: unhandled abi type %T", input)
+		}
+	}
+
+	// Only hold onto logs that pass our address filter, if any
+	if c.ContractInfo.PassesEventFilter(strValues) {
+		eventLog := &types.Log{
+			ID:     watchedEvent.LogID,
+			Values: strValues,
+			Block:  watchedEvent.BlockNumber,
+			Tx:     watchedEvent.TxHash,
+		}
+
+		// Cache emitted values if their caching is turned on
+		if c.ContractInfo.EmittedAddrs != nil {
+			c.ContractInfo.AddEmittedAddr(seenAddrs...)
+		}
+		if c.ContractInfo.EmittedHashes != nil {
+			c.ContractInfo.AddEmittedHash(seenHashes...)
+		}
+
+		return eventLog, nil
+	}
+
+	return nil, nil
+}

pkg/eth/contract_watcher/full/converter/converter_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestConverter(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Converter Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/full/converter/converter_test.go

@@ -0,0 +1,113 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+)
+
+var _ = Describe("Converter", func() {
+	var con *contract.Contract
+	var wantedEvents = []string{"Transfer"}
+	var err error
+
+	BeforeEach(func() {
+		con = test_helpers.SetupTusdContract(wantedEvents, []string{"balanceOf"})
+	})
+
+	Describe("Update", func() {
+		It("Updates contract con held by the converter", func() {
+			c := converter.Converter{}
+			c.Update(con)
+			Expect(c.ContractInfo).To(Equal(con))
+
+			con := test_helpers.SetupTusdContract([]string{}, []string{})
+			c.Update(con)
+			Expect(c.ContractInfo).To(Equal(con))
+		})
+	})
+
+	Describe("Convert", func() {
+		It("Converts a watched event log to mapping of event input names to values", func() {
+			_, ok := con.Events["Approval"]
+			Expect(ok).To(Equal(false))
+
+			event, ok := con.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+			err = con.GenerateFilters()
+			Expect(err).ToNot(HaveOccurred())
+
+			c := converter.Converter{}
+			c.Update(con)
+			log, err := c.Convert(mocks.MockTranferEvent, event)
+			Expect(err).ToNot(HaveOccurred())
+
+			from := common.HexToAddress("0x000000000000000000000000000000000000000000000000000000000000af21")
+			to := common.HexToAddress("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")
+			value := helpers.BigFromString("1097077688018008265106216665536940668749033598146")
+
+			v := log.Values["value"]
+
+			Expect(log.Values["to"]).To(Equal(to.String()))
+			Expect(log.Values["from"]).To(Equal(from.String()))
+			Expect(v).To(Equal(value.String()))
+		})
+
+		It("Keeps track of addresses it sees to grow a token holder address list for the contract", func() {
+			event, ok := con.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+
+			c := converter.Converter{}
+			c.Update(con)
+			_, err := c.Convert(mocks.MockTranferEvent, event)
+			Expect(err).ToNot(HaveOccurred())
+
+			b, ok := con.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = con.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = con.EmittedAddrs[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Fails with an empty contract", func() {
+			event := con.Events["Transfer"]
+			c := converter.Converter{}
+			c.Update(&contract.Contract{})
+			_, err = c.Convert(mocks.MockTranferEvent, event)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/eth/contract_watcher/full/retriever/block_retriever.go

@@ -0,0 +1,99 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever
+
+import (
+	"database/sql"
+
+	"github.com/vulcanize/vulcanizedb/libraries/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+// BlockRetriever is used to retrieve the first block for a given contract and the most recent block
+// It requires a vDB synced database with blocks, transactions, receipts, and logs
+type BlockRetriever interface {
+	RetrieveFirstBlock(contractAddr string) (int64, error)
+	RetrieveMostRecentBlock() (int64, error)
+}
+
+type blockRetriever struct {
+	db *postgres.DB
+}
+
+// NewBlockRetriever returns a new BlockRetriever
+func NewBlockRetriever(db *postgres.DB) BlockRetriever {
+	return &blockRetriever{
+		db: db,
+	}
+}
+
+// RetrieveFirstBlock fetches the block number for the earliest block in the db
+// Tries both methods of finding the first block, with the receipt method taking precedence
+func (r *blockRetriever) RetrieveFirstBlock(contractAddr string) (int64, error) {
+	i, err := r.retrieveFirstBlockFromReceipts(contractAddr)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			i, err = r.retrieveFirstBlockFromLogs(contractAddr)
+		}
+		return i, err
+	}
+
+	return i, err
+}
+
+// For some contracts the contract creation transaction receipt doesn't have the contract address so this doesn't work (e.g. Sai)
+func (r *blockRetriever) retrieveFirstBlockFromReceipts(contractAddr string) (int64, error) {
+	var firstBlock int64
+	addressID, getAddressErr := repository.GetOrCreateAddress(r.db, contractAddr)
+	if getAddressErr != nil {
+		return firstBlock, getAddressErr
+	}
+	err := r.db.Get(
+		&firstBlock,
+		`SELECT number FROM eth_blocks
+		       WHERE id = (SELECT block_id FROM full_sync_receipts
+                           WHERE contract_address_id = $1
+		                   ORDER BY block_id ASC
+					       LIMIT 1)`,
+		addressID,
+	)
+
+	return firstBlock, err
+}
+
+// In which case this servers as a heuristic to find the first block by finding the first contract event log
+func (r *blockRetriever) retrieveFirstBlockFromLogs(contractAddr string) (int64, error) {
+	var firstBlock int
+	err := r.db.Get(
+		&firstBlock,
+		"SELECT block_number FROM full_sync_logs WHERE lower(address) = $1 ORDER BY block_number ASC LIMIT 1",
+		contractAddr,
+	)
+
+	return int64(firstBlock), err
+}
+
+// RetrieveMostRecentBlock retrieves the most recent block number in vDB
+func (r *blockRetriever) RetrieveMostRecentBlock() (int64, error) {
+	var lastBlock int64
+	err := r.db.Get(
+		&lastBlock,
+		"SELECT number FROM eth_blocks ORDER BY number DESC LIMIT 1",
+	)
+
+	return lastBlock, err
+}

pkg/eth/contract_watcher/full/retriever/block_retriever_test.go

@@ -0,0 +1,259 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	"strings"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+)
+
+var _ = Describe("Block Retriever", func() {
+	var db *postgres.DB
+	var r retriever.BlockRetriever
+	var rawTransaction []byte
+	var blockRepository repositories.BlockRepository
+
+	// Contains no contract address
+	var block1 = core.Block{
+		Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+		Number:       1,
+		Transactions: []core.TransactionModel{},
+	}
+
+	BeforeEach(func() {
+		db, _ = test_helpers.SetupDBandBC()
+		blockRepository = *repositories.NewBlockRepository(db)
+		r = retriever.NewBlockRetriever(db)
+		gethTransaction := types.Transaction{}
+		var err error
+		rawTransaction, err = gethTransaction.MarshalJSON()
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("RetrieveFirstBlock", func() {
+		It("Retrieves block number where contract first appears in receipt, if available", func() {
+			// Contains the address in the receipt
+			block2 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+				Number: 2,
+				Transactions: []core.TransactionModel{{
+					Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					GasPrice: 0,
+					GasLimit: 0,
+					Nonce:    0,
+					Raw:      rawTransaction,
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+						ContractAddress: constants.TusdContractAddress,
+						Logs:            []core.FullSyncLog{},
+					},
+					TxIndex: 0,
+					Value:   "0",
+				}},
+			}
+
+			// Contains address in logs
+			block3 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number: 3,
+				Transactions: []core.TransactionModel{{
+					Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+					GasPrice: 0,
+					GasLimit: 0,
+					Nonce:    0,
+					Raw:      rawTransaction,
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+						ContractAddress: constants.TusdContractAddress,
+						Logs: []core.FullSyncLog{{
+							BlockNumber: 3,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+							Address:     constants.TusdContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+					TxIndex: 0,
+					Value:   "0",
+				}},
+			}
+
+			_, insertErrOne := blockRepository.CreateOrUpdateBlock(block1)
+			Expect(insertErrOne).NotTo(HaveOccurred())
+			_, insertErrTwo := blockRepository.CreateOrUpdateBlock(block2)
+			Expect(insertErrTwo).NotTo(HaveOccurred())
+			_, insertErrThree := blockRepository.CreateOrUpdateBlock(block3)
+			Expect(insertErrThree).NotTo(HaveOccurred())
+
+			i, err := r.RetrieveFirstBlock(strings.ToLower(constants.TusdContractAddress))
+			Expect(err).NotTo(HaveOccurred())
+			Expect(i).To(Equal(int64(2)))
+		})
+
+		It("Retrieves block number where contract first appears in event logs if it cannot find the address in a receipt", func() {
+			block2 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+				Number: 2,
+				Transactions: []core.TransactionModel{{
+					Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					GasPrice: 0,
+					GasLimit: 0,
+					Nonce:    0,
+					Raw:      rawTransaction,
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+						ContractAddress: "",
+						Logs: []core.FullSyncLog{{
+							BlockNumber: 2,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+							Address:     constants.DaiContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+					TxIndex: 0,
+					Value:   "0",
+				}},
+			}
+
+			block3 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number: 3,
+				Transactions: []core.TransactionModel{{
+					Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+					GasPrice: 0,
+					GasLimit: 0,
+					Nonce:    0,
+					Raw:      rawTransaction,
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+						ContractAddress: "",
+						Logs: []core.FullSyncLog{{
+							BlockNumber: 3,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+							Address:     constants.DaiContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+					TxIndex: 0,
+					Value:   "0",
+				}},
+			}
+
+			_, insertErrOne := blockRepository.CreateOrUpdateBlock(block1)
+			Expect(insertErrOne).NotTo(HaveOccurred())
+			_, insertErrTwo := blockRepository.CreateOrUpdateBlock(block2)
+			Expect(insertErrTwo).NotTo(HaveOccurred())
+			_, insertErrThree := blockRepository.CreateOrUpdateBlock(block3)
+			Expect(insertErrThree).NotTo(HaveOccurred())
+
+			i, err := r.RetrieveFirstBlock(constants.DaiContractAddress)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(i).To(Equal(int64(2)))
+		})
+
+		It("Fails if the contract address cannot be found in any blocks", func() {
+			block2 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+				Number:       2,
+				Transactions: []core.TransactionModel{},
+			}
+
+			block3 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number:       3,
+				Transactions: []core.TransactionModel{},
+			}
+
+			_, insertErrOne := blockRepository.CreateOrUpdateBlock(block1)
+			Expect(insertErrOne).NotTo(HaveOccurred())
+			_, insertErrTwo := blockRepository.CreateOrUpdateBlock(block2)
+			Expect(insertErrTwo).NotTo(HaveOccurred())
+			_, insertErrThree := blockRepository.CreateOrUpdateBlock(block3)
+			Expect(insertErrThree).NotTo(HaveOccurred())
+
+			_, err := r.RetrieveFirstBlock(constants.DaiContractAddress)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("RetrieveMostRecentBlock", func() {
+		It("Retrieves the latest block", func() {
+			block2 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+				Number:       2,
+				Transactions: []core.TransactionModel{},
+			}
+
+			block3 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number:       3,
+				Transactions: []core.TransactionModel{},
+			}
+
+			_, insertErrOne := blockRepository.CreateOrUpdateBlock(block1)
+			Expect(insertErrOne).NotTo(HaveOccurred())
+			_, insertErrTwo := blockRepository.CreateOrUpdateBlock(block2)
+			Expect(insertErrTwo).NotTo(HaveOccurred())
+			_, insertErrThree := blockRepository.CreateOrUpdateBlock(block3)
+			Expect(insertErrThree).NotTo(HaveOccurred())
+
+			i, err := r.RetrieveMostRecentBlock()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(i).To(Equal(int64(3)))
+		})
+
+		It("Fails if it cannot retrieve the latest block", func() {
+			i, err := r.RetrieveMostRecentBlock()
+			Expect(err).To(HaveOccurred())
+			Expect(i).To(Equal(int64(0)))
+		})
+	})
+})

pkg/eth/contract_watcher/full/retriever/retriever_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Block Number Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/full/transformer/transformer.go

@@ -0,0 +1,236 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer
+
+import (
+	"errors"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+)
+
+// Transformer is the top level struct for transforming watched contract data
+// Requires a fully synced vDB and a running eth node (or infura)
+type Transformer struct {
+	// Database interfaces
+	FilterRepository           datastore.FilterRepository       // Log filters repo; accepts filters generated by Contract.GenerateFilters()
+	WatchedEventRepository     datastore.WatchedEventRepository // Watched event log views, created by the log filters
+	TransformedEventRepository repository.EventRepository       // Holds transformed watched event log data
+
+	// Pre-processing interfaces
+	Parser    parser.Parser            // Parses events and methods out of contract abi fetched using contract address
+	Retriever retriever.BlockRetriever // Retrieves first block for contract and current block height
+
+	// Processing interfaces
+	Converter converter.ConverterInterface // Converts watched event logs into custom log
+	Poller    poller.Poller                // Polls methods using contract's token holder addresses and persists them using method datastore
+
+	// Store contract configuration information
+	Config config.ContractConfig
+
+	// Store contract info as mapping to contract address
+	Contracts map[string]*contract.Contract
+
+	// Latest block in the block repository
+	LastBlock int64
+}
+
+// NewTransformer takes in contract config, blockchain, and database, and returns a new Transformer
+func NewTransformer(con config.ContractConfig, BC core.BlockChain, DB *postgres.DB) *Transformer {
+	return &Transformer{
+		Poller:                     poller.NewPoller(BC, DB, types.FullSync),
+		Parser:                     parser.NewParser(con.Network),
+		Retriever:                  retriever.NewBlockRetriever(DB),
+		Converter:                  &converter.Converter{},
+		Contracts:                  map[string]*contract.Contract{},
+		WatchedEventRepository:     repositories.WatchedEventRepository{DB: DB},
+		FilterRepository:           repositories.FilterRepository{DB: DB},
+		TransformedEventRepository: repository.NewEventRepository(DB, types.FullSync),
+		Config:                     con,
+	}
+}
+
+// Init initializes the transformer
+// Use after creating and setting transformer
+// Loops over all of the addr => filter sets
+// Uses parser to pull event info from abi
+// Use this info to generate event filters
+func (tr *Transformer) Init() error {
+	for contractAddr := range tr.Config.Addresses {
+		// Configure Abi
+		if tr.Config.Abis[contractAddr] == "" {
+			// If no abi is given in the config, this method will try fetching from internal look-up table and etherscan
+			err := tr.Parser.Parse(contractAddr)
+			if err != nil {
+				return err
+			}
+		} else {
+			// If we have an abi from the config, load that into the parser
+			err := tr.Parser.ParseAbiStr(tr.Config.Abis[contractAddr])
+			if err != nil {
+				return err
+			}
+		}
+
+		// Get first block and most recent block number in the header repo
+		firstBlock, err := tr.Retriever.RetrieveFirstBlock(contractAddr)
+		if err != nil {
+			return err
+		}
+		// Set to specified range if it falls within the bounds
+		if firstBlock < tr.Config.StartingBlocks[contractAddr] {
+			firstBlock = tr.Config.StartingBlocks[contractAddr]
+		}
+
+		// Get contract name if it has one
+		var name = new(string)
+		pollingErr := tr.Poller.FetchContractData(tr.Parser.Abi(), contractAddr, "name", nil, name, tr.LastBlock)
+		if pollingErr != nil {
+			// can't return this error because "name" might not exist on the contract
+			logrus.Warnf("error fetching contract data: %s", pollingErr.Error())
+		}
+
+		// Remove any potential accidental duplicate inputs in arg filter values
+		eventArgs := map[string]bool{}
+		for _, arg := range tr.Config.EventArgs[contractAddr] {
+			eventArgs[arg] = true
+		}
+		methodArgs := map[string]bool{}
+		for _, arg := range tr.Config.MethodArgs[contractAddr] {
+			methodArgs[arg] = true
+		}
+
+		// Aggregate info into contract object
+		info := contract.Contract{
+			Name:          *name,
+			Network:       tr.Config.Network,
+			Address:       contractAddr,
+			Abi:           tr.Parser.Abi(),
+			ParsedAbi:     tr.Parser.ParsedAbi(),
+			StartingBlock: firstBlock,
+			Events:        tr.Parser.GetEvents(tr.Config.Events[contractAddr]),
+			Methods:       tr.Parser.GetSelectMethods(tr.Config.Methods[contractAddr]),
+			FilterArgs:    eventArgs,
+			MethodArgs:    methodArgs,
+			Piping:        tr.Config.Piping[contractAddr],
+		}.Init()
+
+		// Use info to create filters
+		err = info.GenerateFilters()
+		if err != nil {
+			return err
+		}
+
+		// Iterate over filters and push them to the repo using filter repository interface
+		for _, filter := range info.Filters {
+			err = tr.FilterRepository.CreateFilter(filter)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Store contract info for further processing
+		tr.Contracts[contractAddr] = info
+	}
+
+	// Get the most recent block number in the block repo
+	var err error
+	tr.LastBlock, err = tr.Retriever.RetrieveMostRecentBlock()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Execute runs the transformation processes
+// Iterates through stored, initialized contract objects
+// Iterates through contract's event filters, grabbing watched event logs
+// Uses converter to convert logs into custom log type
+// Persists converted logs into custom postgres tables
+// Calls selected methods, using token holder address generated during event log conversion
+func (tr *Transformer) Execute() error {
+	if len(tr.Contracts) == 0 {
+		return errors.New("error: transformer has no initialized contracts to work with")
+	}
+	// Iterate through all internal contracts
+	for _, con := range tr.Contracts {
+		// Update converter with current contract
+		tr.Converter.Update(con)
+
+		// Iterate through contract filters and get watched event logs
+		for eventSig, filter := range con.Filters {
+			watchedEvents, err := tr.WatchedEventRepository.GetWatchedEvents(filter.Name)
+			if err != nil {
+				return err
+			}
+
+			// Iterate over watched event logs
+			for _, we := range watchedEvents {
+				// Convert them to our custom log type
+				cstm, err := tr.Converter.Convert(*we, con.Events[eventSig])
+				if err != nil {
+					return err
+				}
+				if cstm == nil {
+					continue
+				}
+
+				// If log is not empty, immediately persist in repo
+				// Run this in seperate goroutine?
+				err = tr.TransformedEventRepository.PersistLogs([]types.Log{*cstm}, con.Events[eventSig], con.Address, con.Name)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// After persisting all watched event logs
+		// poller polls select contract methods
+		// and persists the results into custom pg tables
+		if err := tr.Poller.PollContract(*con, tr.LastBlock); err != nil {
+			return err
+		}
+	}
+
+	// At the end of a transformation cycle, and before the next
+	// update the latest block from the block repo
+	var err error
+	tr.LastBlock, err = tr.Retriever.RetrieveMostRecentBlock()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetConfig returns the transformers config; satisfies the transformer interface
+func (tr *Transformer) GetConfig() config.ContractConfig {
+	return tr.Config
+}

pkg/eth/contract_watcher/full/transformer/transformer_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestTransformer(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Transformer Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/full/transformer/transformer_test.go

@@ -0,0 +1,98 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer_test
+
+import (
+	"math/rand"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/transformer"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
+)
+
+var _ = Describe("Transformer", func() {
+	var fakeAddress = "0x1234567890abcdef"
+	rand.Seed(time.Now().UnixNano())
+
+	Describe("Init", func() {
+		It("Initializes transformer's contract objects", func() {
+			blockRetriever := &fakes.MockFullSyncBlockRetriever{}
+			firstBlock := int64(1)
+			mostRecentBlock := int64(2)
+			blockRetriever.FirstBlock = firstBlock
+			blockRetriever.MostRecentBlock = mostRecentBlock
+
+			parsr := &fakes.MockParser{}
+			fakeAbi := "fake_abi"
+			eventName := "Transfer"
+			event := types.Event{}
+			parsr.AbiToReturn = fakeAbi
+			parsr.EventName = eventName
+			parsr.Event = event
+
+			pollr := &fakes.MockPoller{}
+			fakeContractName := "fake_contract_name"
+			pollr.ContractName = fakeContractName
+
+			t := getTransformer(blockRetriever, parsr, pollr)
+
+			err := t.Init()
+
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[fakeAddress]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(firstBlock))
+			Expect(t.LastBlock).To(Equal(mostRecentBlock))
+			Expect(c.Abi).To(Equal(fakeAbi))
+			Expect(c.Name).To(Equal(fakeContractName))
+			Expect(c.Address).To(Equal(fakeAddress))
+		})
+
+		It("Fails to initialize if first and most recent blocks cannot be fetched from vDB", func() {
+			blockRetriever := &fakes.MockFullSyncBlockRetriever{}
+			blockRetriever.FirstBlockErr = fakes.FakeError
+			t := getTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
+
+			err := t.Init()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(MatchError(fakes.FakeError))
+		})
+	})
+})
+
+func getTransformer(blockRetriever retriever.BlockRetriever, parsr parser.Parser, pollr poller.Poller) transformer.Transformer {
+	return transformer.Transformer{
+		FilterRepository: &fakes.MockFilterRepository{},
+		Parser:           parsr,
+		Retriever:        blockRetriever,
+		Poller:           pollr,
+		Contracts:        map[string]*contract.Contract{},
+		Config:           mocks.MockConfig,
+	}
+}

pkg/eth/contract_watcher/header/converter/converter.go

@@ -0,0 +1,227 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+)
+
+// ConverterInterface is the interface for converting geth logs to our custom log type
+type ConverterInterface interface {
+	Convert(logs []gethTypes.Log, event types.Event, headerID int64) ([]types.Log, error)
+	ConvertBatch(logs []gethTypes.Log, events map[string]types.Event, headerID int64) (map[string][]types.Log, error)
+	Update(info *contract.Contract)
+}
+
+// Converter is the underlying struct for the ConverterInterface
+type Converter struct {
+	ContractInfo *contract.Contract
+}
+
+// Update is used to configure the converter with a specific contract
+func (c *Converter) Update(info *contract.Contract) {
+	c.ContractInfo = info
+}
+
+// Convert the given watched event log into a types.Log for the given event
+func (c *Converter) Convert(logs []gethTypes.Log, event types.Event, headerID int64) ([]types.Log, error) {
+	boundContract := bind.NewBoundContract(common.HexToAddress(c.ContractInfo.Address), c.ContractInfo.ParsedAbi, nil, nil, nil)
+	returnLogs := make([]types.Log, 0, len(logs))
+	for _, log := range logs {
+		values := make(map[string]interface{})
+		for _, field := range event.Fields {
+			var i interface{}
+			values[field.Name] = i
+		}
+
+		err := boundContract.UnpackLogIntoMap(values, event.Name, log)
+		if err != nil {
+			return nil, err
+		}
+
+		strValues := make(map[string]string, len(values))
+		seenAddrs := make([]interface{}, 0, len(values))
+		seenHashes := make([]interface{}, 0, len(values))
+		for fieldName, input := range values {
+			// Postgres cannot handle custom types, resolve everything to strings
+			switch input.(type) {
+			case *big.Int:
+				b := input.(*big.Int)
+				strValues[fieldName] = b.String()
+			case common.Address:
+				a := input.(common.Address)
+				strValues[fieldName] = a.String()
+				seenAddrs = append(seenAddrs, a)
+			case common.Hash:
+				h := input.(common.Hash)
+				strValues[fieldName] = h.String()
+				seenHashes = append(seenHashes, h)
+			case string:
+				strValues[fieldName] = input.(string)
+			case bool:
+				strValues[fieldName] = strconv.FormatBool(input.(bool))
+			case []byte:
+				b := input.([]byte)
+				strValues[fieldName] = hexutil.Encode(b)
+				if len(b) == 32 {
+					seenHashes = append(seenHashes, common.HexToHash(strValues[fieldName]))
+				}
+			case uint8:
+				u := input.(uint8)
+				strValues[fieldName] = strconv.Itoa(int(u))
+			case [32]uint8:
+				raw := input.([32]uint8)
+				converted := convertUintSliceToHash(raw)
+				strValues[fieldName] = converted.String()
+				seenHashes = append(seenHashes, converted)
+			default:
+				return nil, fmt.Errorf("error: unhandled abi type %T", input)
+			}
+		}
+
+		// Only hold onto logs that pass our address filter, if any
+		if c.ContractInfo.PassesEventFilter(strValues) {
+			raw, err := json.Marshal(log)
+			if err != nil {
+				return nil, err
+			}
+
+			returnLogs = append(returnLogs, types.Log{
+				LogIndex:         log.Index,
+				Values:           strValues,
+				Raw:              raw,
+				TransactionIndex: log.TxIndex,
+				ID:               headerID,
+			})
+
+			// Cache emitted values if their caching is turned on
+			if c.ContractInfo.EmittedAddrs != nil {
+				c.ContractInfo.AddEmittedAddr(seenAddrs...)
+			}
+			if c.ContractInfo.EmittedHashes != nil {
+				c.ContractInfo.AddEmittedHash(seenHashes...)
+			}
+		}
+	}
+
+	return returnLogs, nil
+}
+
+// ConvertBatch converts the given watched event logs into types.Logs; returns a map of event names to a slice of their converted logs
+func (c *Converter) ConvertBatch(logs []gethTypes.Log, events map[string]types.Event, headerID int64) (map[string][]types.Log, error) {
+	boundContract := bind.NewBoundContract(common.HexToAddress(c.ContractInfo.Address), c.ContractInfo.ParsedAbi, nil, nil, nil)
+	eventsToLogs := make(map[string][]types.Log)
+	for _, event := range events {
+		eventsToLogs[event.Name] = make([]types.Log, 0, len(logs))
+		// Iterate through all event logs
+		for _, log := range logs {
+			// If the log is of this event type, process it as such
+			if event.Sig() == log.Topics[0] {
+				values := make(map[string]interface{})
+				err := boundContract.UnpackLogIntoMap(values, event.Name, log)
+				if err != nil {
+					return nil, err
+				}
+				// Postgres cannot handle custom types, so we will resolve everything to strings
+				strValues := make(map[string]string, len(values))
+				// Keep track of addresses and hashes emitted from events
+				seenAddrs := make([]interface{}, 0, len(values))
+				seenHashes := make([]interface{}, 0, len(values))
+				for fieldName, input := range values {
+					switch input.(type) {
+					case *big.Int:
+						b := input.(*big.Int)
+						strValues[fieldName] = b.String()
+					case common.Address:
+						a := input.(common.Address)
+						strValues[fieldName] = a.String()
+						seenAddrs = append(seenAddrs, a)
+					case common.Hash:
+						h := input.(common.Hash)
+						strValues[fieldName] = h.String()
+						seenHashes = append(seenHashes, h)
+					case string:
+						strValues[fieldName] = input.(string)
+					case bool:
+						strValues[fieldName] = strconv.FormatBool(input.(bool))
+					case []byte:
+						b := input.([]byte)
+						strValues[fieldName] = hexutil.Encode(b)
+						if len(b) == 32 { // collect byte arrays of size 32 as hashes
+							seenHashes = append(seenHashes, common.BytesToHash(b))
+						}
+					case uint8:
+						u := input.(uint8)
+						strValues[fieldName] = strconv.Itoa(int(u))
+					case [32]uint8:
+						raw := input.([32]uint8)
+						converted := convertUintSliceToHash(raw)
+						strValues[fieldName] = converted.String()
+						seenHashes = append(seenHashes, converted)
+					default:
+						return nil, fmt.Errorf("error: unhandled abi type %T", input)
+					}
+				}
+
+				// Only hold onto logs that pass our argument filter, if any
+				if c.ContractInfo.PassesEventFilter(strValues) {
+					raw, err := json.Marshal(log)
+					if err != nil {
+						return nil, err
+					}
+
+					eventsToLogs[event.Name] = append(eventsToLogs[event.Name], types.Log{
+						LogIndex:         log.Index,
+						Values:           strValues,
+						Raw:              raw,
+						TransactionIndex: log.TxIndex,
+						ID:               headerID,
+					})
+
+					// Cache emitted values that pass the argument filter if their caching is turned on
+					if c.ContractInfo.EmittedAddrs != nil {
+						c.ContractInfo.AddEmittedAddr(seenAddrs...)
+					}
+					if c.ContractInfo.EmittedHashes != nil {
+						c.ContractInfo.AddEmittedHash(seenHashes...)
+					}
+				}
+			}
+		}
+	}
+
+	return eventsToLogs, nil
+}
+
+func convertUintSliceToHash(raw [32]uint8) common.Hash {
+	var asBytes []byte
+	for _, u := range raw {
+		asBytes = append(asBytes, u)
+	}
+	return common.BytesToHash(asBytes)
+}

pkg/eth/contract_watcher/header/converter/converter_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestConverter(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Header Sync Converter Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/header/converter/converter_test.go

@@ -0,0 +1,186 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+)
+
+var _ = Describe("Converter", func() {
+	var con *contract.Contract
+	var tusdWantedEvents = []string{"Transfer", "Mint"}
+	var ensWantedEvents = []string{"NewOwner"}
+	var marketPlaceWantedEvents = []string{"OrderCreated"}
+	var molochWantedEvents = []string{"SubmitVote"}
+	var err error
+
+	Describe("Update", func() {
+		It("Updates contract info held by the converter", func() {
+			con = test_helpers.SetupTusdContract(tusdWantedEvents, []string{})
+			c := converter.Converter{}
+			c.Update(con)
+			Expect(c.ContractInfo).To(Equal(con))
+
+			info := test_helpers.SetupTusdContract([]string{}, []string{})
+			c.Update(info)
+			Expect(c.ContractInfo).To(Equal(info))
+		})
+	})
+
+	Describe("Convert", func() {
+		It("Converts a watched event log to mapping of event input names to values", func() {
+			con = test_helpers.SetupTusdContract(tusdWantedEvents, []string{})
+			_, ok := con.Events["Approval"]
+			Expect(ok).To(Equal(false))
+
+			event, ok := con.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+
+			c := converter.Converter{}
+			c.Update(con)
+			logs, err := c.Convert([]types.Log{mocks.MockTransferLog1, mocks.MockTransferLog2}, event, 232)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(logs)).To(Equal(2))
+
+			sender1 := common.HexToAddress("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")
+			sender2 := common.HexToAddress("0x000000000000000000000000000000000000000000000000000000000000af21")
+			value := helpers.BigFromString("1097077688018008265106216665536940668749033598146")
+
+			Expect(logs[0].Values["to"]).To(Equal(sender1.String()))
+			Expect(logs[0].Values["from"]).To(Equal(sender2.String()))
+			Expect(logs[0].Values["value"]).To(Equal(value.String()))
+			Expect(logs[0].ID).To(Equal(int64(232)))
+			Expect(logs[1].Values["to"]).To(Equal(sender2.String()))
+			Expect(logs[1].Values["from"]).To(Equal(sender1.String()))
+			Expect(logs[1].Values["value"]).To(Equal(value.String()))
+			Expect(logs[1].ID).To(Equal(int64(232)))
+		})
+
+		It("Keeps track of addresses it sees if they will be used for method polling", func() {
+			con = test_helpers.SetupTusdContract(tusdWantedEvents, []string{"balanceOf"})
+			event, ok := con.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+
+			c := converter.Converter{}
+			c.Update(con)
+			_, err := c.Convert([]types.Log{mocks.MockTransferLog1, mocks.MockTransferLog2}, event, 232)
+			Expect(err).ToNot(HaveOccurred())
+
+			b, ok := con.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = con.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = con.EmittedAddrs[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedHashes[common.HexToHash("0x000000000000000000000000c02aaa39b223helloa0e5c4f27ead9083c752553")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Keeps track of hashes it sees if they will be used for method polling", func() {
+			con = test_helpers.SetupENSContract(ensWantedEvents, []string{"owner"})
+			event, ok := con.Events["NewOwner"]
+			Expect(ok).To(Equal(true))
+
+			c := converter.Converter{}
+			c.Update(con)
+			_, err := c.Convert([]types.Log{mocks.MockNewOwnerLog1, mocks.MockNewOwnerLog2}, event, 232)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(con.EmittedHashes)).To(Equal(3))
+
+			b, ok := con.EmittedHashes[common.HexToHash("0x000000000000000000000000c02aaa39b223helloa0e5c4f27ead9083c752553")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = con.EmittedHashes[common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = con.EmittedHashes[common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba400")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = con.EmittedHashes[common.HexToHash("0x9dd48thiscc444isc242510c0made03upa5975cac061dhashb843bce061ba400")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedHashes[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.EmittedHashes[""]
+			Expect(ok).To(Equal(false))
+
+			// Does not keep track of emitted addresses if the methods provided will not use them
+			_, ok = con.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("correctly parses bytes32", func() {
+			con = test_helpers.SetupMarketPlaceContract(marketPlaceWantedEvents, []string{})
+			event, ok := con.Events["OrderCreated"]
+			Expect(ok).To(BeTrue())
+
+			c := converter.Converter{}
+			c.Update(con)
+			result, err := c.Convert([]types.Log{mocks.MockOrderCreatedLog}, event, 232)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(len(result)).To(Equal(1))
+			Expect(result[0].Values["id"]).To(Equal("0x633f94affdcabe07c000231f85c752c97b9cc43966b432ec4d18641e6d178233"))
+		})
+
+		It("correctly parses uint8", func() {
+			con = test_helpers.SetupMolochContract(molochWantedEvents, []string{})
+			event, ok := con.Events["SubmitVote"]
+			Expect(ok).To(BeTrue())
+
+			c := converter.Converter{}
+			c.Update(con)
+			result, err := c.Convert([]types.Log{mocks.MockSubmitVoteLog}, event, 232)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(len(result)).To(Equal(1))
+			Expect(result[0].Values["uintVote"]).To(Equal("1"))
+		})
+
+		It("Fails with an empty contract", func() {
+			event := con.Events["Transfer"]
+			c := converter.Converter{}
+			c.Update(&contract.Contract{})
+			_, err = c.Convert([]types.Log{mocks.MockTransferLog1}, event, 232)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/eth/contract_watcher/header/fetcher/fetcher.go

@@ -0,0 +1,71 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package fetcher
+
+import (
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+// Fetcher is the fetching interface
+type Fetcher interface {
+	FetchLogs(contractAddresses []string, topics []common.Hash, missingHeader core.Header) ([]types.Log, error)
+}
+
+type fetcher struct {
+	blockChain core.BlockChain
+}
+
+// NewFetcher returns a new Fetcher
+func NewFetcher(blockchain core.BlockChain) Fetcher {
+	return &fetcher{
+		blockChain: blockchain,
+	}
+}
+
+// FetchLogs checks all topic0s, on all addresses, fetching matching logs for the given header
+func (fetcher *fetcher) FetchLogs(contractAddresses []string, topic0s []common.Hash, header core.Header) ([]types.Log, error) {
+	addresses := hexStringsToAddresses(contractAddresses)
+	blockHash := common.HexToHash(header.Hash)
+	query := ethereum.FilterQuery{
+		BlockHash: &blockHash,
+		Addresses: addresses,
+		// Search for _any_ of the topics in topic0 position; see docs on `FilterQuery`
+		Topics: [][]common.Hash{topic0s},
+	}
+
+	logs, err := fetcher.blockChain.GetEthLogsWithCustomQuery(query)
+	if err != nil {
+		// TODO review aggregate fetching error handling
+		return []types.Log{}, err
+	}
+
+	return logs, nil
+}
+
+func hexStringsToAddresses(hexStrings []string) []common.Address {
+	var addresses []common.Address
+	for _, hexString := range hexStrings {
+		address := common.HexToAddress(hexString)
+		addresses = append(addresses, address)
+	}
+
+	return addresses
+}

pkg/eth/contract_watcher/header/fetcher/fetcher_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package fetcher_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestFetcher(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Fetcher Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/header/fetcher/fetcher_test.go

@@ -0,0 +1,66 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package fetcher_test
+
+import (
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
+)
+
+var _ = Describe("Fetcher", func() {
+	Describe("FetchLogs", func() {
+		It("fetches logs based on the given query", func() {
+			blockChain := fakes.NewMockBlockChain()
+			fetcher := fetcher.NewFetcher(blockChain)
+			header := fakes.FakeHeader
+
+			addresses := []string{"0xfakeAddress", "0xanotherFakeAddress"}
+			topicZeros := [][]common.Hash{{common.BytesToHash([]byte{1, 2, 3, 4, 5})}}
+
+			_, err := fetcher.FetchLogs(addresses, []common.Hash{common.BytesToHash([]byte{1, 2, 3, 4, 5})}, header)
+
+			address1 := common.HexToAddress("0xfakeAddress")
+			address2 := common.HexToAddress("0xanotherFakeAddress")
+			Expect(err).NotTo(HaveOccurred())
+
+			blockHash := common.HexToHash(header.Hash)
+			expectedQuery := ethereum.FilterQuery{
+				BlockHash: &blockHash,
+				Addresses: []common.Address{address1, address2},
+				Topics:    topicZeros,
+			}
+			blockChain.AssertGetEthLogsWithCustomQueryCalledWith(expectedQuery)
+		})
+
+		It("returns an error if fetching the logs fails", func() {
+			blockChain := fakes.NewMockBlockChain()
+			blockChain.SetGetEthLogsWithCustomQueryErr(fakes.FakeError)
+			fetcher := fetcher.NewFetcher(blockChain)
+
+			_, err := fetcher.FetchLogs([]string{}, []common.Hash{}, core.Header{})
+
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(MatchError(fakes.FakeError))
+		})
+	})
+})

pkg/eth/contract_watcher/header/repository/header_repository.go

@@ -0,0 +1,271 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/golang-lru"
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+const columnCacheSize = 1000
+
+// HeaderRepository interfaces with the header and checked_headers tables
+type HeaderRepository interface {
+	AddCheckColumn(id string) error
+	AddCheckColumns(ids []string) error
+	MarkHeaderChecked(headerID int64, eventID string) error
+	MarkHeaderCheckedForAll(headerID int64, ids []string) error
+	MarkHeadersCheckedForAll(headers []core.Header, ids []string) error
+	MissingHeaders(startingBlockNumber int64, endingBlockNumber int64, eventID string) ([]core.Header, error)
+	MissingMethodsCheckedEventsIntersection(startingBlockNumber, endingBlockNumber int64, methodIds, eventIds []string) ([]core.Header, error)
+	MissingHeadersForAll(startingBlockNumber, endingBlockNumber int64, ids []string) ([]core.Header, error)
+	CheckCache(key string) (interface{}, bool)
+}
+
+type headerRepository struct {
+	db      *postgres.DB
+	columns *lru.Cache // Cache created columns to minimize db connections
+}
+
+// NewHeaderRepository returns a new HeaderRepository
+func NewHeaderRepository(db *postgres.DB) HeaderRepository {
+	ccs, _ := lru.New(columnCacheSize)
+	return &headerRepository{
+		db:      db,
+		columns: ccs,
+	}
+}
+
+// AddCheckColumn adds a checked_header column for the provided column id
+func (r *headerRepository) AddCheckColumn(id string) error {
+	// Check cache to see if column already exists before querying pg
+	_, ok := r.columns.Get(id)
+	if ok {
+		return nil
+	}
+
+	pgStr := "ALTER TABLE public.checked_headers ADD COLUMN IF NOT EXISTS "
+	pgStr = pgStr + id + " INTEGER NOT NULL DEFAULT 0"
+	_, err := r.db.Exec(pgStr)
+	if err != nil {
+		return err
+	}
+
+	// Add column name to cache
+	r.columns.Add(id, true)
+
+	return nil
+}
+
+// AddCheckColumns adds a checked_header column for all of the provided column ids
+func (r *headerRepository) AddCheckColumns(ids []string) error {
+	var err error
+	baseQuery := "ALTER TABLE public.checked_headers"
+	input := make([]string, 0, len(ids))
+	for _, id := range ids {
+		_, ok := r.columns.Get(id)
+		if !ok {
+			baseQuery += " ADD COLUMN IF NOT EXISTS " + id + " INTEGER NOT NULL DEFAULT 0,"
+			input = append(input, id)
+		}
+	}
+	if len(input) > 0 {
+		_, err = r.db.Exec(baseQuery[:len(baseQuery)-1])
+		if err == nil {
+			for _, id := range input {
+				r.columns.Add(id, true)
+			}
+		}
+	}
+
+	return err
+}
+
+// MarkHeaderChecked marks the header checked for the provided column id
+func (r *headerRepository) MarkHeaderChecked(headerID int64, id string) error {
+	_, err := r.db.Exec(`INSERT INTO public.checked_headers (header_id, `+id+`)
+		VALUES ($1, $2) 
+		ON CONFLICT (header_id) DO
+			UPDATE SET `+id+` = checked_headers.`+id+` + 1`, headerID, 1)
+	return err
+}
+
+// MarkHeaderCheckedForAll marks the header checked for all of the provided column ids
+func (r *headerRepository) MarkHeaderCheckedForAll(headerID int64, ids []string) error {
+	pgStr := "INSERT INTO public.checked_headers (header_id, "
+	for _, id := range ids {
+		pgStr += id + ", "
+	}
+	pgStr = pgStr[:len(pgStr)-2] + ") VALUES ($1, "
+	for i := 0; i < len(ids); i++ {
+		pgStr += "1, "
+	}
+	pgStr = pgStr[:len(pgStr)-2] + ") ON CONFLICT (header_id) DO UPDATE SET "
+	for _, id := range ids {
+		pgStr += id + `= checked_headers.` + id + ` + 1, `
+	}
+	pgStr = pgStr[:len(pgStr)-2]
+	_, err := r.db.Exec(pgStr, headerID)
+	return err
+}
+
+// MarkHeadersCheckedForAll marks all of the provided headers checked for each of the provided column ids
+func (r *headerRepository) MarkHeadersCheckedForAll(headers []core.Header, ids []string) error {
+	tx, err := r.db.Beginx()
+	if err != nil {
+		return err
+	}
+	for _, header := range headers {
+		pgStr := "INSERT INTO public.checked_headers (header_id, "
+		for _, id := range ids {
+			pgStr += id + ", "
+		}
+		pgStr = pgStr[:len(pgStr)-2] + ") VALUES ($1, "
+		for i := 0; i < len(ids); i++ {
+			pgStr += "1, "
+		}
+		pgStr = pgStr[:len(pgStr)-2] + ") ON CONFLICT (header_id) DO UPDATE SET "
+		for _, id := range ids {
+			pgStr += fmt.Sprintf("%s = checked_headers.%s + 1, ", id, id)
+		}
+		pgStr = pgStr[:len(pgStr)-2]
+		_, err = tx.Exec(pgStr, header.ID)
+		if err != nil {
+			rollbackErr := tx.Rollback()
+			if rollbackErr != nil {
+				logrus.Warnf("error rolling back transaction: %s", rollbackErr.Error())
+			}
+			return err
+		}
+	}
+	err = tx.Commit()
+	return err
+}
+
+// MissingHeaders returns missing headers for the provided checked_headers column id
+func (r *headerRepository) MissingHeaders(startingBlockNumber, endingBlockNumber int64, id string) ([]core.Header, error) {
+	var result []core.Header
+	var query string
+	var err error
+	if endingBlockNumber == -1 {
+		query = `SELECT headers.id, headers.block_number, headers.hash FROM headers
+				LEFT JOIN checked_headers on headers.id = header_id
+				WHERE (header_id ISNULL OR checked_headers.` + id + `=0)
+				AND headers.block_number >= $1
+				AND headers.eth_node_fingerprint = $2
+				ORDER BY headers.block_number`
+		err = r.db.Select(&result, query, startingBlockNumber, r.db.Node.ID)
+	} else {
+		query = `SELECT headers.id, headers.block_number, headers.hash FROM headers
+				LEFT JOIN checked_headers on headers.id = header_id
+				WHERE (header_id ISNULL OR checked_headers.` + id + `=0)
+				AND headers.block_number >= $1
+				AND headers.block_number <= $2
+				AND headers.eth_node_fingerprint = $3
+				ORDER BY headers.block_number`
+		err = r.db.Select(&result, query, startingBlockNumber, endingBlockNumber, r.db.Node.ID)
+	}
+	return continuousHeaders(result), err
+}
+
+// MissingHeadersForAll returns missing headers for all of the provided checked_headers column ids
+func (r *headerRepository) MissingHeadersForAll(startingBlockNumber, endingBlockNumber int64, ids []string) ([]core.Header, error) {
+	var result []core.Header
+	var query string
+	var err error
+	baseQuery := `SELECT headers.id, headers.block_number, headers.hash FROM headers
+				  LEFT JOIN checked_headers on headers.id = header_id
+				  WHERE (header_id ISNULL`
+	for _, id := range ids {
+		baseQuery += ` OR checked_headers.` + id + `= 0`
+	}
+	if endingBlockNumber == -1 {
+		endStr := `) AND headers.block_number >= $1
+				  AND headers.eth_node_fingerprint = $2
+				  ORDER BY headers.block_number`
+		query = baseQuery + endStr
+		err = r.db.Select(&result, query, startingBlockNumber, r.db.Node.ID)
+	} else {
+		endStr := `) AND headers.block_number >= $1
+				  AND headers.block_number <= $2
+				  AND headers.eth_node_fingerprint = $3
+				  ORDER BY headers.block_number`
+		query = baseQuery + endStr
+		err = r.db.Select(&result, query, startingBlockNumber, endingBlockNumber, r.db.Node.ID)
+	}
+	return continuousHeaders(result), err
+}
+
+// MissingMethodsCheckedEventsIntersection returns headers that have been checked for all of the provided event ids but not for the provided method ids
+func (r *headerRepository) MissingMethodsCheckedEventsIntersection(startingBlockNumber, endingBlockNumber int64, methodIds, eventIds []string) ([]core.Header, error) {
+	var result []core.Header
+	var query string
+	var err error
+	baseQuery := `SELECT headers.id, headers.block_number, headers.hash FROM headers
+				  LEFT JOIN checked_headers on headers.id = header_id
+				  WHERE (header_id IS NOT NULL`
+	for _, id := range eventIds {
+		baseQuery += ` AND ` + id + `!=0`
+	}
+	baseQuery += `) AND (`
+	for _, id := range methodIds {
+		baseQuery += id + ` =0 AND `
+	}
+	baseQuery = baseQuery[:len(baseQuery)-5] + `) `
+	if endingBlockNumber == -1 {
+		endStr := `AND headers.block_number >= $1
+				  AND headers.eth_node_fingerprint = $2
+				  ORDER BY headers.block_number`
+		query = baseQuery + endStr
+		err = r.db.Select(&result, query, startingBlockNumber, r.db.Node.ID)
+	} else {
+		endStr := `AND headers.block_number >= $1
+				  AND headers.block_number <= $2
+				  AND headers.eth_node_fingerprint = $3
+				  ORDER BY headers.block_number`
+		query = baseQuery + endStr
+		err = r.db.Select(&result, query, startingBlockNumber, endingBlockNumber, r.db.Node.ID)
+	}
+	return continuousHeaders(result), err
+}
+
+// Returns a continuous set of headers
+func continuousHeaders(headers []core.Header) []core.Header {
+	if len(headers) < 1 {
+		logrus.Trace("no headers to arrange continuously")
+		return headers
+	}
+	previousHeader := headers[0].BlockNumber
+	for i := 1; i < len(headers); i++ {
+		previousHeader++
+		if headers[i].BlockNumber != previousHeader {
+			return headers[:i]
+		}
+	}
+
+	return headers
+}
+
+// CheckCache checks the repositories column id cache for a value
+func (r *headerRepository) CheckCache(key string) (interface{}, bool) {
+	return r.columns.Get(key)
+}

pkg/eth/contract_watcher/header/repository/header_repository_test.go

@@ -0,0 +1,371 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository_test
+
+import (
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+)
+
+var _ = Describe("Repository", func() {
+	var db *postgres.DB
+	var contractHeaderRepo repository.HeaderRepository // contract_watcher headerSync header repository
+	var coreHeaderRepo repositories.HeaderRepository   // pkg/datastore header repository
+	var eventIDs = []string{
+		"eventName_contractAddr",
+		"eventName_contractAddr2",
+		"eventName_contractAddr3",
+	}
+	var methodIDs = []string{
+		"methodName_contractAddr",
+		"methodName_contractAddr2",
+		"methodName_contractAddr3",
+	}
+
+	BeforeEach(func() {
+		db, _ = test_helpers.SetupDBandBC()
+		contractHeaderRepo = repository.NewHeaderRepository(db)
+		coreHeaderRepo = repositories.NewHeaderRepository(db)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("AddCheckColumn", func() {
+		It("Creates a column for the given eventID to mark if the header has been checked for that event", func() {
+			query := fmt.Sprintf("SELECT %s FROM checked_headers", eventIDs[0])
+			_, err := db.Exec(query)
+			Expect(err).To(HaveOccurred())
+
+			err = contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			_, err = db.Exec(query)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("Caches column it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+			_, ok := contractHeaderRepo.CheckCache(eventIDs[0])
+			Expect(ok).To(Equal(false))
+
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			v, ok := contractHeaderRepo.CheckCache(eventIDs[0])
+			Expect(ok).To(Equal(true))
+			Expect(v).To(Equal(true))
+		})
+	})
+
+	Describe("AddCheckColumns", func() {
+		It("Creates a column for the given eventIDs to mark if the header has been checked for those events", func() {
+			for _, id := range eventIDs {
+				_, err := db.Exec(fmt.Sprintf("SELECT %s FROM checked_headers", id))
+				Expect(err).To(HaveOccurred())
+			}
+
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			for _, id := range eventIDs {
+				_, err := db.Exec(fmt.Sprintf("SELECT %s FROM checked_headers", id))
+				Expect(err).ToNot(HaveOccurred())
+			}
+		})
+
+		It("Caches columns it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+			for _, id := range eventIDs {
+				_, ok := contractHeaderRepo.CheckCache(id)
+				Expect(ok).To(Equal(false))
+			}
+
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			for _, id := range eventIDs {
+				v, ok := contractHeaderRepo.CheckCache(id)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			}
+		})
+	})
+
+	Describe("MissingHeaders", func() {
+		It("Returns all unchecked headers for the given eventID", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+		})
+
+		It("Returns unchecked headers in ascending order", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			h1 := missingHeaders[0]
+			h2 := missingHeaders[1]
+			h3 := missingHeaders[2]
+			Expect(h1.BlockNumber).To(Equal(mocks.MockHeader1.BlockNumber))
+			Expect(h2.BlockNumber).To(Equal(mocks.MockHeader2.BlockNumber))
+			Expect(h3.BlockNumber).To(Equal(mocks.MockHeader3.BlockNumber))
+		})
+
+		It("Returns only contiguous chunks of headers", func() {
+			addDiscontinuousHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+			Expect(missingHeaders[0].BlockNumber).To(Equal(mocks.MockHeader1.BlockNumber))
+			Expect(missingHeaders[1].BlockNumber).To(Equal(mocks.MockHeader2.BlockNumber))
+		})
+
+		It("Fails if eventID does not yet exist in check_headers table", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			_, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, "notEventId")
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("MissingHeadersForAll", func() { // HERE
+		It("Returns all headers that have not been checked for all of the ids provided", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[1])
+			Expect(err).ToNot(HaveOccurred())
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[2])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader2.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+		})
+
+		It("Returns only contiguous chunks of headers", func() {
+			addDiscontinuousHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+			Expect(missingHeaders[0].BlockNumber).To(Equal(mocks.MockHeader1.BlockNumber))
+			Expect(missingHeaders[1].BlockNumber).To(Equal(mocks.MockHeader2.BlockNumber))
+		})
+
+		It("returns headers after starting header if starting header not missing", func() {
+			addLaterHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).NotTo(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, -1, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+			Expect(missingHeaders[0].BlockNumber).To(Equal(mocks.MockHeader3.BlockNumber))
+			Expect(missingHeaders[1].BlockNumber).To(Equal(mocks.MockHeader4.BlockNumber))
+		})
+
+		It("Fails if one of the eventIDs does not yet exist in check_headers table", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			badEventIDs := append(eventIDs, "notEventId")
+
+			_, err = contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, badEventIDs)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("MarkHeaderChecked", func() {
+		It("Marks the header checked for the given eventID", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].ID
+			err = contractHeaderRepo.MarkHeaderChecked(headerID, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader2.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+		})
+
+		It("Fails if eventID does not yet exist in check_headers table", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].ID
+			err = contractHeaderRepo.MarkHeaderChecked(headerID, "notEventId")
+			Expect(err).To(HaveOccurred())
+
+			missingHeaders, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+		})
+	})
+
+	Describe("MarkHeaderCheckedForAll", func() {
+		It("Marks the header checked for all provided column ids", func() {
+			addHeaders(coreHeaderRepo)
+			err := contractHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].ID
+			err = contractHeaderRepo.MarkHeaderCheckedForAll(headerID, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader2.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+		})
+	})
+
+	Describe("MarkHeadersCheckedForAll", func() {
+		It("Marks the headers checked for all provided column ids", func() {
+			addHeaders(coreHeaderRepo)
+			methodIDs := []string{
+				"methodName_contractAddr",
+				"methodName_contractAddr2",
+				"methodName_contractAddr3",
+			}
+
+			var missingHeaders []core.Header
+			for _, id := range methodIDs {
+				err := contractHeaderRepo.AddCheckColumn(id)
+				Expect(err).ToNot(HaveOccurred())
+				missingHeaders, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, id)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(missingHeaders)).To(Equal(3))
+			}
+
+			err := contractHeaderRepo.MarkHeadersCheckedForAll(missingHeaders, methodIDs)
+			Expect(err).ToNot(HaveOccurred())
+			for _, id := range methodIDs {
+				missingHeaders, err = contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, id)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(missingHeaders)).To(Equal(0))
+			}
+		})
+	})
+
+	Describe("MissingMethodsCheckedEventsIntersection", func() {
+		It("Returns headers that have been checked for all the provided events but have not been checked for all the provided methods", func() {
+			addHeaders(coreHeaderRepo)
+			for i, id := range eventIDs {
+				err := contractHeaderRepo.AddCheckColumn(id)
+				Expect(err).ToNot(HaveOccurred())
+				err = contractHeaderRepo.AddCheckColumn(methodIDs[i])
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			missingHeaders, err := contractHeaderRepo.MissingHeaders(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].ID
+			headerID2 := missingHeaders[1].ID
+			for i, id := range eventIDs {
+				err = contractHeaderRepo.MarkHeaderChecked(headerID, id)
+				Expect(err).ToNot(HaveOccurred())
+				err = contractHeaderRepo.MarkHeaderChecked(headerID2, id)
+				Expect(err).ToNot(HaveOccurred())
+				err = contractHeaderRepo.MarkHeaderChecked(headerID, methodIDs[i])
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			intersectionHeaders, err := contractHeaderRepo.MissingMethodsCheckedEventsIntersection(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, methodIDs, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(intersectionHeaders)).To(Equal(1))
+			Expect(intersectionHeaders[0].ID).To(Equal(headerID2))
+		})
+	})
+})
+
+func addHeaders(coreHeaderRepo repositories.HeaderRepository) {
+	_, err := coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader1)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader2)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader3)
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func addDiscontinuousHeaders(coreHeaderRepo repositories.HeaderRepository) {
+	_, err := coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader1)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader2)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader4)
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func addLaterHeaders(coreHeaderRepo repositories.HeaderRepository) {
+	_, err := coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader3)
+	Expect(err).NotTo(HaveOccurred())
+	_, err = coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader4)
+	Expect(err).NotTo(HaveOccurred())
+}

pkg/eth/contract_watcher/header/repository/repository_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestRepository(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Header Sync Repository Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/header/retriever/block_retriever.go

@@ -0,0 +1,61 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+// BlockRetriever is used to retrieve the first block for a given contract and the most recent block
+// It requires a vDB synced database with blocks, transactions, receipts, and logs
+type BlockRetriever interface {
+	RetrieveFirstBlock() (int64, error)
+	RetrieveMostRecentBlock() (int64, error)
+}
+
+type blockRetriever struct {
+	db *postgres.DB
+}
+
+// NewBlockRetriever returns a new BlockRetriever
+func NewBlockRetriever(db *postgres.DB) BlockRetriever {
+	return &blockRetriever{
+		db: db,
+	}
+}
+
+// RetrieveFirstBlock retrieves block number of earliest header in repo
+func (r *blockRetriever) RetrieveFirstBlock() (int64, error) {
+	var firstBlock int
+	err := r.db.Get(
+		&firstBlock,
+		"SELECT block_number FROM headers ORDER BY block_number LIMIT 1",
+	)
+
+	return int64(firstBlock), err
+}
+
+// RetrieveMostRecentBlock retrieves block number of latest header in repo
+func (r *blockRetriever) RetrieveMostRecentBlock() (int64, error) {
+	var lastBlock int
+	err := r.db.Get(
+		&lastBlock,
+		"SELECT block_number FROM headers ORDER BY block_number DESC LIMIT 1",
+	)
+
+	return int64(lastBlock), err
+}

pkg/eth/contract_watcher/header/retriever/block_retriever_test.go

@@ -0,0 +1,85 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+)
+
+var _ = Describe("Block Retriever", func() {
+	var db *postgres.DB
+	var r retriever.BlockRetriever
+	var headerRepository repositories.HeaderRepository
+
+	BeforeEach(func() {
+		db, _ = test_helpers.SetupDBandBC()
+		headerRepository = repositories.NewHeaderRepository(db)
+		r = retriever.NewBlockRetriever(db)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("RetrieveFirstBlock", func() {
+		It("Retrieves block number of earliest header in the database", func() {
+			_, err := headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = headerRepository.CreateOrUpdateHeader(mocks.MockHeader2)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+			Expect(err).ToNot(HaveOccurred())
+
+			i, err := r.RetrieveFirstBlock()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(i).To(Equal(int64(6194632)))
+		})
+
+		It("Fails if no headers can be found in the database", func() {
+			_, err := r.RetrieveFirstBlock()
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("RetrieveMostRecentBlock", func() {
+		It("Retrieves the latest header's block number", func() {
+			_, err := headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = headerRepository.CreateOrUpdateHeader(mocks.MockHeader2)
+			Expect(err).ToNot(HaveOccurred())
+			_, err = headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+			Expect(err).ToNot(HaveOccurred())
+
+			i, err := r.RetrieveMostRecentBlock()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(i).To(Equal(int64(6194634)))
+		})
+
+		It("Fails if no headers can be found in the database", func() {
+			i, err := r.RetrieveMostRecentBlock()
+			Expect(err).To(HaveOccurred())
+			Expect(i).To(Equal(int64(0)))
+		})
+	})
+})

pkg/eth/contract_watcher/header/retriever/retriever_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Header Sync Block Number Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/header/transformer/transformer.go

@@ -0,0 +1,337 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/poller"
+	srep "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+// Transformer is the top level struct for transforming watched contract data
+// Requires a header synced vDB (headers) and a running eth node (or infura)
+type Transformer struct {
+	// Database interfaces
+	EventRepository  srep.EventRepository        // Holds transformed watched event log data
+	HeaderRepository repository.HeaderRepository // Interface for interaction with header repositories
+
+	// Pre-processing interfaces
+	Parser    parser.Parser            // Parses events and methods out of contract abi fetched using contract address
+	Retriever retriever.BlockRetriever // Retrieves first block for contract
+
+	// Processing interfaces
+	Fetcher   fetcher.Fetcher              // Fetches event logs, using header hashes
+	Converter converter.ConverterInterface // Converts watched event logs into custom log
+	Poller    poller.Poller                // Polls methods using arguments collected from events and persists them using a method datastore
+
+	// Store contract configuration information
+	Config config.ContractConfig
+
+	// Store contract info as mapping to contract address
+	Contracts map[string]*contract.Contract
+
+	// Internally configured transformer variables
+	contractAddresses []string            // Holds all contract addresses, for batch fetching of logs
+	sortedEventIds    map[string][]string // Map to sort event column ids by contract, for post fetch processing and persisting of logs
+	sortedMethodIds   map[string][]string // Map to sort method column ids by contract, for post fetch method polling
+	eventIds          []string            // Holds event column ids across all contract, for batch fetching of headers
+	eventFilters      []common.Hash       // Holds topic0 hashes across all contracts, for batch fetching of logs
+	Start             int64               // Hold the lowest starting block and the highest ending block
+}
+
+// Order-of-operations:
+// 1. Create new transformer
+// 2. Load contract addresses and their parameters
+// 3. Init
+// 4. Execute
+
+// NewTransformer takes in a contract config, blockchain, and database, and returns a new Transformer
+func NewTransformer(con config.ContractConfig, bc core.BlockChain, db *postgres.DB) *Transformer {
+
+	return &Transformer{
+		Poller:           poller.NewPoller(bc, db, types.HeaderSync),
+		Fetcher:          fetcher.NewFetcher(bc),
+		Parser:           parser.NewParser(con.Network),
+		HeaderRepository: repository.NewHeaderRepository(db),
+		Retriever:        retriever.NewBlockRetriever(db),
+		Converter:        &converter.Converter{},
+		Contracts:        map[string]*contract.Contract{},
+		EventRepository:  srep.NewEventRepository(db, types.HeaderSync),
+		Config:           con,
+	}
+}
+
+// Init initialized the Transformer
+// Use after creating and setting transformer
+// Loops over all of the addr => filter sets
+// Uses parser to pull event info from abi
+// Use this info to generate event filters
+func (tr *Transformer) Init() error {
+	// Initialize internally configured transformer settings
+	tr.contractAddresses = make([]string, 0)       // Holds all contract addresses, for batch fetching of logs
+	tr.sortedEventIds = make(map[string][]string)  // Map to sort event column ids by contract, for post fetch processing and persisting of logs
+	tr.sortedMethodIds = make(map[string][]string) // Map to sort method column ids by contract, for post fetch method polling
+	tr.eventIds = make([]string, 0)                // Holds event column ids across all contract, for batch fetching of headers
+	tr.eventFilters = make([]common.Hash, 0)       // Holds topic0 hashes across all contracts, for batch fetching of logs
+	tr.Start = math.MaxInt64
+
+	// Iterate through all internal contract addresses
+	for contractAddr := range tr.Config.Addresses {
+		// Configure Abi
+		if tr.Config.Abis[contractAddr] == "" {
+			// If no abi is given in the config, this method will try fetching from internal look-up table and etherscan
+			parseErr := tr.Parser.Parse(contractAddr)
+			if parseErr != nil {
+				return fmt.Errorf("error parsing contract by address: %s", parseErr.Error())
+			}
+		} else {
+			// If we have an abi from the config, load that into the parser
+			parseErr := tr.Parser.ParseAbiStr(tr.Config.Abis[contractAddr])
+			if parseErr != nil {
+				return fmt.Errorf("error parsing contract abi: %s", parseErr.Error())
+			}
+		}
+
+		// Get first block and most recent block number in the header repo
+		firstBlock, retrieveErr := tr.Retriever.RetrieveFirstBlock()
+		if retrieveErr != nil {
+			if retrieveErr == sql.ErrNoRows {
+				logrus.Error(fmt.Errorf("error retrieving first block: %s", retrieveErr.Error()))
+				firstBlock = 0
+			} else {
+				return fmt.Errorf("error retrieving first block: %s", retrieveErr.Error())
+			}
+		}
+
+		// Set to specified range if it falls within the bounds
+		if firstBlock < tr.Config.StartingBlocks[contractAddr] {
+			firstBlock = tr.Config.StartingBlocks[contractAddr]
+		}
+
+		// Get contract name if it has one
+		var name = new(string)
+		pollingErr := tr.Poller.FetchContractData(tr.Parser.Abi(), contractAddr, "name", nil, name, -1)
+		if pollingErr != nil {
+			// can't return this error because "name" might not exist on the contract
+			logrus.Warnf("error fetching contract data: %s", pollingErr.Error())
+		}
+
+		// Remove any potential accidental duplicate inputs
+		eventArgs := map[string]bool{}
+		for _, arg := range tr.Config.EventArgs[contractAddr] {
+			eventArgs[arg] = true
+		}
+		methodArgs := map[string]bool{}
+		for _, arg := range tr.Config.MethodArgs[contractAddr] {
+			methodArgs[arg] = true
+		}
+
+		// Aggregate info into contract object and store for execution
+		con := contract.Contract{
+			Name:          *name,
+			Network:       tr.Config.Network,
+			Address:       contractAddr,
+			Abi:           tr.Parser.Abi(),
+			ParsedAbi:     tr.Parser.ParsedAbi(),
+			StartingBlock: firstBlock,
+			Events:        tr.Parser.GetEvents(tr.Config.Events[contractAddr]),
+			Methods:       tr.Parser.GetSelectMethods(tr.Config.Methods[contractAddr]),
+			FilterArgs:    eventArgs,
+			MethodArgs:    methodArgs,
+			Piping:        tr.Config.Piping[contractAddr],
+		}.Init()
+		tr.Contracts[contractAddr] = con
+		tr.contractAddresses = append(tr.contractAddresses, con.Address)
+
+		// Create checked_headers columns for each event id and append to list of all event ids
+		tr.sortedEventIds[con.Address] = make([]string, 0, len(con.Events))
+		for _, event := range con.Events {
+			eventID := strings.ToLower(event.Name + "_" + con.Address)
+			addColumnErr := tr.HeaderRepository.AddCheckColumn(eventID)
+			if addColumnErr != nil {
+				return fmt.Errorf("error adding check column: %s", addColumnErr.Error())
+			}
+			// Keep track of this event id; sorted and unsorted
+			tr.sortedEventIds[con.Address] = append(tr.sortedEventIds[con.Address], eventID)
+			tr.eventIds = append(tr.eventIds, eventID)
+			// Append this event sig to the filters
+			tr.eventFilters = append(tr.eventFilters, event.Sig())
+		}
+
+		// Create checked_headers columns for each method id and append list of all method ids
+		tr.sortedMethodIds[con.Address] = make([]string, 0, len(con.Methods))
+		for _, m := range con.Methods {
+			methodID := strings.ToLower(m.Name + "_" + con.Address)
+			addColumnErr := tr.HeaderRepository.AddCheckColumn(methodID)
+			if addColumnErr != nil {
+				return fmt.Errorf("error adding check column: %s", addColumnErr.Error())
+			}
+			tr.sortedMethodIds[con.Address] = append(tr.sortedMethodIds[con.Address], methodID)
+		}
+
+		// Update start to the lowest block
+		if con.StartingBlock < tr.Start {
+			tr.Start = con.StartingBlock
+		}
+	}
+
+	return nil
+}
+
+// Execute runs the transformation processes
+func (tr *Transformer) Execute() error {
+	if len(tr.Contracts) == 0 {
+		return errors.New("error: transformer has no initialized contracts")
+	}
+
+	// Find unchecked headers for all events across all contracts; these are returned in asc order
+	missingHeaders, missingHeadersErr := tr.HeaderRepository.MissingHeadersForAll(tr.Start, -1, tr.eventIds)
+	if missingHeadersErr != nil {
+		return fmt.Errorf("error getting missing headers: %s", missingHeadersErr.Error())
+	}
+
+	// Iterate over headers
+	for _, header := range missingHeaders {
+		// Set `start` to this header
+		// This way if we throw an error but don't bring the execution cycle down (how it is currently handled)
+		// we restart the cycle at this header
+		tr.Start = header.BlockNumber
+		// Map to sort batch fetched logs by which contract they belong to, for post fetch processing
+		sortedLogs := make(map[string][]gethTypes.Log)
+		// And fetch all event logs across contracts at this header
+		allLogs, fetchErr := tr.Fetcher.FetchLogs(tr.contractAddresses, tr.eventFilters, header)
+		if fetchErr != nil {
+			return fmt.Errorf("error fetching logs: %s", fetchErr.Error())
+		}
+
+		// If no logs are found mark the header checked for all of these eventIDs
+		// and continue to method polling and onto the next iteration
+		if len(allLogs) < 1 {
+			markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, tr.eventIds)
+			if markCheckedErr != nil {
+				return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
+			}
+			pollingErr := tr.methodPolling(header, tr.sortedMethodIds)
+			if pollingErr != nil {
+				return fmt.Errorf("error polling methods: %s", pollingErr.Error())
+			}
+			tr.Start = header.BlockNumber + 1 // Empty header; setup to start at the next header
+			logrus.Tracef("no logs found for block %d, continuing", header.BlockNumber)
+			continue
+		}
+
+		for _, log := range allLogs {
+			addr := strings.ToLower(log.Address.Hex())
+			sortedLogs[addr] = append(sortedLogs[addr], log)
+		}
+
+		// Process logs for each contract
+		for conAddr, logs := range sortedLogs {
+			if logs == nil {
+				logrus.Tracef("no logs found for contract %s at block %d, continuing", conAddr, header.BlockNumber)
+				continue
+			}
+			// Configure converter with this contract
+			con := tr.Contracts[conAddr]
+			tr.Converter.Update(con)
+
+			// Convert logs into batches of log mappings (eventName => []types.Logs
+			convertedLogs, convertErr := tr.Converter.ConvertBatch(logs, con.Events, header.ID)
+			if convertErr != nil {
+				return fmt.Errorf("error converting logs: %s", convertErr.Error())
+			}
+			// Cycle through each type of event log and persist them
+			for eventName, logs := range convertedLogs {
+				// If logs for this event are empty, mark them checked at this header and continue
+				if len(logs) < 1 {
+					logrus.Tracef("no logs found for event %s on contract %s at block %d, continuing", eventName, conAddr, header.BlockNumber)
+					continue
+				}
+				// If logs aren't empty, persist them
+				persistErr := tr.EventRepository.PersistLogs(logs, con.Events[eventName], con.Address, con.Name)
+				if persistErr != nil {
+					return fmt.Errorf("error persisting logs: %s", persistErr.Error())
+				}
+			}
+		}
+
+		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, tr.eventIds)
+		if markCheckedErr != nil {
+			return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
+		}
+
+		// Poll contracts at this block height
+		pollingErr := tr.methodPolling(header, tr.sortedMethodIds)
+		if pollingErr != nil {
+			return fmt.Errorf("error polling methods: %s", pollingErr.Error())
+		}
+		// Success; setup to start at the next header
+		tr.Start = header.BlockNumber + 1
+	}
+
+	return nil
+}
+
+// Used to poll contract methods at a given header
+func (tr *Transformer) methodPolling(header core.Header, sortedMethodIds map[string][]string) error {
+	for _, con := range tr.Contracts {
+		// Skip method polling processes if no methods are specified
+		// Also don't try to poll methods below this contract's specified starting block
+		if len(con.Methods) == 0 || header.BlockNumber < con.StartingBlock {
+			logrus.Tracef("not polling contract: %s", con.Address)
+			continue
+		}
+
+		// Poll all methods for this contract at this header
+		pollingErr := tr.Poller.PollContractAt(*con, header.BlockNumber)
+		if pollingErr != nil {
+			return fmt.Errorf("error polling contract %s: %s", con.Address, pollingErr.Error())
+		}
+
+		// Mark this header checked for the methods
+		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, sortedMethodIds[con.Address])
+		if markCheckedErr != nil {
+			return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
+		}
+	}
+
+	return nil
+}
+
+// GetConfig returns the transformers config; satisfies the transformer interface
+func (tr *Transformer) GetConfig() config.ContractConfig {
+	return tr.Config
+}

pkg/eth/contract_watcher/header/transformer/transformer_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestTransformer(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Header Sync Transformer Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/header/transformer/transformer_test.go

@@ -0,0 +1,138 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package transformer_test
+
+import (
+	"database/sql"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/transformer"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
+)
+
+var _ = Describe("Transformer", func() {
+	var fakeAddress = "0x1234567890abcdef"
+	Describe("Init", func() {
+		It("Initializes transformer's contract objects", func() {
+			blockRetriever := &fakes.MockHeaderSyncBlockRetriever{}
+			firstBlock := int64(1)
+			blockRetriever.FirstBlock = firstBlock
+
+			parsr := &fakes.MockParser{}
+			fakeAbi := "fake_abi"
+			parsr.AbiToReturn = fakeAbi
+
+			pollr := &fakes.MockPoller{}
+			fakeContractName := "fake_contract_name"
+			pollr.ContractName = fakeContractName
+
+			t := getFakeTransformer(blockRetriever, parsr, pollr)
+
+			err := t.Init()
+
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[fakeAddress]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(firstBlock))
+			Expect(c.Abi).To(Equal(fakeAbi))
+			Expect(c.Name).To(Equal(fakeContractName))
+			Expect(c.Address).To(Equal(fakeAddress))
+		})
+
+		It("Fails to initialize if first block cannot be fetched from vDB headers table", func() {
+			blockRetriever := &fakes.MockHeaderSyncBlockRetriever{}
+			blockRetriever.FirstBlockErr = fakes.FakeError
+			t := getFakeTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
+
+			err := t.Init()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(fakes.FakeError.Error()))
+		})
+	})
+
+	Describe("Execute", func() {
+		It("Executes contract transformations", func() {
+			blockRetriever := &fakes.MockHeaderSyncBlockRetriever{}
+			firstBlock := int64(1)
+			blockRetriever.FirstBlock = firstBlock
+
+			parsr := &fakes.MockParser{}
+			fakeAbi := "fake_abi"
+			parsr.AbiToReturn = fakeAbi
+
+			pollr := &fakes.MockPoller{}
+			fakeContractName := "fake_contract_name"
+			pollr.ContractName = fakeContractName
+
+			t := getFakeTransformer(blockRetriever, parsr, pollr)
+
+			err := t.Init()
+
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[fakeAddress]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(firstBlock))
+			Expect(c.Abi).To(Equal(fakeAbi))
+			Expect(c.Name).To(Equal(fakeContractName))
+			Expect(c.Address).To(Equal(fakeAddress))
+		})
+
+		It("uses first block from config if vDB headers table has no rows", func() {
+			blockRetriever := &fakes.MockHeaderSyncBlockRetriever{}
+			blockRetriever.FirstBlockErr = sql.ErrNoRows
+			t := getFakeTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
+
+			err := t.Init()
+
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("returns error if fetching first block fails for other reason", func() {
+			blockRetriever := &fakes.MockHeaderSyncBlockRetriever{}
+			blockRetriever.FirstBlockErr = fakes.FakeError
+			t := getFakeTransformer(blockRetriever, &fakes.MockParser{}, &fakes.MockPoller{})
+
+			err := t.Init()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(fakes.FakeError.Error()))
+		})
+	})
+})
+
+func getFakeTransformer(blockRetriever retriever.BlockRetriever, parsr parser.Parser, pollr poller.Poller) transformer.Transformer {
+	return transformer.Transformer{
+		Parser:           parsr,
+		Retriever:        blockRetriever,
+		Poller:           pollr,
+		HeaderRepository: &fakes.MockHeaderSyncHeaderRepository{},
+		Contracts:        map[string]*contract.Contract{},
+		Config:           mocks.MockConfig,
+	}
+}

pkg/eth/contract_watcher/shared/constants/interface.go

@@ -0,0 +1,129 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package constants
+
+import (
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// SupportsInterfaceABI is the basic abi needed to check which interfaces are adhered to
+var SupportsInterfaceABI = `[{"constant":true,"inputs":[{"name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"}]`
+
+// Individual event interfaces for constructing ABI from
+var AddrChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"a","type":"address"}],"name":"AddrChanged","type":"event"}`
+var ContentChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes32"}],"name":"ContentChanged","type":"event"}`
+var NameChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"name","type":"string"}],"name":"NameChanged","type":"event"}`
+var AbiChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":true,"name":"contentType","type":"uint256"}],"name":"ABIChanged","type":"event"}`
+var PubkeyChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"x","type":"bytes32"},{"indexed":false,"name":"y","type":"bytes32"}],"name":"PubkeyChanged","type":"event"}`
+var TextChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"indexedKey","type":"string"},{"indexed":false,"name":"key","type":"string"}],"name":"TextChanged","type":"event"}`
+var MultihashChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes"}],"name":"MultihashChanged","type":"event"}`
+var ContenthashChangeInterface = `{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes"}],"name":"ContenthashChanged","type":"event"}`
+
+// Resolver interface signatures
+type Interface int
+
+// Interface enums
+const (
+	MetaSig Interface = iota
+	AddrChangeSig
+	ContentChangeSig
+	NameChangeSig
+	AbiChangeSig
+	PubkeyChangeSig
+	TextChangeSig
+	MultihashChangeSig
+	ContentHashChangeSig
+)
+
+// Hex returns the hex signature for an interface
+func (e Interface) Hex() string {
+	strings := [...]string{
+		"0x01ffc9a7",
+		"0x3b3b57de",
+		"0xd8389dc5",
+		"0x691f3431",
+		"0x2203ab56",
+		"0xc8690233",
+		"0x59d1d43c",
+		"0xe89401a1",
+		"0xbc1c58d1",
+	}
+
+	if e < MetaSig || e > ContentHashChangeSig {
+		return "Unknown"
+	}
+
+	return strings[e]
+}
+
+// Bytes returns the bytes signature for an interface
+func (e Interface) Bytes() [4]uint8 {
+	if e < MetaSig || e > ContentHashChangeSig {
+		return [4]byte{}
+	}
+
+	str := e.Hex()
+	by, _ := hexutil.Decode(str)
+	var byArray [4]uint8
+	for i := 0; i < 4; i++ {
+		byArray[i] = by[i]
+	}
+
+	return byArray
+}
+
+// EventSig returns the event signature for an interface
+func (e Interface) EventSig() string {
+	strings := [...]string{
+		"",
+		"AddrChanged(bytes32,address)",
+		"ContentChanged(bytes32,bytes32)",
+		"NameChanged(bytes32,string)",
+		"ABIChanged(bytes32,uint256)",
+		"PubkeyChanged(bytes32,bytes32,bytes32)",
+		"TextChanged(bytes32,string,string)",
+		"MultihashChanged(bytes32,bytes)",
+		"ContenthashChanged(bytes32,bytes)",
+	}
+
+	if e < MetaSig || e > ContentHashChangeSig {
+		return "Unknown"
+	}
+
+	return strings[e]
+}
+
+// MethodSig returns the method signature for an interface
+func (e Interface) MethodSig() string {
+	strings := [...]string{
+		"supportsInterface(bytes4)",
+		"addr(bytes32)",
+		"content(bytes32)",
+		"name(bytes32)",
+		"ABI(bytes32,uint256)",
+		"pubkey(bytes32)",
+		"text(bytes32,string)",
+		"multihash(bytes32)",
+		"setContenthash(bytes32,bytes)",
+	}
+
+	if e < MetaSig || e > ContentHashChangeSig {
+		return "Unknown"
+	}
+
+	return strings[e]
+}

pkg/eth/contract_watcher/shared/contract/contract.go

@@ -0,0 +1,172 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package contract
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/filters"
+)
+
+// Contract object to hold our contract data
+type Contract struct {
+	Name           string                       // Name of the contract
+	Address        string                       // Address of the contract
+	Network        string                       // Network on which the contract is deployed; default empty "" is Ethereum mainnet
+	StartingBlock  int64                        // Starting block of the contract
+	Abi            string                       // Abi string
+	ParsedAbi      abi.ABI                      // Parsed abi
+	Events         map[string]types.Event       // List of events to watch
+	Methods        []types.Method               // List of methods to poll
+	Filters        map[string]filters.LogFilter // Map of event filters to their event names; used only for full sync watcher
+	FilterArgs     map[string]bool              // User-input list of values to filter event logs for
+	MethodArgs     map[string]bool              // User-input list of values to limit method polling to
+	EmittedAddrs   map[interface{}]bool         // List of all unique addresses collected from converted event logs
+	EmittedHashes  map[interface{}]bool         // List of all unique hashes collected from converted event logs
+	CreateAddrList bool                         // Whether or not to persist address list to postgres
+	CreateHashList bool                         // Whether or not to persist hash list to postgres
+	Piping         bool                         // Whether or not to pipe method results forward as arguments to subsequent methods
+}
+
+// Init initializes a contract object
+// If we will be calling methods that use addr, hash, or byte arrays
+// as arguments then we initialize maps to hold these types of values
+func (c Contract) Init() *Contract {
+	for _, method := range c.Methods {
+		for _, arg := range method.Args {
+			switch arg.Type.T {
+			case abi.AddressTy:
+				c.EmittedAddrs = map[interface{}]bool{}
+			case abi.HashTy, abi.BytesTy, abi.FixedBytesTy:
+				c.EmittedHashes = map[interface{}]bool{}
+			default:
+			}
+		}
+	}
+
+	return &c
+}
+
+// GenerateFilters uses contract info to generate event filters - full sync contract watcher only
+func (c *Contract) GenerateFilters() error {
+	c.Filters = map[string]filters.LogFilter{}
+
+	for name, event := range c.Events {
+		c.Filters[name] = filters.LogFilter{
+			Name:      c.Address + "_" + event.Name,
+			FromBlock: c.StartingBlock,
+			ToBlock:   -1,
+			Address:   common.HexToAddress(c.Address).Hex(),
+			Topics:    core.Topics{event.Sig().Hex()},
+		}
+	}
+	// If no filters were generated, throw an error (no point in continuing with this contract)
+	if len(c.Filters) == 0 {
+		return errors.New("error: no filters created")
+	}
+
+	return nil
+}
+
+// WantedEventArg returns true if address is in list of arguments to
+// filter events for or if no filtering is specified
+func (c *Contract) WantedEventArg(arg string) bool {
+	if c.FilterArgs == nil {
+		return false
+	} else if len(c.FilterArgs) == 0 {
+		return true
+	} else if a, ok := c.FilterArgs[arg]; ok {
+		return a
+	}
+
+	return false
+}
+
+// WantedMethodArg returns true if address is in list of arguments to
+// poll methods with or if no filtering is specified
+func (c *Contract) WantedMethodArg(arg interface{}) bool {
+	if c.MethodArgs == nil {
+		return false
+	} else if len(c.MethodArgs) == 0 {
+		return true
+	}
+
+	// resolve interface to one of the three types we handle as arguments
+	str := StringifyArg(arg)
+
+	// See if it's hex string has been filtered for
+	if a, ok := c.MethodArgs[str]; ok {
+		return a
+	}
+
+	return false
+}
+
+// PassesEventFilter returns true if any mapping value matches filtered for address or if no filter exists
+// Used to check if an event log name-value mapping should be filtered or not
+func (c *Contract) PassesEventFilter(args map[string]string) bool {
+	for _, arg := range args {
+		if c.WantedEventArg(arg) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// AddEmittedAddr adds event emitted addresses to our list if it passes filter and method polling is on
+func (c *Contract) AddEmittedAddr(addresses ...interface{}) {
+	for _, addr := range addresses {
+		if c.WantedMethodArg(addr) && c.Methods != nil {
+			c.EmittedAddrs[addr] = true
+		}
+	}
+}
+
+// AddEmittedHash adds event emitted hashes to our list if it passes filter and method polling is on
+func (c *Contract) AddEmittedHash(hashes ...interface{}) {
+	for _, hash := range hashes {
+		if c.WantedMethodArg(hash) && c.Methods != nil {
+			c.EmittedHashes[hash] = true
+		}
+	}
+}
+
+// StringifyArg resolves a method argument type to string type
+func StringifyArg(arg interface{}) (str string) {
+	switch arg.(type) {
+	case string:
+		str = arg.(string)
+	case common.Address:
+		a := arg.(common.Address)
+		str = a.String()
+	case common.Hash:
+		a := arg.(common.Hash)
+		str = a.String()
+	case []byte:
+		a := arg.([]byte)
+		str = hexutil.Encode(a)
+	}
+
+	return
+}

pkg/eth/contract_watcher/shared/contract/contract_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package contract_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestContract(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Contract Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/shared/contract/contract_test.go

@@ -0,0 +1,236 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package contract_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+)
+
+var _ = Describe("Contract", func() {
+	var err error
+	var info *contract.Contract
+	var wantedEvents = []string{"Transfer", "Approval"}
+
+	Describe("GenerateFilters", func() {
+
+		It("Generates filters from contract data", func() {
+			info = test_helpers.SetupTusdContract(wantedEvents, nil)
+			err = info.GenerateFilters()
+			Expect(err).ToNot(HaveOccurred())
+
+			val, ok := info.Filters["Transfer"]
+			Expect(ok).To(Equal(true))
+			Expect(val).To(Equal(mocks.ExpectedTransferFilter))
+
+			val, ok = info.Filters["Approval"]
+			Expect(ok).To(Equal(true))
+			Expect(val).To(Equal(mocks.ExpectedApprovalFilter))
+
+			val, ok = info.Filters["Mint"]
+			Expect(ok).To(Equal(false))
+
+		})
+
+		It("Fails with an empty contract", func() {
+			info = &contract.Contract{}
+			err = info.GenerateFilters()
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("IsEventAddr", func() {
+
+		BeforeEach(func() {
+			info = &contract.Contract{}
+			info.MethodArgs = map[string]bool{}
+			info.FilterArgs = map[string]bool{}
+		})
+
+		It("Returns true if address is in event address filter list", func() {
+			info.FilterArgs["testAddress1"] = true
+			info.FilterArgs["testAddress2"] = true
+
+			is := info.WantedEventArg("testAddress1")
+			Expect(is).To(Equal(true))
+			is = info.WantedEventArg("testAddress2")
+			Expect(is).To(Equal(true))
+
+			info.MethodArgs["testAddress3"] = true
+			is = info.WantedEventArg("testAddress3")
+			Expect(is).To(Equal(false))
+		})
+
+		It("Returns true if event address filter is empty (no filter)", func() {
+			is := info.WantedEventArg("testAddress1")
+			Expect(is).To(Equal(true))
+			is = info.WantedEventArg("testAddress2")
+			Expect(is).To(Equal(true))
+		})
+
+		It("Returns false if address is not in event address filter list", func() {
+			info.FilterArgs["testAddress1"] = true
+			info.FilterArgs["testAddress2"] = true
+
+			is := info.WantedEventArg("testAddress3")
+			Expect(is).To(Equal(false))
+		})
+
+		It("Returns false if event address filter is nil (block all)", func() {
+			info.FilterArgs = nil
+
+			is := info.WantedEventArg("testAddress1")
+			Expect(is).To(Equal(false))
+			is = info.WantedEventArg("testAddress2")
+			Expect(is).To(Equal(false))
+		})
+	})
+
+	Describe("IsMethodAddr", func() {
+		BeforeEach(func() {
+			info = &contract.Contract{}
+			info.MethodArgs = map[string]bool{}
+			info.FilterArgs = map[string]bool{}
+		})
+
+		It("Returns true if address is in method address filter list", func() {
+			info.MethodArgs["testAddress1"] = true
+			info.MethodArgs["testAddress2"] = true
+
+			is := info.WantedMethodArg("testAddress1")
+			Expect(is).To(Equal(true))
+			is = info.WantedMethodArg("testAddress2")
+			Expect(is).To(Equal(true))
+
+			info.FilterArgs["testAddress3"] = true
+			is = info.WantedMethodArg("testAddress3")
+			Expect(is).To(Equal(false))
+		})
+
+		It("Returns true if method address filter list is empty (no filter)", func() {
+			is := info.WantedMethodArg("testAddress1")
+			Expect(is).To(Equal(true))
+			is = info.WantedMethodArg("testAddress2")
+			Expect(is).To(Equal(true))
+		})
+
+		It("Returns false if address is not in method address filter list", func() {
+			info.MethodArgs["testAddress1"] = true
+			info.MethodArgs["testAddress2"] = true
+
+			is := info.WantedMethodArg("testAddress3")
+			Expect(is).To(Equal(false))
+		})
+
+		It("Returns false if method address filter list is nil (block all)", func() {
+			info.MethodArgs = nil
+
+			is := info.WantedMethodArg("testAddress1")
+			Expect(is).To(Equal(false))
+			is = info.WantedMethodArg("testAddress2")
+			Expect(is).To(Equal(false))
+		})
+	})
+
+	Describe("PassesEventFilter", func() {
+		var mapping map[string]string
+		BeforeEach(func() {
+			info = &contract.Contract{}
+			info.FilterArgs = map[string]bool{}
+			mapping = map[string]string{}
+
+		})
+
+		It("Return true if event log name-value mapping has filtered for address as a value", func() {
+			info.FilterArgs["testAddress1"] = true
+			info.FilterArgs["testAddress2"] = true
+
+			mapping["testInputName1"] = "testAddress1"
+			mapping["testInputName2"] = "testAddress2"
+			mapping["testInputName3"] = "testAddress3"
+
+			pass := info.PassesEventFilter(mapping)
+			Expect(pass).To(Equal(true))
+		})
+
+		It("Return true if event address filter list is empty (no filter)", func() {
+			mapping["testInputName1"] = "testAddress1"
+			mapping["testInputName2"] = "testAddress2"
+			mapping["testInputName3"] = "testAddress3"
+
+			pass := info.PassesEventFilter(mapping)
+			Expect(pass).To(Equal(true))
+		})
+
+		It("Return false if event log name-value mapping does not have filtered for address as a value", func() {
+			info.FilterArgs["testAddress1"] = true
+			info.FilterArgs["testAddress2"] = true
+
+			mapping["testInputName3"] = "testAddress3"
+
+			pass := info.PassesEventFilter(mapping)
+			Expect(pass).To(Equal(false))
+		})
+
+		It("Return false if event address filter list is nil (block all)", func() {
+			info.FilterArgs = nil
+
+			mapping["testInputName1"] = "testAddress1"
+			mapping["testInputName2"] = "testAddress2"
+			mapping["testInputName3"] = "testAddress3"
+
+			pass := info.PassesEventFilter(mapping)
+			Expect(pass).To(Equal(false))
+		})
+	})
+
+	Describe("AddEmittedAddr", func() {
+		BeforeEach(func() {
+			info = &contract.Contract{}
+			info.FilterArgs = map[string]bool{}
+			info.MethodArgs = map[string]bool{}
+			info.Methods = []types.Method{}
+			info.EmittedAddrs = map[interface{}]bool{}
+		})
+
+		It("Adds address to list if it is on the method filter address list", func() {
+			info.MethodArgs["testAddress2"] = true
+			info.AddEmittedAddr("testAddress2")
+			b := info.EmittedAddrs["testAddress2"]
+			Expect(b).To(Equal(true))
+		})
+
+		It("Adds address to list if method filter is empty", func() {
+			info.AddEmittedAddr("testAddress2")
+			b := info.EmittedAddrs["testAddress2"]
+			Expect(b).To(Equal(true))
+		})
+
+		It("Does not add address to list if both filters are closed (nil)", func() {
+			info.FilterArgs = nil // close both
+			info.MethodArgs = nil
+			info.AddEmittedAddr("testAddress1")
+			b := info.EmittedAddrs["testAddress1"]
+			Expect(b).To(Equal(false))
+		})
+	})
+})

pkg/eth/contract_watcher/shared/fetcher/fetcher.go

@@ -0,0 +1,124 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package fetcher
+
+import (
+	"fmt"
+	"log"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+// Fetcher serves as the lower level data fetcher that calls the underlying
+// blockchain's FetchConctractData method for a given return type
+
+// FetcherInterface is the interface definition for a fetcher
+type FetcherInterface interface {
+	FetchBigInt(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (big.Int, error)
+	FetchBool(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (bool, error)
+	FetchAddress(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (common.Address, error)
+	FetchString(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (string, error)
+	FetchHash(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (common.Hash, error)
+}
+
+// Used to create a new Fetcher error for a given error and fetch method
+func newFetcherError(err error, fetchMethod string) *fetcherError {
+	e := fetcherError{err.Error(), fetchMethod}
+	log.Println(e.Error())
+	return &e
+}
+
+// Fetcher struct
+type Fetcher struct {
+	BlockChain core.BlockChain // Underlying Blockchain
+}
+
+// Fetcher error
+type fetcherError struct {
+	err         string
+	fetchMethod string
+}
+
+// Error method
+func (fe *fetcherError) Error() string {
+	return fmt.Sprintf("Error fetching %s: %s", fe.fetchMethod, fe.err)
+}
+
+//  Generic Fetcher methods used by Getters to call contract methods
+
+// FetchBigInt is the method used to fetch big.Int value from contract
+func (f Fetcher) FetchBigInt(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (big.Int, error) {
+	var result = new(big.Int)
+	err := f.BlockChain.FetchContractData(contractAbi, contractAddress, method, methodArgs, &result, blockNumber)
+
+	if err != nil {
+		return *result, newFetcherError(err, method)
+	}
+
+	return *result, nil
+}
+
+// FetchBool is the method used to fetch bool value from contract
+func (f Fetcher) FetchBool(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (bool, error) {
+	var result = new(bool)
+	err := f.BlockChain.FetchContractData(contractAbi, contractAddress, method, methodArgs, &result, blockNumber)
+
+	if err != nil {
+		return *result, newFetcherError(err, method)
+	}
+
+	return *result, nil
+}
+
+// FetchAddress is the method used to fetch address value from contract
+func (f Fetcher) FetchAddress(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (common.Address, error) {
+	var result = new(common.Address)
+	err := f.BlockChain.FetchContractData(contractAbi, contractAddress, method, methodArgs, &result, blockNumber)
+
+	if err != nil {
+		return *result, newFetcherError(err, method)
+	}
+
+	return *result, nil
+}
+
+// FetchString is the method used to fetch string value from contract
+func (f Fetcher) FetchString(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (string, error) {
+	var result = new(string)
+	err := f.BlockChain.FetchContractData(contractAbi, contractAddress, method, methodArgs, &result, blockNumber)
+
+	if err != nil {
+		return *result, newFetcherError(err, method)
+	}
+
+	return *result, nil
+}
+
+// FetchHash is the method used to fetch hash value from contract
+func (f Fetcher) FetchHash(method, contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (common.Hash, error) {
+	var result = new(common.Hash)
+	err := f.BlockChain.FetchContractData(contractAbi, contractAddress, method, methodArgs, &result, blockNumber)
+
+	if err != nil {
+		return *result, newFetcherError(err, method)
+	}
+
+	return *result, nil
+}

pkg/eth/contract_watcher/shared/getter/getter_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package getter_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRepository(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Getter Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/shared/getter/getter_test.go

@@ -0,0 +1,57 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package getter_test
+
+import (
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/getter"
+	rpc2 "github.com/vulcanize/vulcanizedb/pkg/eth/converters/rpc"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/node"
+	"github.com/vulcanize/vulcanizedb/test_config"
+)
+
+var _ = Describe("Interface Getter", func() {
+	Describe("GetAbi", func() {
+		It("Constructs and returns a custom abi based on results from supportsInterface calls", func() {
+			expectedABI := `[` + constants.AddrChangeInterface + `,` + constants.NameChangeInterface + `,` + constants.ContentChangeInterface + `,` + constants.AbiChangeInterface + `,` + constants.PubkeyChangeInterface + `]`
+			con := test_config.TestClient
+			testIPC := con.IPCPath
+			blockNumber := int64(6885696)
+			rawRpcClient, err := rpc.Dial(testIPC)
+			Expect(err).NotTo(HaveOccurred())
+			rpcClient := client.NewRPCClient(rawRpcClient, testIPC)
+			ethClient := ethclient.NewClient(rawRpcClient)
+			blockChainClient := client.NewEthClient(ethClient)
+			node := node.MakeNode(rpcClient)
+			transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
+			blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
+			interfaceGetter := getter.NewInterfaceGetter(blockChain)
+			abi, err := interfaceGetter.GetABI(constants.PublicResolverAddress, blockNumber)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(abi).To(Equal(expectedABI))
+			_, err = eth.ParseAbi(abi)
+			Expect(err).ToNot(HaveOccurred())
+		})
+	})
+})

pkg/eth/contract_watcher/shared/getter/interface_getter.go

@@ -0,0 +1,113 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package getter
+
+import (
+	"fmt"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+// InterfaceGetter is used to derive the interface of a contract
+type InterfaceGetter interface {
+	GetABI(resolverAddr string, blockNumber int64) (string, error)
+	GetBlockChain() core.BlockChain
+}
+
+type interfaceGetter struct {
+	fetcher.Fetcher
+}
+
+// NewInterfaceGetter returns a new InterfaceGetter
+func NewInterfaceGetter(blockChain core.BlockChain) InterfaceGetter {
+	return &interfaceGetter{
+		Fetcher: fetcher.Fetcher{
+			BlockChain: blockChain,
+		},
+	}
+}
+
+// GetABI is used to construct a custom ABI based on the results from calling supportsInterface
+func (g *interfaceGetter) GetABI(resolverAddr string, blockNumber int64) (string, error) {
+	a := constants.SupportsInterfaceABI
+	args := make([]interface{}, 1)
+	args[0] = constants.MetaSig.Bytes()
+	supports, err := g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err != nil {
+		return "", fmt.Errorf("call to getSupportsInterface failed: %v", err)
+	}
+	if !supports {
+		return "", fmt.Errorf("contract does not support interface")
+	}
+
+	abiStr := `[`
+	args[0] = constants.AddrChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.AddrChangeInterface + ","
+	}
+	args[0] = constants.NameChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.NameChangeInterface + ","
+	}
+	args[0] = constants.ContentChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.ContentChangeInterface + ","
+	}
+	args[0] = constants.AbiChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.AbiChangeInterface + ","
+	}
+	args[0] = constants.PubkeyChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.PubkeyChangeInterface + ","
+	}
+	args[0] = constants.ContentHashChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.ContenthashChangeInterface + ","
+	}
+	args[0] = constants.MultihashChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.MultihashChangeInterface + ","
+	}
+	args[0] = constants.TextChangeSig.Bytes()
+	supports, err = g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err == nil && supports {
+		abiStr += constants.TextChangeInterface + ","
+	}
+	abiStr = abiStr[:len(abiStr)-1] + `]`
+
+	return abiStr, nil
+}
+
+// Use this method to check whether or not a contract supports a given method/event interface
+func (g *interfaceGetter) getSupportsInterface(contractAbi, contractAddress string, blockNumber int64, methodArgs []interface{}) (bool, error) {
+	return g.Fetcher.FetchBool("supportsInterface", contractAbi, contractAddress, blockNumber, methodArgs)
+}
+
+// GetBlockChain is a method to retrieve the Getter's blockchain
+func (g *interfaceGetter) GetBlockChain() core.BlockChain {
+	return g.Fetcher.BlockChain
+}

pkg/eth/contract_watcher/shared/helpers/helpers.go

@@ -0,0 +1,72 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package helpers
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+// ConvertToLog converts a watched event to a log
+func ConvertToLog(watchedEvent core.WatchedEvent) types.Log {
+	allTopics := []string{watchedEvent.Topic0, watchedEvent.Topic1, watchedEvent.Topic2, watchedEvent.Topic3}
+	var nonNilTopics []string
+	for _, topic := range allTopics {
+		if topic != "" {
+			nonNilTopics = append(nonNilTopics, topic)
+		}
+	}
+	return types.Log{
+		Address:     common.HexToAddress(watchedEvent.Address),
+		Topics:      createTopics(nonNilTopics...),
+		Data:        hexutil.MustDecode(watchedEvent.Data),
+		BlockNumber: uint64(watchedEvent.BlockNumber),
+		TxHash:      common.HexToHash(watchedEvent.TxHash),
+		TxIndex:     0,
+		BlockHash:   common.HexToHash("0x0"),
+		Index:       uint(watchedEvent.Index),
+		Removed:     false,
+	}
+}
+
+func createTopics(topics ...string) []common.Hash {
+	var topicsArray []common.Hash
+	for _, topic := range topics {
+		topicsArray = append(topicsArray, common.HexToHash(topic))
+	}
+	return topicsArray
+}
+
+// BigFromString creates a big.Int from a string
+func BigFromString(n string) *big.Int {
+	b := new(big.Int)
+	b.SetString(n, 10)
+	return b
+}
+
+// GenerateSignature returns the keccak256 hash hex of a string
+func GenerateSignature(s string) string {
+	eventSignature := []byte(s)
+	hash := crypto.Keccak256Hash(eventSignature)
+	return hash.Hex()
+}

pkg/eth/contract_watcher/shared/helpers/test_helpers/database.go

@@ -0,0 +1,296 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package test_helpers
+
+import (
+	"math/rand"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	rpc2 "github.com/vulcanize/vulcanizedb/pkg/eth/converters/rpc"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/node"
+	"github.com/vulcanize/vulcanizedb/test_config"
+)
+
+type TransferLog struct {
+	ID             int64  `db:"id"`
+	VulcanizeLogID int64  `db:"vulcanize_log_id"`
+	TokenName      string `db:"token_name"`
+	Block          int64  `db:"block"`
+	Tx             string `db:"tx"`
+	From           string `db:"from_"`
+	To             string `db:"to_"`
+	Value          string `db:"value_"`
+}
+
+type NewOwnerLog struct {
+	ID             int64  `db:"id"`
+	VulcanizeLogID int64  `db:"vulcanize_log_id"`
+	TokenName      string `db:"token_name"`
+	Block          int64  `db:"block"`
+	Tx             string `db:"tx"`
+	Node           string `db:"node_"`
+	Label          string `db:"label_"`
+	Owner          string `db:"owner_"`
+}
+
+type HeaderSyncTransferLog struct {
+	ID        int64  `db:"id"`
+	HeaderID  int64  `db:"header_id"`
+	TokenName string `db:"token_name"`
+	LogIndex  int64  `db:"log_idx"`
+	TxIndex   int64  `db:"tx_idx"`
+	From      string `db:"from_"`
+	To        string `db:"to_"`
+	Value     string `db:"value_"`
+	RawLog    []byte `db:"raw_log"`
+}
+
+type HeaderSyncNewOwnerLog struct {
+	ID        int64  `db:"id"`
+	HeaderID  int64  `db:"header_id"`
+	TokenName string `db:"token_name"`
+	LogIndex  int64  `db:"log_idx"`
+	TxIndex   int64  `db:"tx_idx"`
+	Node      string `db:"node_"`
+	Label     string `db:"label_"`
+	Owner     string `db:"owner_"`
+	RawLog    []byte `db:"raw_log"`
+}
+
+type BalanceOf struct {
+	ID        int64  `db:"id"`
+	TokenName string `db:"token_name"`
+	Block     int64  `db:"block"`
+	Address   string `db:"who_"`
+	Balance   string `db:"returned"`
+}
+
+type Resolver struct {
+	ID        int64  `db:"id"`
+	TokenName string `db:"token_name"`
+	Block     int64  `db:"block"`
+	Node      string `db:"node_"`
+	Address   string `db:"returned"`
+}
+
+type Owner struct {
+	ID        int64  `db:"id"`
+	TokenName string `db:"token_name"`
+	Block     int64  `db:"block"`
+	Node      string `db:"node_"`
+	Address   string `db:"returned"`
+}
+
+func SetupDBandBC() (*postgres.DB, core.BlockChain) {
+	con := test_config.TestClient
+	testIPC := con.IPCPath
+	rawRPCClient, err := rpc.Dial(testIPC)
+	Expect(err).NotTo(HaveOccurred())
+	rpcClient := client.NewRPCClient(rawRPCClient, testIPC)
+	ethClient := ethclient.NewClient(rawRPCClient)
+	blockChainClient := client.NewEthClient(ethClient)
+	madeNode := node.MakeNode(rpcClient)
+	transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
+	blockChain := eth.NewBlockChain(blockChainClient, rpcClient, madeNode, transactionConverter)
+
+	db, err := postgres.NewDB(config.Database{
+		Hostname: "localhost",
+		Name:     "vulcanize_testing",
+		Port:     5432,
+	}, blockChain.Node())
+	Expect(err).NotTo(HaveOccurred())
+
+	return db, blockChain
+}
+
+func SetupTusdRepo(vulcanizeLogID *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
+	db, err := postgres.NewDB(config.Database{
+		Hostname: "localhost",
+		Name:     "vulcanize_testing",
+		Port:     5432,
+	}, core.Node{})
+	Expect(err).NotTo(HaveOccurred())
+
+	receiptRepository := repositories.FullSyncReceiptRepository{DB: db}
+	logRepository := repositories.FullSyncLogRepository{DB: db}
+	blockRepository := *repositories.NewBlockRepository(db)
+
+	blockNumber := rand.Int63()
+	blockID := CreateBlock(blockNumber, blockRepository)
+
+	receipts := []core.Receipt{{Logs: []core.FullSyncLog{{}}}}
+
+	err = receiptRepository.CreateReceiptsAndLogs(blockID, receipts)
+	Expect(err).ToNot(HaveOccurred())
+
+	err = logRepository.Get(vulcanizeLogID, `SELECT id FROM full_sync_logs`)
+	Expect(err).ToNot(HaveOccurred())
+
+	info := SetupTusdContract(wantedEvents, wantedMethods)
+
+	return db, info
+}
+
+func SetupTusdContract(wantedEvents, wantedMethods []string) *contract.Contract {
+	p := mocks.NewParser(constants.TusdAbiString)
+	err := p.Parse(constants.TusdContractAddress)
+	Expect(err).ToNot(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "TrueUSD",
+		Address:       constants.TusdContractAddress,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		StartingBlock: 6194634,
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		MethodArgs:    map[string]bool{},
+		FilterArgs:    map[string]bool{},
+	}.Init()
+}
+
+func SetupENSContract(wantedEvents, wantedMethods []string) *contract.Contract {
+	p := mocks.NewParser(constants.ENSAbiString)
+	err := p.Parse(constants.EnsContractAddress)
+	Expect(err).ToNot(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "ENS-Registry",
+		Address:       constants.EnsContractAddress,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		StartingBlock: 6194634,
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		MethodArgs:    map[string]bool{},
+		FilterArgs:    map[string]bool{},
+	}.Init()
+}
+
+func SetupMarketPlaceContract(wantedEvents, wantedMethods []string) *contract.Contract {
+	p := mocks.NewParser(constants.MarketPlaceAbiString)
+	err := p.Parse(constants.MarketPlaceContractAddress)
+	Expect(err).NotTo(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "Marketplace",
+		Address:       constants.MarketPlaceContractAddress,
+		StartingBlock: 6496012,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		FilterArgs:    map[string]bool{},
+		MethodArgs:    map[string]bool{},
+	}.Init()
+}
+
+func SetupMolochContract(wantedEvents, wantedMethods []string) *contract.Contract {
+	p := mocks.NewParser(constants.MolochAbiString)
+	err := p.Parse(constants.MolochContractAddress)
+	Expect(err).NotTo(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "Moloch",
+		Address:       constants.MolochContractAddress,
+		StartingBlock: 7218566,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		FilterArgs:    map[string]bool{},
+		MethodArgs:    map[string]bool{},
+	}.Init()
+}
+
+// TODO: tear down/setup DB from migrations so this doesn't alter the schema between tests
+func TearDown(db *postgres.DB) {
+	tx, err := db.Beginx()
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM addresses`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM eth_blocks`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM headers`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM full_sync_logs`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM log_filters`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM full_sync_transactions`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec("DELETE FROM header_sync_transactions")
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM full_sync_receipts`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM header_sync_receipts`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DROP TABLE checked_headers`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`CREATE TABLE checked_headers (
+    	id SERIAL PRIMARY KEY,
+    	header_id INTEGER UNIQUE NOT NULL REFERENCES headers (id) ON DELETE CASCADE);`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DROP SCHEMA IF EXISTS full_0x8dd5fbce2f6a956c3022ba3663759011dd51e73e CASCADE`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DROP SCHEMA IF EXISTS header_0x8dd5fbce2f6a956c3022ba3663759011dd51e73e CASCADE`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DROP SCHEMA IF EXISTS full_0x314159265dd8dbb310642f98f50c066173c1259b CASCADE`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DROP SCHEMA IF EXISTS header_0x314159265dd8dbb310642f98f50c066173c1259b CASCADE`)
+	Expect(err).NotTo(HaveOccurred())
+
+	err = tx.Commit()
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = db.Exec(`VACUUM checked_headers`)
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func CreateBlock(blockNumber int64, repository repositories.BlockRepository) int64 {
+	blockID, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
+	Expect(err).NotTo(HaveOccurred())
+
+	return blockID
+}

pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks/entities.go

@@ -0,0 +1,360 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package mocks
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/filters"
+)
+
+var TransferBlock1 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+	Number: 6194633,
+	Transactions: []core.TransactionModel{{
+		GasLimit: 0,
+		GasPrice: 0,
+		Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+		Nonce:    0,
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+			ContractAddress: "",
+			Logs: []core.FullSyncLog{{
+				BlockNumber: 6194633,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+				Address:     constants.TusdContractAddress,
+				Topics: core.Topics{
+					constants.TransferEvent.Signature(),
+					"0x000000000000000000000000000000000000000000000000000000000000af21",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+			}},
+		},
+		TxIndex: 0,
+		Value:   "0",
+	}},
+}
+
+var TransferBlock2 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ooo",
+	Number: 6194634,
+	Transactions: []core.TransactionModel{{
+		GasLimit: 0,
+		GasPrice: 0,
+		Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+		Nonce:    0,
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+			ContractAddress: "",
+			Logs: []core.FullSyncLog{{
+				BlockNumber: 6194634,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+				Address:     constants.TusdContractAddress,
+				Topics: core.Topics{
+					constants.TransferEvent.Signature(),
+					"0x000000000000000000000000000000000000000000000000000000000000af21",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+			}},
+		},
+		TxIndex: 0,
+		Value:   "0",
+	}},
+}
+
+var NewOwnerBlock1 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ppp",
+	Number: 6194635,
+	Transactions: []core.TransactionModel{{
+		GasLimit: 0,
+		GasPrice: 0,
+		Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+		Nonce:    0,
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+			ContractAddress: "",
+			Logs: []core.FullSyncLog{{
+				BlockNumber: 6194635,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+				Address:     constants.EnsContractAddress,
+				Topics: core.Topics{
+					constants.NewOwnerEvent.Signature(),
+					"0x0000000000000000000000000000000000000000000000000000c02aaa39b223",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000000000000000000000000000000000000000af21",
+			}},
+		},
+		TxIndex: 0,
+		Value:   "0",
+	}},
+}
+
+var NewOwnerBlock2 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ggg",
+	Number: 6194636,
+	Transactions: []core.TransactionModel{{
+		GasLimit: 0,
+		GasPrice: 0,
+		Hash:     "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+		Nonce:    0,
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+			ContractAddress: "",
+			Logs: []core.FullSyncLog{{
+				BlockNumber: 6194636,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+				Address:     constants.EnsContractAddress,
+				Topics: core.Topics{
+					constants.NewOwnerEvent.Signature(),
+					"0x0000000000000000000000000000000000000000000000000000c02aaa39b223",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba400",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000000000000000000000000000000000000000af21",
+			}},
+		},
+		TxIndex: 0,
+		Value:   "0",
+	}},
+}
+
+var ExpectedTransferFilter = filters.LogFilter{
+	Name:      constants.TusdContractAddress + "_" + "Transfer",
+	Address:   constants.TusdContractAddress,
+	ToBlock:   -1,
+	FromBlock: 6194634,
+	Topics:    core.Topics{constants.TransferEvent.Signature()},
+}
+
+var ExpectedApprovalFilter = filters.LogFilter{
+	Name:      constants.TusdContractAddress + "_" + "Approval",
+	Address:   constants.TusdContractAddress,
+	ToBlock:   -1,
+	FromBlock: 6194634,
+	Topics:    core.Topics{constants.ApprovalEvent.Signature()},
+}
+
+var MockTranferEvent = core.WatchedEvent{
+	LogID:       1,
+	Name:        constants.TransferEvent.String(),
+	BlockNumber: 5488076,
+	Address:     constants.TusdContractAddress,
+	TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+	Index:       110,
+	Topic0:      constants.TransferEvent.Signature(),
+	Topic1:      "0x000000000000000000000000000000000000000000000000000000000000af21",
+	Topic2:      "0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+	Topic3:      "",
+	Data:        "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+}
+
+var rawFakeHeader, _ = json.Marshal(core.Header{})
+
+var MockHeader1 = core.Header{
+	Hash:        "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+	BlockNumber: 6194632,
+	Raw:         rawFakeHeader,
+	Timestamp:   "50000000",
+}
+
+var MockHeader2 = core.Header{
+	Hash:        "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+	BlockNumber: 6194633,
+	Raw:         rawFakeHeader,
+	Timestamp:   "50000015",
+}
+
+var MockHeader3 = core.Header{
+	Hash:        "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+	BlockNumber: 6194634,
+	Raw:         rawFakeHeader,
+	Timestamp:   "50000030",
+}
+
+var MockHeader4 = core.Header{
+	Hash:        "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+	BlockNumber: 6194635,
+	Raw:         rawFakeHeader,
+	Timestamp:   "50000030",
+}
+
+var MockTransferLog1 = types.Log{
+	Index:       1,
+	Address:     common.HexToAddress(constants.TusdContractAddress),
+	BlockNumber: 5488076,
+	TxIndex:     110,
+	TxHash:      common.HexToHash("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae"),
+	Topics: []common.Hash{
+		common.HexToHash(constants.TransferEvent.Signature()),
+		common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000af21"),
+		common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"),
+	},
+	Data: hexutil.MustDecode("0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe"),
+}
+
+var MockTransferLog2 = types.Log{
+	Index:       3,
+	Address:     common.HexToAddress(constants.TusdContractAddress),
+	BlockNumber: 5488077,
+	TxIndex:     2,
+	TxHash:      common.HexToHash("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546df"),
+	Topics: []common.Hash{
+		common.HexToHash(constants.TransferEvent.Signature()),
+		common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"),
+		common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000af21"),
+	},
+	Data: hexutil.MustDecode("0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe"),
+}
+
+var MockMintLog = types.Log{
+	Index:       10,
+	Address:     common.HexToAddress(constants.TusdContractAddress),
+	BlockNumber: 5488080,
+	TxIndex:     50,
+	TxHash:      common.HexToHash("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6minty"),
+	Topics: []common.Hash{
+		common.HexToHash(constants.MintEvent.Signature()),
+		common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000af21"),
+	},
+	Data: hexutil.MustDecode("0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe"),
+}
+
+var MockNewOwnerLog1 = types.Log{
+	Index:       1,
+	Address:     common.HexToAddress(constants.EnsContractAddress),
+	BlockNumber: 5488076,
+	TxIndex:     110,
+	TxHash:      common.HexToHash("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae"),
+	Topics: []common.Hash{
+		common.HexToHash(constants.NewOwnerEvent.Signature()),
+		common.HexToHash("0x000000000000000000000000c02aaa39b223helloa0e5c4f27ead9083c752553"),
+		common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"),
+	},
+	Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000af21"),
+}
+
+var MockNewOwnerLog2 = types.Log{
+	Index:       3,
+	Address:     common.HexToAddress(constants.EnsContractAddress),
+	BlockNumber: 5488077,
+	TxIndex:     2,
+	TxHash:      common.HexToHash("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546df"),
+	Topics: []common.Hash{
+		common.HexToHash(constants.NewOwnerEvent.Signature()),
+		common.HexToHash("0x000000000000000000000000c02aaa39b223helloa0e5c4f27ead9083c752553"),
+		common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba400"),
+	},
+	Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000af21"),
+}
+
+var MockOrderCreatedLog = types.Log{
+	Address: common.HexToAddress(constants.MarketPlaceContractAddress),
+	Topics: []common.Hash{
+		common.HexToHash("0x84c66c3f7ba4b390e20e8e8233e2a516f3ce34a72749e4f12bd010dfba238039"),
+		common.HexToHash("0xffffffffffffffffffffffffffffff72ffffffffffffffffffffffffffffffd0"),
+		common.HexToHash("0x00000000000000000000000083b7b6f360a9895d163ea797d9b939b9173b292a"),
+	},
+	Data:        hexutil.MustDecode("0x633f94affdcabe07c000231f85c752c97b9cc43966b432ec4d18641e6d178233000000000000000000000000f87e31492faf9a91b02ee0deaad50d51d56d5d4d0000000000000000000000000000000000000000000003da9fbcf4446d6000000000000000000000000000000000000000000000000000000000016db2524880"),
+	BlockNumber: 8587618,
+	TxHash:      common.HexToHash("0x7ad9e2f88416738f3c7ad0a6d260f71794532206a0e838299f5014b4fe81e66e"),
+	TxIndex:     93,
+	BlockHash:   common.HexToHash("0x06a1762b7f2e070793fc24cd785de0fa485e728832c4f3469790153ae51a56a2"),
+	Index:       59,
+	Removed:     false,
+}
+
+var MockSubmitVoteLog = types.Log{
+	Address: common.HexToAddress(constants.MolochContractAddress),
+	Topics: []common.Hash{
+		common.HexToHash("0x29bf0061f2faa9daa482f061b116195432d435536d8af4ae6b3c5dd78223679b"),
+		common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000061"),
+		common.HexToHash("0x0000000000000000000000006ddf1b8e6d71b5b33912607098be123ffe62ae53"),
+		common.HexToHash("0x00000000000000000000000037385081870ef47e055410fefd582e2a95d2960b"),
+	},
+	Data:        hexutil.MustDecode("0x0000000000000000000000000000000000000000000000000000000000000001"),
+	BlockNumber: 8517621,
+	TxHash:      common.HexToHash("0xcc7390a2099812d0dfc9baef201afbc7a44bfae145050c9dc700b77cbd3cd752"),
+	TxIndex:     103,
+	BlockHash:   common.HexToHash("0x3e82681d8036b1225fcaa8bcd4cdbe757b39f13468286b303cde22146385525e"),
+	Index:       132,
+	Removed:     false,
+}
+
+var ens = strings.ToLower(constants.EnsContractAddress)
+var tusd = strings.ToLower(constants.TusdContractAddress)
+
+var MockConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		"0x1234567890abcdef": true,
+	},
+	Abis: map[string]string{
+		"0x1234567890abcdef": "fake_abi",
+	},
+	Events: map[string][]string{
+		"0x1234567890abcdef": {"Transfer"},
+	},
+	Methods: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+	MethodArgs: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+	EventArgs: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+}
+
+var MockEmptyConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		"0x1234567890abcdef": true,
+	},
+	Abis: map[string]string{
+		"0x1234567890abcdef": "fake_abi",
+	},
+	Events: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+	Methods: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+	MethodArgs: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+	EventArgs: map[string][]string{
+		"0x1234567890abcdef": nil,
+	},
+}

pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks/parser.go

@@ -0,0 +1,165 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package mocks
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/vulcanize/vulcanizedb/pkg/eth"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+)
+
+// Mock parser
+// Is given ABI string instead of address
+// Performs all other functions of the real parser
+type mockParser struct {
+	abi       string
+	parsedAbi abi.ABI
+}
+
+func NewParser(abi string) parser.Parser {
+	return &mockParser{
+		abi: abi,
+	}
+}
+
+func (p *mockParser) Abi() string {
+	return p.abi
+}
+
+func (p *mockParser) ParsedAbi() abi.ABI {
+	return p.parsedAbi
+}
+
+func (p *mockParser) ParseAbiStr(abiStr string) error {
+	panic("implement me")
+}
+
+// Retrieves and parses the abi string
+// for the given contract address
+func (p *mockParser) Parse(contractAddr string) error {
+	var err error
+	p.parsedAbi, err = eth.ParseAbi(p.abi)
+
+	return err
+}
+
+// Returns only specified methods, if they meet the criteria
+// Returns as array with methods in same order they were specified
+// Nil wanted array => no events are returned
+func (p *mockParser) GetSelectMethods(wanted []string) []types.Method {
+	wLen := len(wanted)
+	if wLen == 0 {
+		return nil
+	}
+	methods := make([]types.Method, wLen)
+	for _, m := range p.parsedAbi.Methods {
+		for i, name := range wanted {
+			if name == m.Name && okTypes(m, wanted) {
+				methods[i] = types.NewMethod(m)
+			}
+		}
+	}
+
+	return methods
+}
+
+// Returns wanted methods
+// Empty wanted array => all methods are returned
+// Nil wanted array => no methods are returned
+func (p *mockParser) GetMethods(wanted []string) []types.Method {
+	if wanted == nil {
+		return nil
+	}
+	methods := make([]types.Method, 0)
+	length := len(wanted)
+	for _, m := range p.parsedAbi.Methods {
+		if length == 0 || stringInSlice(wanted, m.Name) {
+			methods = append(methods, types.NewMethod(m))
+		}
+	}
+
+	return methods
+}
+
+// Returns wanted events as map of types.Events
+// If no events are specified, all events are returned
+func (p *mockParser) GetEvents(wanted []string) map[string]types.Event {
+	events := map[string]types.Event{}
+
+	for _, e := range p.parsedAbi.Events {
+		if len(wanted) == 0 || stringInSlice(wanted, e.Name) {
+			event := types.NewEvent(e)
+			events[e.Name] = event
+		}
+	}
+
+	return events
+}
+
+func stringInSlice(list []string, s string) bool {
+	for _, b := range list {
+		if b == s {
+			return true
+		}
+	}
+
+	return false
+}
+
+func okTypes(m abi.Method, wanted []string) bool {
+	// Only return method if it has less than 3 arguments, a single output value, and it is a method we want or we want all methods (empty 'wanted' slice)
+	if len(m.Inputs) < 3 && len(m.Outputs) == 1 && (len(wanted) == 0 || stringInSlice(wanted, m.Name)) {
+		// Only return methods if inputs are all of accepted types and output is of the accepted types
+		if !okReturnType(m.Outputs[0]) {
+			return false
+		}
+		for _, input := range m.Inputs {
+			switch input.Type.T {
+			case abi.AddressTy, abi.HashTy, abi.BytesTy, abi.FixedBytesTy:
+			default:
+				return false
+			}
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func okReturnType(arg abi.Argument) bool {
+	wantedTypes := []byte{
+		abi.UintTy,
+		abi.IntTy,
+		abi.BoolTy,
+		abi.StringTy,
+		abi.AddressTy,
+		abi.HashTy,
+		abi.BytesTy,
+		abi.FixedBytesTy,
+		abi.FixedPointTy,
+	}
+
+	for _, ty := range wantedTypes {
+		if arg.Type.T == ty {
+			return true
+		}
+	}
+
+	return false
+}

pkg/eth/contract_watcher/shared/helpers/test_helpers/test_data.go

@@ -0,0 +1,109 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package test_helpers
+
+import (
+	"strings"
+
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+)
+
+var ens = strings.ToLower(constants.EnsContractAddress)
+var tusd = strings.ToLower(constants.TusdContractAddress)
+
+var TusdConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		tusd: true,
+	},
+	Abis: map[string]string{
+		tusd: "",
+	},
+	Events: map[string][]string{
+		tusd: {"Transfer"},
+	},
+	Methods: map[string][]string{
+		tusd: nil,
+	},
+	MethodArgs: map[string][]string{
+		tusd: nil,
+	},
+	EventArgs: map[string][]string{
+		tusd: nil,
+	},
+	StartingBlocks: map[string]int64{
+		tusd: 5197514,
+	},
+}
+
+var ENSConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		ens: true,
+	},
+	Abis: map[string]string{
+		ens: "",
+	},
+	Events: map[string][]string{
+		ens: {"NewOwner"},
+	},
+	Methods: map[string][]string{
+		ens: nil,
+	},
+	MethodArgs: map[string][]string{
+		ens: nil,
+	},
+	EventArgs: map[string][]string{
+		ens: nil,
+	},
+	StartingBlocks: map[string]int64{
+		ens: 3327417,
+	},
+}
+
+var ENSandTusdConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		ens:  true,
+		tusd: true,
+	},
+	Abis: map[string]string{
+		ens:  "",
+		tusd: "",
+	},
+	Events: map[string][]string{
+		ens:  {"NewOwner"},
+		tusd: {"Transfer"},
+	},
+	Methods: map[string][]string{
+		ens:  nil,
+		tusd: nil,
+	},
+	MethodArgs: map[string][]string{
+		ens:  nil,
+		tusd: nil,
+	},
+	EventArgs: map[string][]string{
+		ens:  nil,
+		tusd: nil,
+	},
+	StartingBlocks: map[string]int64{
+		ens:  3327417,
+		tusd: 5197514,
+	},
+}

pkg/eth/contract_watcher/shared/parser/parser.go

@@ -0,0 +1,221 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package parser
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+)
+
+// Parser is used to fetch and parse contract ABIs
+// It is dependent on etherscan's api
+type Parser interface {
+	Parse(contractAddr string) error
+	ParseAbiStr(abiStr string) error
+	Abi() string
+	ParsedAbi() abi.ABI
+	GetMethods(wanted []string) []types.Method
+	GetSelectMethods(wanted []string) []types.Method
+	GetEvents(wanted []string) map[string]types.Event
+}
+
+type parser struct {
+	client    *eth.EtherScanAPI
+	abi       string
+	parsedAbi abi.ABI
+}
+
+// NewParser returns a new Parser
+func NewParser(network string) Parser {
+	url := eth.GenURL(network)
+
+	return &parser{
+		client: eth.NewEtherScanClient(url),
+	}
+}
+
+// Abi returns the parser's configured abi string
+func (p *parser) Abi() string {
+	return p.abi
+}
+
+// ParsedAbi returns the parser's parsed abi
+func (p *parser) ParsedAbi() abi.ABI {
+	return p.parsedAbi
+}
+
+// Parse retrieves and parses the abi string
+// for the given contract address
+func (p *parser) Parse(contractAddr string) error {
+	// If the abi is one our locally stored abis, fetch
+	// TODO: Allow users to pass abis through config
+	knownAbi, err := p.lookUp(contractAddr)
+	if err == nil {
+		p.abi = knownAbi
+		p.parsedAbi, err = eth.ParseAbi(knownAbi)
+		return err
+	}
+	// Try getting abi from etherscan
+	abiStr, err := p.client.GetAbi(contractAddr)
+	if err != nil {
+		return err
+	}
+	//TODO: Implement other ways to fetch abi
+	p.abi = abiStr
+	p.parsedAbi, err = eth.ParseAbi(abiStr)
+
+	return err
+}
+
+// ParseAbiStr loads and parses an abi from a given abi string
+func (p *parser) ParseAbiStr(abiStr string) error {
+	var err error
+	p.abi = abiStr
+	p.parsedAbi, err = eth.ParseAbi(abiStr)
+
+	return err
+}
+
+func (p *parser) lookUp(contractAddr string) (string, error) {
+	if v, ok := constants.ABIs[common.HexToAddress(contractAddr)]; ok {
+		return v, nil
+	}
+
+	return "", errors.New("ABI not present in lookup table")
+}
+
+// GetSelectMethods returns only specified methods, if they meet the criteria
+// Returns as array with methods in same order they were specified
+// Nil or empty wanted array => no events are returned
+func (p *parser) GetSelectMethods(wanted []string) []types.Method {
+	wLen := len(wanted)
+	if wLen == 0 {
+		return nil
+	}
+	methods := make([]types.Method, wLen)
+	for _, m := range p.parsedAbi.Methods {
+		for i, name := range wanted {
+			if name == m.Name && okTypes(m, wanted) {
+				methods[i] = types.NewMethod(m)
+			}
+		}
+	}
+
+	return methods
+}
+
+// GetMethods returns wanted methods
+// Empty wanted array => all methods are returned
+// Nil wanted array => no methods are returned
+func (p *parser) GetMethods(wanted []string) []types.Method {
+	if wanted == nil {
+		return nil
+	}
+	methods := make([]types.Method, 0)
+	length := len(wanted)
+	for _, m := range p.parsedAbi.Methods {
+		if length == 0 || stringInSlice(wanted, m.Name) {
+			methods = append(methods, types.NewMethod(m))
+		}
+	}
+
+	return methods
+}
+
+// GetEvents returns wanted events as map of types.Events
+// Empty wanted array => all events are returned
+// Nil wanted array => no events are returned
+func (p *parser) GetEvents(wanted []string) map[string]types.Event {
+	events := map[string]types.Event{}
+	if wanted == nil {
+		return events
+	}
+
+	length := len(wanted)
+	for _, e := range p.parsedAbi.Events {
+		if length == 0 || stringInSlice(wanted, e.Name) {
+			events[e.Name] = types.NewEvent(e)
+		}
+	}
+
+	return events
+}
+
+func okReturnType(arg abi.Argument) bool {
+	wantedTypes := []byte{
+		abi.UintTy,
+		abi.IntTy,
+		abi.BoolTy,
+		abi.StringTy,
+		abi.AddressTy,
+		abi.HashTy,
+		abi.BytesTy,
+		abi.FixedBytesTy,
+		abi.FixedPointTy,
+	}
+
+	for _, ty := range wantedTypes {
+		if arg.Type.T == ty {
+			return true
+		}
+	}
+
+	return false
+}
+
+func okTypes(m abi.Method, wanted []string) bool {
+	// Only return method if it has less than 3 arguments, a single output value, and it is a method we want or we want all methods (empty 'wanted' slice)
+	if len(m.Inputs) < 3 && len(m.Outputs) == 1 && (len(wanted) == 0 || stringInSlice(wanted, m.Name)) {
+		// Only return methods if inputs are all of accepted types and output is of the accepted types
+		if !okReturnType(m.Outputs[0]) {
+			return false
+		}
+		for _, input := range m.Inputs {
+			switch input.Type.T {
+			// Addresses are properly labeled and caught
+			// But hashes tend to not be explicitly labeled and caught
+			// Instead bytes32 are assumed to be hashes
+			case abi.AddressTy, abi.HashTy:
+			case abi.FixedBytesTy:
+				if input.Type.Size != 32 {
+					return false
+				}
+			default:
+				return false
+			}
+		}
+		return true
+	}
+
+	return false
+}
+
+func stringInSlice(list []string, s string) bool {
+	for _, b := range list {
+		if b == s {
+			return true
+		}
+	}
+
+	return false
+}

pkg/eth/contract_watcher/shared/parser/parser_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package parser_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestParser(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Parser Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/shared/parser/parser_test.go

@@ -0,0 +1,226 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package parser_test
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+)
+
+var _ = Describe("Parser", func() {
+
+	var p parser.Parser
+	var err error
+
+	BeforeEach(func() {
+		p = parser.NewParser("")
+	})
+
+	Describe("Mock Parse", func() {
+		It("Uses parses given abi string", func() {
+			mp := mocks.NewParser(constants.DaiAbiString)
+			err = mp.Parse(constants.DaiContractAddress)
+			Expect(err).ToNot(HaveOccurred())
+
+			parsedAbi := mp.ParsedAbi()
+			expectedAbi, err := eth.ParseAbi(constants.DaiAbiString)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(parsedAbi).To(Equal(expectedAbi))
+
+			methods := mp.GetSelectMethods([]string{"balanceOf"})
+			Expect(len(methods)).To(Equal(1))
+			balOf := methods[0]
+			Expect(balOf.Name).To(Equal("balanceOf"))
+			Expect(len(balOf.Args)).To(Equal(1))
+			Expect(len(balOf.Return)).To(Equal(1))
+
+			events := mp.GetEvents([]string{"Transfer"})
+			_, ok := events["Mint"]
+			Expect(ok).To(Equal(false))
+			e, ok := events["Transfer"]
+			Expect(ok).To(Equal(true))
+			Expect(len(e.Fields)).To(Equal(3))
+		})
+	})
+
+	Describe("Parse", func() {
+		It("Fetches and parses abi from etherscan using contract address", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359" // dai contract address
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			expectedAbi := constants.DaiAbiString
+			Expect(p.Abi()).To(Equal(expectedAbi))
+
+			expectedParsedAbi, err := eth.ParseAbi(expectedAbi)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ParsedAbi()).To(Equal(expectedParsedAbi))
+		})
+
+		It("Fails with a normal, non-contract, account address", func() {
+			addr := "0xAb2A8F7cB56D9EC65573BA1bE0f92Fa2Ff7dd165"
+			err = p.Parse(addr)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("GetEvents", func() {
+		It("Returns parsed events", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			events := p.GetEvents([]string{"Transfer"})
+
+			e, ok := events["Transfer"]
+			Expect(ok).To(Equal(true))
+
+			abiTy := e.Fields[0].Type.T
+			Expect(abiTy).To(Equal(abi.AddressTy))
+
+			pgTy := e.Fields[0].PgType
+			Expect(pgTy).To(Equal("CHARACTER VARYING(66)"))
+
+			abiTy = e.Fields[1].Type.T
+			Expect(abiTy).To(Equal(abi.AddressTy))
+
+			pgTy = e.Fields[1].PgType
+			Expect(pgTy).To(Equal("CHARACTER VARYING(66)"))
+
+			abiTy = e.Fields[2].Type.T
+			Expect(abiTy).To(Equal(abi.UintTy))
+
+			pgTy = e.Fields[2].PgType
+			Expect(pgTy).To(Equal("NUMERIC"))
+
+			_, ok = events["Approval"]
+			Expect(ok).To(Equal(false))
+		})
+	})
+
+	Describe("GetSelectMethods", func() {
+		It("Parses and returns only methods specified in passed array", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			methods := p.GetSelectMethods([]string{"balanceOf"})
+			Expect(len(methods)).To(Equal(1))
+
+			balOf := methods[0]
+			Expect(balOf.Name).To(Equal("balanceOf"))
+			Expect(len(balOf.Args)).To(Equal(1))
+			Expect(len(balOf.Return)).To(Equal(1))
+
+			abiTy := balOf.Args[0].Type.T
+			Expect(abiTy).To(Equal(abi.AddressTy))
+
+			pgTy := balOf.Args[0].PgType
+			Expect(pgTy).To(Equal("CHARACTER VARYING(66)"))
+
+			abiTy = balOf.Return[0].Type.T
+			Expect(abiTy).To(Equal(abi.UintTy))
+
+			pgTy = balOf.Return[0].PgType
+			Expect(pgTy).To(Equal("NUMERIC"))
+
+		})
+
+		It("Parses and returns methods in the order they were specified", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			selectMethods := p.GetSelectMethods([]string{"balanceOf", "allowance"})
+			Expect(len(selectMethods)).To(Equal(2))
+
+			balOf := selectMethods[0]
+			allow := selectMethods[1]
+
+			Expect(balOf.Name).To(Equal("balanceOf"))
+			Expect(allow.Name).To(Equal("allowance"))
+		})
+
+		It("Returns nil if given a nil or empty array", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			var nilArr []types.Method
+			selectMethods := p.GetSelectMethods([]string{})
+			Expect(selectMethods).To(Equal(nilArr))
+			selectMethods = p.GetMethods(nil)
+			Expect(selectMethods).To(Equal(nilArr))
+		})
+
+	})
+
+	Describe("GetMethods", func() {
+		It("Parses and returns only methods specified in passed array", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			methods := p.GetMethods([]string{"balanceOf"})
+			Expect(len(methods)).To(Equal(1))
+
+			balOf := methods[0]
+			Expect(balOf.Name).To(Equal("balanceOf"))
+			Expect(len(balOf.Args)).To(Equal(1))
+			Expect(len(balOf.Return)).To(Equal(1))
+
+			abiTy := balOf.Args[0].Type.T
+			Expect(abiTy).To(Equal(abi.AddressTy))
+
+			pgTy := balOf.Args[0].PgType
+			Expect(pgTy).To(Equal("CHARACTER VARYING(66)"))
+
+			abiTy = balOf.Return[0].Type.T
+			Expect(abiTy).To(Equal(abi.UintTy))
+
+			pgTy = balOf.Return[0].PgType
+			Expect(pgTy).To(Equal("NUMERIC"))
+
+		})
+
+		It("Returns nil if given a nil array", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			var nilArr []types.Method
+			selectMethods := p.GetMethods(nil)
+			Expect(selectMethods).To(Equal(nilArr))
+		})
+
+		It("Returns every method if given an empty array", func() {
+			contractAddr := "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
+			err = p.Parse(contractAddr)
+			Expect(err).ToNot(HaveOccurred())
+
+			selectMethods := p.GetMethods([]string{})
+			Expect(len(selectMethods)).To(Equal(25))
+		})
+	})
+})

pkg/eth/contract_watcher/shared/poller/poller.go

@@ -0,0 +1,291 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package poller
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+// Poller is the interface for polling public contract methods
+type Poller interface {
+	PollContract(con contract.Contract, lastBlock int64) error
+	PollContractAt(con contract.Contract, blockNumber int64) error
+	FetchContractData(contractAbi, contractAddress, method string, methodArgs []interface{}, result interface{}, blockNumber int64) error
+}
+
+type poller struct {
+	repository.MethodRepository
+	bc       core.BlockChain
+	contract contract.Contract
+}
+
+// NewPoller returns a new Poller
+func NewPoller(blockChain core.BlockChain, db *postgres.DB, mode types.Mode) Poller {
+	return &poller{
+		MethodRepository: repository.NewMethodRepository(db, mode),
+		bc:               blockChain,
+	}
+}
+
+// PollContract polls a contract's public methods from the contracts starting block to specified last block
+func (p *poller) PollContract(con contract.Contract, lastBlock int64) error {
+	for i := con.StartingBlock; i <= lastBlock; i++ {
+		if err := p.PollContractAt(con, i); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// PollContractAt polls a contract's public getter methods at the specified block height
+func (p *poller) PollContractAt(con contract.Contract, blockNumber int64) error {
+	p.contract = con
+	for _, m := range con.Methods {
+		switch len(m.Args) {
+		case 0:
+			if err := p.pollNoArgAt(m, blockNumber); err != nil {
+				return err
+			}
+		case 1:
+			if err := p.pollSingleArgAt(m, blockNumber); err != nil {
+				return err
+			}
+		case 2:
+			if err := p.pollDoubleArgAt(m, blockNumber); err != nil {
+				return err
+			}
+		default:
+			return errors.New("poller error: too many arguments to handle")
+
+		}
+	}
+
+	return nil
+}
+
+func (p *poller) pollNoArgAt(m types.Method, bn int64) error {
+	result := types.Result{
+		Block:  bn,
+		Method: m,
+		Inputs: nil,
+		PgType: m.Return[0].PgType,
+	}
+
+	var out interface{}
+	err := p.bc.FetchContractData(p.contract.Abi, p.contract.Address, m.Name, nil, &out, bn)
+	if err != nil {
+		return fmt.Errorf("poller error calling 0 argument method\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+	}
+	strOut, err := stringify(out)
+	if err != nil {
+		return err
+	}
+
+	// Cache returned value if piping is turned on
+	p.cache(out)
+	result.Output = strOut
+
+	// Persist result immediately
+	err = p.PersistResults([]types.Result{result}, m, p.contract.Address, p.contract.Name)
+	if err != nil {
+		return fmt.Errorf("poller error persisting 0 argument method result\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+	}
+
+	return nil
+}
+
+// Use token holder address to poll methods that take 1 address argument (e.g. balanceOf)
+func (p *poller) pollSingleArgAt(m types.Method, bn int64) error {
+	result := types.Result{
+		Block:  bn,
+		Method: m,
+		Inputs: make([]interface{}, 1),
+		PgType: m.Return[0].PgType,
+	}
+
+	// Depending on the type of the arg choose
+	// the correct argument set to iterate over
+	var args map[interface{}]bool
+	switch m.Args[0].Type.T {
+	case abi.HashTy, abi.FixedBytesTy:
+		args = p.contract.EmittedHashes
+	case abi.AddressTy:
+		args = p.contract.EmittedAddrs
+	}
+	if len(args) == 0 { // If we haven't collected any args by now we can't call the method
+		return nil
+	}
+
+	results := make([]types.Result, 0, len(args))
+	for arg := range args {
+		in := []interface{}{arg}
+		strIn := []interface{}{contract.StringifyArg(arg)}
+
+		var out interface{}
+		err := p.bc.FetchContractData(p.contract.Abi, p.contract.Address, m.Name, in, &out, bn)
+		if err != nil {
+			return fmt.Errorf("poller error calling 1 argument method\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+		}
+		strOut, err := stringify(out)
+		if err != nil {
+			return err
+		}
+		p.cache(out)
+
+		// Write inputs and outputs to result and append result to growing set
+		result.Inputs = strIn
+		result.Output = strOut
+		results = append(results, result)
+	}
+	// Persist result set as batch
+	err := p.PersistResults(results, m, p.contract.Address, p.contract.Name)
+	if err != nil {
+		return fmt.Errorf("poller error persisting 1 argument method result\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+	}
+
+	return nil
+}
+
+// Use token holder address to poll methods that take 2 address arguments (e.g. allowance)
+func (p *poller) pollDoubleArgAt(m types.Method, bn int64) error {
+	result := types.Result{
+		Block:  bn,
+		Method: m,
+		Inputs: make([]interface{}, 2),
+		PgType: m.Return[0].PgType,
+	}
+
+	// Depending on the type of the args choose
+	// the correct argument sets to iterate over
+	var firstArgs map[interface{}]bool
+	switch m.Args[0].Type.T {
+	case abi.HashTy, abi.FixedBytesTy:
+		firstArgs = p.contract.EmittedHashes
+	case abi.AddressTy:
+		firstArgs = p.contract.EmittedAddrs
+	}
+	if len(firstArgs) == 0 {
+		return nil
+	}
+
+	var secondArgs map[interface{}]bool
+	switch m.Args[1].Type.T {
+	case abi.HashTy, abi.FixedBytesTy:
+		secondArgs = p.contract.EmittedHashes
+	case abi.AddressTy:
+		secondArgs = p.contract.EmittedAddrs
+	}
+	if len(secondArgs) == 0 {
+		return nil
+	}
+
+	results := make([]types.Result, 0, len(firstArgs)*len(secondArgs))
+	for arg1 := range firstArgs {
+		for arg2 := range secondArgs {
+			in := []interface{}{arg1, arg2}
+			strIn := []interface{}{contract.StringifyArg(arg1), contract.StringifyArg(arg2)}
+
+			var out interface{}
+			err := p.bc.FetchContractData(p.contract.Abi, p.contract.Address, m.Name, in, &out, bn)
+			if err != nil {
+				return fmt.Errorf("poller error calling 2 argument method\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+			}
+			strOut, err := stringify(out)
+			if err != nil {
+				return err
+			}
+			p.cache(out)
+
+			result.Output = strOut
+			result.Inputs = strIn
+			results = append(results, result)
+		}
+	}
+
+	err := p.PersistResults(results, m, p.contract.Address, p.contract.Name)
+	if err != nil {
+		return fmt.Errorf("poller error persisting 2 argument method result\r\nblock: %d, method: %s, contract: %s\r\nerr: %v", bn, m.Name, p.contract.Address, err)
+	}
+
+	return nil
+}
+
+// FetchContractData is just a wrapper around the poller blockchain's FetchContractData method
+func (p *poller) FetchContractData(contractAbi, contractAddress, method string, methodArgs []interface{}, result interface{}, blockNumber int64) error {
+	return p.bc.FetchContractData(contractAbi, contractAddress, method, methodArgs, result, blockNumber)
+}
+
+// This is used to cache a method return value if method piping is turned on
+func (p *poller) cache(out interface{}) {
+	if p.contract.Piping {
+		switch out.(type) {
+		case common.Hash:
+			if p.contract.EmittedHashes != nil {
+				p.contract.AddEmittedHash(out.(common.Hash))
+			}
+		case []byte:
+			if p.contract.EmittedHashes != nil && len(out.([]byte)) == 32 {
+				p.contract.AddEmittedHash(common.BytesToHash(out.([]byte)))
+			}
+		case common.Address:
+			if p.contract.EmittedAddrs != nil {
+				p.contract.AddEmittedAddr(out.(common.Address))
+			}
+		default:
+		}
+	}
+}
+
+func stringify(input interface{}) (string, error) {
+	switch input.(type) {
+	case *big.Int:
+		b := input.(*big.Int)
+		return b.String(), nil
+	case common.Address:
+		a := input.(common.Address)
+		return a.String(), nil
+	case common.Hash:
+		h := input.(common.Hash)
+		return h.String(), nil
+	case string:
+		return input.(string), nil
+	case []byte:
+		b := hexutil.Encode(input.([]byte))
+		return b, nil
+	case byte:
+		b := input.(byte)
+		return string(b), nil
+	case bool:
+		return strconv.FormatBool(input.(bool)), nil
+	default:
+		return "", errors.New("error: unhandled return type")
+	}
+}

pkg/eth/contract_watcher/shared/repository/event_repository.go

@@ -0,0 +1,316 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/golang-lru"
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+const (
+	// Number of contract address and method ids to keep in cache
+	contractCacheSize = 100
+	eventCacheSize    = 1000
+)
+
+// EventRepository is used to persist event data into custom tables
+type EventRepository interface {
+	PersistLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error
+	CreateEventTable(contractAddr string, event types.Event) (bool, error)
+	CreateContractSchema(contractName string) (bool, error)
+	CheckSchemaCache(key string) (interface{}, bool)
+	CheckTableCache(key string) (interface{}, bool)
+}
+
+type eventRepository struct {
+	db      *postgres.DB
+	mode    types.Mode
+	schemas *lru.Cache // Cache names of recently used schemas to minimize db connections
+	tables  *lru.Cache // Cache names of recently used tables to minimize db connections
+}
+
+// NewEventRepository returns a new EventRepository
+func NewEventRepository(db *postgres.DB, mode types.Mode) EventRepository {
+	ccs, _ := lru.New(contractCacheSize)
+	ecs, _ := lru.New(eventCacheSize)
+	return &eventRepository{
+		db:      db,
+		mode:    mode,
+		schemas: ccs,
+		tables:  ecs,
+	}
+}
+
+// PersistLogs creates a schema for the contract if needed
+// Creates table for the watched contract event if needed
+// Persists converted event log data into this custom table
+func (r *eventRepository) PersistLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error {
+	if len(logs) == 0 {
+		return errors.New("event repository error: passed empty logs slice")
+	}
+	_, schemaErr := r.CreateContractSchema(contractAddr)
+	if schemaErr != nil {
+		return fmt.Errorf("error creating schema for contract %s: %s", contractAddr, schemaErr.Error())
+	}
+
+	_, tableErr := r.CreateEventTable(contractAddr, eventInfo)
+	if tableErr != nil {
+		return fmt.Errorf("error creating table for event %s on contract %s: %s", eventInfo.Name, contractAddr, tableErr.Error())
+	}
+
+	return r.persistLogs(logs, eventInfo, contractAddr, contractName)
+}
+
+func (r *eventRepository) persistLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error {
+	var err error
+	switch r.mode {
+	case types.HeaderSync:
+		err = r.persistHeaderSyncLogs(logs, eventInfo, contractAddr, contractName)
+	case types.FullSync:
+		err = r.persistFullSyncLogs(logs, eventInfo, contractAddr, contractName)
+	default:
+		return errors.New("event repository error: unhandled mode")
+	}
+
+	return err
+}
+
+// Creates a custom postgres command to persist logs for the given event (compatible with header synced vDB)
+func (r *eventRepository) persistHeaderSyncLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error {
+	tx, txErr := r.db.Beginx()
+	if txErr != nil {
+		return fmt.Errorf("error beginning db transaction: %s", txErr.Error())
+	}
+
+	for _, event := range logs {
+		// Begin pg query string
+		pgStr := fmt.Sprintf("INSERT INTO %s_%s.%s_event ", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(eventInfo.Name))
+		pgStr = pgStr + "(header_id, token_name, raw_log, log_idx, tx_idx"
+		el := len(event.Values)
+
+		// Preallocate slice of needed capacity and proceed to pack variables into it in same order they appear in string
+		data := make([]interface{}, 0, 5+el)
+		data = append(data,
+			event.ID,
+			contractName,
+			event.Raw,
+			event.LogIndex,
+			event.TransactionIndex)
+
+		// Iterate over inputs and append name to query string and value to input data
+		for inputName, input := range event.Values {
+			pgStr = pgStr + fmt.Sprintf(", %s_", strings.ToLower(inputName)) // Add underscore after to avoid any collisions with reserved pg words
+			data = append(data, input)
+		}
+
+		// For each input entry we created we add its postgres command variable to the string
+		pgStr = pgStr + ") VALUES ($1, $2, $3, $4, $5"
+		for i := 0; i < el; i++ {
+			pgStr = pgStr + fmt.Sprintf(", $%d", i+6)
+		}
+		pgStr = pgStr + ") ON CONFLICT DO NOTHING"
+
+		logrus.Tracef("query for inserting log: %s", pgStr)
+		// Add this query to the transaction
+		_, execErr := tx.Exec(pgStr, data...)
+		if execErr != nil {
+			rollbackErr := tx.Rollback()
+			if rollbackErr != nil {
+				logrus.Warnf("error rolling back transactions while persisting logs: %s", rollbackErr.Error())
+			}
+			return fmt.Errorf("error executing query: %s", execErr.Error())
+		}
+	}
+
+	return tx.Commit()
+}
+
+// Creates a custom postgres command to persist logs for the given event (compatible with fully synced vDB)
+func (r *eventRepository) persistFullSyncLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error {
+	tx, txErr := r.db.Beginx()
+	if txErr != nil {
+		return fmt.Errorf("error beginning db transaction: %s", txErr.Error())
+	}
+
+	for _, event := range logs {
+		pgStr := fmt.Sprintf("INSERT INTO %s_%s.%s_event ", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(eventInfo.Name))
+		pgStr = pgStr + "(vulcanize_log_id, token_name, block, tx"
+		el := len(event.Values)
+
+		data := make([]interface{}, 0, 4+el)
+		data = append(data,
+			event.ID,
+			contractName,
+			event.Block,
+			event.Tx)
+
+		for inputName, input := range event.Values {
+			pgStr = pgStr + fmt.Sprintf(", %s_", strings.ToLower(inputName))
+			data = append(data, input)
+		}
+
+		pgStr = pgStr + ") VALUES ($1, $2, $3, $4"
+		for i := 0; i < el; i++ {
+			pgStr = pgStr + fmt.Sprintf(", $%d", i+5)
+		}
+		pgStr = pgStr + ") ON CONFLICT (vulcanize_log_id) DO NOTHING"
+
+		logrus.Tracef("query for inserting log: %s", pgStr)
+		_, execErr := tx.Exec(pgStr, data...)
+		if execErr != nil {
+			rollbackErr := tx.Rollback()
+			if rollbackErr != nil {
+				logrus.Warnf("error rolling back transactions while persisting logs: %s", rollbackErr.Error())
+			}
+			return fmt.Errorf("error executing query: %s", execErr.Error())
+		}
+	}
+
+	return tx.Commit()
+}
+
+// CreateEventTable checks for event table and creates it if it does not already exist
+// Returns true if it created a new table; returns false if table already existed
+func (r *eventRepository) CreateEventTable(contractAddr string, event types.Event) (bool, error) {
+	tableID := fmt.Sprintf("%s_%s.%s_event", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(event.Name))
+	// Check cache before querying pq to see if table exists
+	_, ok := r.tables.Get(tableID)
+	if ok {
+		return false, nil
+	}
+	tableExists, checkTableErr := r.checkForTable(contractAddr, event.Name)
+	if checkTableErr != nil {
+		return false, fmt.Errorf("error checking for table: %s", checkTableErr)
+	}
+
+	if !tableExists {
+		createTableErr := r.newEventTable(tableID, event)
+		if createTableErr != nil {
+			return false, fmt.Errorf("error creating table: %s", createTableErr.Error())
+		}
+	}
+
+	// Add table id to cache
+	r.tables.Add(tableID, true)
+
+	return !tableExists, nil
+}
+
+// Creates a table for the given contract and event
+func (r *eventRepository) newEventTable(tableID string, event types.Event) error {
+	// Begin pg string
+	var pgStr = fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s ", tableID)
+	var err error
+
+	// Handle different modes
+	switch r.mode {
+	case types.FullSync:
+		pgStr = pgStr + "(id SERIAL, vulcanize_log_id INTEGER NOT NULL UNIQUE, token_name CHARACTER VARYING(66) NOT NULL, block INTEGER NOT NULL, tx CHARACTER VARYING(66) NOT NULL,"
+
+		// Iterate over event fields, using their name and pgType to grow the string
+		for _, field := range event.Fields {
+			pgStr = pgStr + fmt.Sprintf(" %s_ %s NOT NULL,", strings.ToLower(field.Name), field.PgType)
+		}
+		pgStr = pgStr + " CONSTRAINT log_index_fk FOREIGN KEY (vulcanize_log_id) REFERENCES full_sync_logs (id) ON DELETE CASCADE)"
+	case types.HeaderSync:
+		pgStr = pgStr + "(id SERIAL, header_id INTEGER NOT NULL REFERENCES headers (id) ON DELETE CASCADE, token_name CHARACTER VARYING(66) NOT NULL, raw_log JSONB, log_idx INTEGER NOT NULL, tx_idx INTEGER NOT NULL,"
+
+		for _, field := range event.Fields {
+			pgStr = pgStr + fmt.Sprintf(" %s_ %s NOT NULL,", strings.ToLower(field.Name), field.PgType)
+		}
+		pgStr = pgStr + " UNIQUE (header_id, tx_idx, log_idx))"
+	default:
+		return errors.New("unhandled repository mode")
+	}
+
+	_, err = r.db.Exec(pgStr)
+
+	return err
+}
+
+// Checks if a table already exists for the given contract and event
+func (r *eventRepository) checkForTable(contractAddr string, eventName string) (bool, error) {
+	pgStr := fmt.Sprintf("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = '%s_%s' AND table_name = '%s_event')", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(eventName))
+
+	var exists bool
+	err := r.db.Get(&exists, pgStr)
+
+	return exists, err
+}
+
+// CreateContractSchema checks for contract schema and creates it if it does not already exist
+// Returns true if it created a new schema; returns false if schema already existed
+func (r *eventRepository) CreateContractSchema(contractAddr string) (bool, error) {
+	if contractAddr == "" {
+		return false, errors.New("error: no contract address specified")
+	}
+
+	// Check cache before querying pq to see if schema exists
+	_, ok := r.schemas.Get(contractAddr)
+	if ok {
+		return false, nil
+	}
+	schemaExists, checkSchemaErr := r.checkForSchema(contractAddr)
+	if checkSchemaErr != nil {
+		return false, fmt.Errorf("error checking for schema: %s", checkSchemaErr.Error())
+	}
+	if !schemaExists {
+		createSchemaErr := r.newContractSchema(contractAddr)
+		if createSchemaErr != nil {
+			return false, fmt.Errorf("error creating schema: %s", createSchemaErr.Error())
+		}
+	}
+
+	// Add schema name to cache
+	r.schemas.Add(contractAddr, true)
+
+	return !schemaExists, nil
+}
+
+// Creates a schema for the given contract
+func (r *eventRepository) newContractSchema(contractAddr string) error {
+	_, err := r.db.Exec("CREATE SCHEMA IF NOT EXISTS " + r.mode.String() + "_" + strings.ToLower(contractAddr))
+
+	return err
+}
+
+// Checks if a schema already exists for the given contract
+func (r *eventRepository) checkForSchema(contractAddr string) (bool, error) {
+	pgStr := fmt.Sprintf("SELECT EXISTS (SELECT schema_name FROM information_schema.schemata WHERE schema_name = '%s_%s')", r.mode.String(), strings.ToLower(contractAddr))
+
+	var exists bool
+	err := r.db.QueryRow(pgStr).Scan(&exists)
+
+	return exists, err
+}
+
+// CheckSchemaCache is used to query the schema name cache
+func (r *eventRepository) CheckSchemaCache(key string) (interface{}, bool) {
+	return r.schemas.Get(key)
+}
+
+// CheckTableCache is used to query the table name cache
+func (r *eventRepository) CheckTableCache(key string) (interface{}, bool) {
+	return r.tables.Get(key)
+}

pkg/eth/contract_watcher/shared/repository/event_repository_test.go

@@ -0,0 +1,364 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	geth "github.com/ethereum/go-ethereum/core/types"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	fc "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/converter"
+	lc "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/converter"
+	lr "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
+	sr "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+)
+
+var _ = Describe("Repository", func() {
+	var db *postgres.DB
+	var dataStore sr.EventRepository
+	var err error
+	var log *types.Log
+	var logs []types.Log
+	var con *contract.Contract
+	var vulcanizeLogId int64
+	var wantedEvents = []string{"Transfer"}
+	var wantedMethods = []string{"balanceOf"}
+	var event types.Event
+	var headerID int64
+	var mockEvent = mocks.MockTranferEvent
+	var mockLog1 = mocks.MockTransferLog1
+	var mockLog2 = mocks.MockTransferLog2
+
+	BeforeEach(func() {
+		db, con = test_helpers.SetupTusdRepo(&vulcanizeLogId, wantedEvents, wantedMethods)
+		mockEvent.LogID = vulcanizeLogId
+
+		event = con.Events["Transfer"]
+		err = con.GenerateFilters()
+		Expect(err).ToNot(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Full sync mode", func() {
+		BeforeEach(func() {
+			dataStore = sr.NewEventRepository(db, types.FullSync)
+		})
+
+		Describe("CreateContractSchema", func() {
+			It("Creates schema if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches schema it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				_, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(false))
+
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("CreateEventTable", func() {
+			It("Creates table if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches table it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				tableID := fmt.Sprintf("%s_%s.%s_event", types.FullSync, strings.ToLower(con.Address), strings.ToLower(event.Name))
+				_, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(false))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("PersistLogs", func() {
+			BeforeEach(func() {
+				c := fc.Converter{}
+				c.Update(con)
+				log, err = c.Convert(mockEvent, event)
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("Persists contract event log values into custom tables", func() {
+				err = dataStore.PersistLogs([]types.Log{*log}, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				b, ok := con.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+				Expect(ok).To(Equal(true))
+				Expect(b).To(Equal(true))
+
+				b, ok = con.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
+				Expect(ok).To(Equal(true))
+				Expect(b).To(Equal(true))
+
+				scanLog := test_helpers.TransferLog{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event", constants.TusdContractAddress)).StructScan(&scanLog)
+				Expect(err).ToNot(HaveOccurred())
+				expectedLog := test_helpers.TransferLog{
+					ID:             1,
+					VulcanizeLogID: vulcanizeLogId,
+					TokenName:      "TrueUSD",
+					Block:          5488076,
+					Tx:             "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					From:           "0x000000000000000000000000000000000000Af21",
+					To:             "0x09BbBBE21a5975cAc061D82f7b843bCE061BA391",
+					Value:          "1097077688018008265106216665536940668749033598146",
+				}
+				Expect(scanLog).To(Equal(expectedLog))
+			})
+
+			It("Doesn't persist duplicate event logs", func() {
+				// Try to persist the same log twice in a single call
+				err = dataStore.PersistLogs([]types.Log{*log, *log}, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanLog := test_helpers.TransferLog{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event", constants.TusdContractAddress)).StructScan(&scanLog)
+				Expect(err).ToNot(HaveOccurred())
+				expectedLog := test_helpers.TransferLog{
+					ID:             1,
+					VulcanizeLogID: vulcanizeLogId,
+					TokenName:      "TrueUSD",
+					Block:          5488076,
+					Tx:             "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					From:           "0x000000000000000000000000000000000000Af21",
+					To:             "0x09BbBBE21a5975cAc061D82f7b843bCE061BA391",
+					Value:          "1097077688018008265106216665536940668749033598146",
+				}
+				Expect(scanLog).To(Equal(expectedLog))
+
+				// Attempt to persist the same log again in separate call
+				err = dataStore.PersistLogs([]types.Log{*log}, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Show that no new logs were entered
+				var count int
+				err = db.Get(&count, fmt.Sprintf("SELECT COUNT(*) FROM full_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(1))
+			})
+
+			It("Fails with empty log", func() {
+				err = dataStore.PersistLogs([]types.Log{}, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+
+	Describe("Header sync mode", func() {
+		BeforeEach(func() {
+			dataStore = sr.NewEventRepository(db, types.HeaderSync)
+		})
+
+		Describe("CreateContractSchema", func() {
+			It("Creates schema if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches schema it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				_, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(false))
+
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+
+			It("Caches table it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				tableID := fmt.Sprintf("%s_%s.%s_event", types.HeaderSync, strings.ToLower(con.Address), strings.ToLower(event.Name))
+				_, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(false))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("CreateEventTable", func() {
+			It("Creates table if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateEventTable(con.Address, event)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+		})
+
+		Describe("PersistLogs", func() {
+			BeforeEach(func() {
+				headerRepository := repositories.NewHeaderRepository(db)
+				headerID, err = headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+				Expect(err).ToNot(HaveOccurred())
+				c := lc.Converter{}
+				c.Update(con)
+				logs, err = c.Convert([]geth.Log{mockLog1, mockLog2}, event, headerID)
+				Expect(err).ToNot(HaveOccurred())
+			})
+
+			It("Persists contract event log values into custom tables", func() {
+				hr := lr.NewHeaderRepository(db)
+				err = hr.AddCheckColumn(event.Name + "_" + con.Address)
+				Expect(err).ToNot(HaveOccurred())
+
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				var count int
+				err = db.Get(&count, fmt.Sprintf("SELECT COUNT(*) FROM header_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(2))
+
+				scanLog := test_helpers.HeaderSyncTransferLog{}
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM header_%s.transfer_event LIMIT 1", constants.TusdContractAddress)).StructScan(&scanLog)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanLog.HeaderID).To(Equal(headerID))
+				Expect(scanLog.TokenName).To(Equal("TrueUSD"))
+				Expect(scanLog.TxIndex).To(Equal(int64(110)))
+				Expect(scanLog.LogIndex).To(Equal(int64(1)))
+				Expect(scanLog.From).To(Equal("0x000000000000000000000000000000000000Af21"))
+				Expect(scanLog.To).To(Equal("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391"))
+				Expect(scanLog.Value).To(Equal("1097077688018008265106216665536940668749033598146"))
+
+				var expectedRawLog, rawLog geth.Log
+				err = json.Unmarshal(logs[0].Raw, &expectedRawLog)
+				Expect(err).ToNot(HaveOccurred())
+				err = json.Unmarshal(scanLog.RawLog, &rawLog)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(rawLog).To(Equal(expectedRawLog))
+			})
+
+			It("Doesn't persist duplicate event logs", func() {
+				hr := lr.NewHeaderRepository(db)
+				err = hr.AddCheckColumn(event.Name + "_" + con.Address)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Successfully persist the two unique logs
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Try to insert the same logs again
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Show that no new logs were entered
+				var count int
+				err = db.Get(&count, fmt.Sprintf("SELECT COUNT(*) FROM header_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(2))
+			})
+
+			It("inserts additional log if only some are duplicate", func() {
+				hr := lr.NewHeaderRepository(db)
+				err = hr.AddCheckColumn(event.Name + "_" + con.Address)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Successfully persist first log
+				err = dataStore.PersistLogs([]types.Log{logs[0]}, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Successfully persist second log even though first already persisted
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Show that both logs were entered
+				var count int
+				err = db.Get(&count, fmt.Sprintf("SELECT COUNT(*) FROM header_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(2))
+			})
+
+			It("Fails with empty log", func() {
+				err = dataStore.PersistLogs([]types.Log{}, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+})

pkg/eth/contract_watcher/shared/repository/method_repository.go

@@ -0,0 +1,235 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/golang-lru"
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+const methodCacheSize = 1000
+
+// MethodRepository is used to persist public getter method data
+type MethodRepository interface {
+	PersistResults(results []types.Result, methodInfo types.Method, contractAddr, contractName string) error
+	CreateMethodTable(contractAddr string, method types.Method) (bool, error)
+	CreateContractSchema(contractAddr string) (bool, error)
+	CheckSchemaCache(key string) (interface{}, bool)
+	CheckTableCache(key string) (interface{}, bool)
+}
+
+type methodRepository struct {
+	*postgres.DB
+	mode    types.Mode
+	schemas *lru.Cache // Cache names of recently used schemas to minimize db connections
+	tables  *lru.Cache // Cache names of recently used tables to minimize db connections
+}
+
+// NewMethodRepository returns a new MethodRepository
+func NewMethodRepository(db *postgres.DB, mode types.Mode) MethodRepository {
+	ccs, _ := lru.New(contractCacheSize)
+	mcs, _ := lru.New(methodCacheSize)
+	return &methodRepository{
+		DB:      db,
+		mode:    mode,
+		schemas: ccs,
+		tables:  mcs,
+	}
+}
+
+// PersistResults creates a schema for the contract if needed
+// Creates table for the contract method if needed
+// Persists method polling data into this custom table
+func (r *methodRepository) PersistResults(results []types.Result, methodInfo types.Method, contractAddr, contractName string) error {
+	if len(results) == 0 {
+		return errors.New("method repository error: passed empty results slice")
+	}
+	_, err := r.CreateContractSchema(contractAddr)
+	if err != nil {
+		return err
+	}
+
+	_, err = r.CreateMethodTable(contractAddr, methodInfo)
+	if err != nil {
+		return err
+	}
+
+	return r.persistResults(results, methodInfo, contractAddr, contractName)
+}
+
+// Creates a custom postgres command to persist logs for the given event
+func (r *methodRepository) persistResults(results []types.Result, methodInfo types.Method, contractAddr, contractName string) error {
+	tx, err := r.DB.Beginx()
+	if err != nil {
+		return err
+	}
+
+	for _, result := range results {
+		// Begin postgres string
+		pgStr := fmt.Sprintf("INSERT INTO %s_%s.%s_method ", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(result.Name))
+		pgStr = pgStr + "(token_name, block"
+		ml := len(result.Args)
+
+		// Preallocate slice of needed capacity and proceed to pack variables into it in same order they appear in string
+		data := make([]interface{}, 0, 3+ml)
+		data = append(data,
+			contractName,
+			result.Block)
+
+		// Iterate over method args and return value, adding names
+		// to the string and pushing values to the slice
+		for i, arg := range result.Args {
+			pgStr = pgStr + fmt.Sprintf(", %s_", strings.ToLower(arg.Name)) // Add underscore after to avoid any collisions with reserved pg words
+			data = append(data, result.Inputs[i])
+		}
+		pgStr = pgStr + ", returned) VALUES ($1, $2"
+		data = append(data, result.Output)
+
+		// For each input entry we created we add its postgres command variable to the string
+		for i := 0; i <= ml; i++ {
+			pgStr = pgStr + fmt.Sprintf(", $%d", i+3)
+		}
+		pgStr = pgStr + ")"
+
+		// Add this query to the transaction
+		_, err = tx.Exec(pgStr, data...)
+		if err != nil {
+			rollbackErr := tx.Rollback()
+			if rollbackErr != nil {
+				logrus.Warnf("error rolling back transaction: %s", rollbackErr.Error())
+			}
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+// CreateMethodTable checks for event table and creates it if it does not already exist
+func (r *methodRepository) CreateMethodTable(contractAddr string, method types.Method) (bool, error) {
+	tableID := fmt.Sprintf("%s_%s.%s_method", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(method.Name))
+
+	// Check cache before querying pq to see if table exists
+	_, ok := r.tables.Get(tableID)
+	if ok {
+		return false, nil
+	}
+	tableExists, err := r.checkForTable(contractAddr, method.Name)
+	if err != nil {
+		return false, err
+	}
+	if !tableExists {
+		err = r.newMethodTable(tableID, method)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// Add schema name to cache
+	r.tables.Add(tableID, true)
+
+	return !tableExists, nil
+}
+
+// Creates a table for the given contract and event
+func (r *methodRepository) newMethodTable(tableID string, method types.Method) error {
+	// Begin pg string
+	pgStr := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s ", tableID)
+	pgStr = pgStr + "(id SERIAL, token_name CHARACTER VARYING(66) NOT NULL, block INTEGER NOT NULL,"
+
+	// Iterate over method inputs and outputs, using their name and pgType to grow the string
+	for _, arg := range method.Args {
+		pgStr = pgStr + fmt.Sprintf(" %s_ %s NOT NULL,", strings.ToLower(arg.Name), arg.PgType)
+	}
+
+	pgStr = pgStr + fmt.Sprintf(" returned %s NOT NULL)", method.Return[0].PgType)
+
+	_, err := r.DB.Exec(pgStr)
+
+	return err
+}
+
+// Checks if a table already exists for the given contract and event
+func (r *methodRepository) checkForTable(contractAddr string, methodName string) (bool, error) {
+	pgStr := fmt.Sprintf("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = '%s_%s' AND table_name = '%s_method')", r.mode.String(), strings.ToLower(contractAddr), strings.ToLower(methodName))
+	var exists bool
+	err := r.DB.Get(&exists, pgStr)
+
+	return exists, err
+}
+
+// CreateContractSchema checks for contract schema and creates it if it does not already exist
+func (r *methodRepository) CreateContractSchema(contractAddr string) (bool, error) {
+	if contractAddr == "" {
+		return false, errors.New("error: no contract address specified")
+	}
+
+	// Check cache before querying pq to see if schema exists
+	_, ok := r.schemas.Get(contractAddr)
+	if ok {
+		return false, nil
+	}
+	schemaExists, err := r.checkForSchema(contractAddr)
+	if err != nil {
+		return false, err
+	}
+	if !schemaExists {
+		err = r.newContractSchema(contractAddr)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// Add schema name to cache
+	r.schemas.Add(contractAddr, true)
+
+	return !schemaExists, nil
+}
+
+// Creates a schema for the given contract
+func (r *methodRepository) newContractSchema(contractAddr string) error {
+	_, err := r.DB.Exec("CREATE SCHEMA IF NOT EXISTS " + r.mode.String() + "_" + strings.ToLower(contractAddr))
+
+	return err
+}
+
+// Checks if a schema already exists for the given contract
+func (r *methodRepository) checkForSchema(contractAddr string) (bool, error) {
+	pgStr := fmt.Sprintf("SELECT EXISTS (SELECT schema_name FROM information_schema.schemata WHERE schema_name = '%s_%s')", r.mode.String(), strings.ToLower(contractAddr))
+
+	var exists bool
+	err := r.DB.Get(&exists, pgStr)
+
+	return exists, err
+}
+
+// CheckSchemaCache is used to query the schema name cache
+func (r *methodRepository) CheckSchemaCache(key string) (interface{}, bool) {
+	return r.schemas.Get(key)
+}
+
+// CheckTableCache is used to query the table name cache
+func (r *methodRepository) CheckTableCache(key string) (interface{}, bool) {
+	return r.tables.Get(key)
+}

pkg/eth/contract_watcher/shared/repository/method_repository_test.go

@@ -0,0 +1,240 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository_test
+
+import (
+	"fmt"
+	"strings"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+var _ = Describe("Repository", func() {
+	var db *postgres.DB
+	var dataStore repository.MethodRepository
+	var con *contract.Contract
+	var err error
+	var mockResult types.Result
+	var method types.Method
+
+	BeforeEach(func() {
+		con = test_helpers.SetupTusdContract([]string{}, []string{"balanceOf"})
+		Expect(len(con.Methods)).To(Equal(1))
+		method = con.Methods[0]
+		mockResult = types.Result{
+			Method: method,
+			PgType: method.Return[0].PgType,
+			Inputs: make([]interface{}, 1),
+			Output: new(interface{}),
+			Block:  6707323,
+		}
+		mockResult.Inputs[0] = "0xfE9e8709d3215310075d67E3ed32A380CCf451C8"
+		mockResult.Output = "66386309548896882859581786"
+		db, _ = test_helpers.SetupDBandBC()
+		dataStore = repository.NewMethodRepository(db, types.FullSync)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Full Sync Mode", func() {
+		BeforeEach(func() {
+			dataStore = repository.NewMethodRepository(db, types.FullSync)
+		})
+
+		Describe("CreateContractSchema", func() {
+			It("Creates schema if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches schema it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				_, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(false))
+
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("CreateMethodTable", func() {
+			It("Creates table if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateMethodTable(constants.TusdContractAddress, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateMethodTable(constants.TusdContractAddress, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches table it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				tableID := fmt.Sprintf("%s_%s.%s_method", types.FullSync, strings.ToLower(con.Address), strings.ToLower(method.Name))
+				_, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(false))
+
+				created, err = dataStore.CreateMethodTable(con.Address, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("PersistResult", func() {
+			It("Persists result from method polling in custom pg table", func() {
+				err = dataStore.PersistResults([]types.Result{mockResult}, method, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method", constants.TusdContractAddress)).StructScan(&scanStruct)
+				expectedLog := test_helpers.BalanceOf{
+					ID:        1,
+					TokenName: "TrueUSD",
+					Block:     6707323,
+					Address:   "0xfE9e8709d3215310075d67E3ed32A380CCf451C8",
+					Balance:   "66386309548896882859581786",
+				}
+				Expect(scanStruct).To(Equal(expectedLog))
+			})
+
+			It("Fails with empty result", func() {
+				err = dataStore.PersistResults([]types.Result{}, method, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+
+	Describe("Header Sync Mode", func() {
+		BeforeEach(func() {
+			dataStore = repository.NewMethodRepository(db, types.HeaderSync)
+		})
+
+		Describe("CreateContractSchema", func() {
+			It("Creates schema if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches schema it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				_, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(false))
+
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckSchemaCache(con.Address)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("CreateMethodTable", func() {
+			It("Creates table if it doesn't exist", func() {
+				created, err := dataStore.CreateContractSchema(constants.TusdContractAddress)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateMethodTable(constants.TusdContractAddress, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				created, err = dataStore.CreateMethodTable(constants.TusdContractAddress, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(false))
+			})
+
+			It("Caches table it creates so that it does not need to repeatedly query the database to check for it's existence", func() {
+				created, err := dataStore.CreateContractSchema(con.Address)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				tableID := fmt.Sprintf("%s_%s.%s_method", types.HeaderSync, strings.ToLower(con.Address), strings.ToLower(method.Name))
+				_, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(false))
+
+				created, err = dataStore.CreateMethodTable(con.Address, method)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(created).To(Equal(true))
+
+				v, ok := dataStore.CheckTableCache(tableID)
+				Expect(ok).To(Equal(true))
+				Expect(v).To(Equal(true))
+			})
+		})
+
+		Describe("PersistResult", func() {
+			It("Persists result from method polling in custom pg table for header sync mode vDB", func() {
+				err = dataStore.PersistResults([]types.Result{mockResult}, method, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM header_%s.balanceof_method", constants.TusdContractAddress)).StructScan(&scanStruct)
+				expectedLog := test_helpers.BalanceOf{
+					ID:        1,
+					TokenName: "TrueUSD",
+					Block:     6707323,
+					Address:   "0xfE9e8709d3215310075d67E3ed32A380CCf451C8",
+					Balance:   "66386309548896882859581786",
+				}
+				Expect(scanStruct).To(Equal(expectedLog))
+			})
+
+			It("Fails with empty result", func() {
+				err = dataStore.PersistResults([]types.Result{}, method, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+})

pkg/eth/contract_watcher/shared/repository/repository_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repository_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestRepository(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Shared Repository Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/shared/retriever/address_retriever.go

@@ -0,0 +1,121 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+// AddressRetriever is used to retrieve the addresses associated with a contract
+type AddressRetriever interface {
+	RetrieveTokenHolderAddresses(info contract.Contract) (map[common.Address]bool, error)
+}
+
+type addressRetriever struct {
+	db   *postgres.DB
+	mode types.Mode
+}
+
+// NewAddressRetriever returns a new AddressRetriever
+func NewAddressRetriever(db *postgres.DB, mode types.Mode) AddressRetriever {
+	return &addressRetriever{
+		db:   db,
+		mode: mode,
+	}
+}
+
+// RetrieveTokenHolderAddresses is used to retrieve list of token-holding/contract-related addresses by iterating over available events
+// This generic method should work whether or not the argument/input names of the events meet the expected standard
+// This could be generalized to iterate over ALL events and pull out any address arguments
+func (r *addressRetriever) RetrieveTokenHolderAddresses(info contract.Contract) (map[common.Address]bool, error) {
+	addrList := make([]string, 0)
+
+	_, ok := info.Filters["Transfer"]
+	if ok {
+		addrs, err := r.retrieveTransferAddresses(info)
+		if err != nil {
+			return nil, err
+		}
+		addrList = append(addrList, addrs...)
+	}
+
+	_, ok = info.Filters["Mint"]
+	if ok {
+		addrs, err := r.retrieveTokenMintees(info)
+		if err != nil {
+			return nil, err
+		}
+		addrList = append(addrList, addrs...)
+	}
+
+	contractAddresses := make(map[common.Address]bool)
+	for _, addr := range addrList {
+		contractAddresses[common.HexToAddress(addr)] = true
+	}
+
+	return contractAddresses, nil
+}
+
+func (r *addressRetriever) retrieveTransferAddresses(con contract.Contract) ([]string, error) {
+	transferAddrs := make([]string, 0)
+	event := con.Events["Transfer"]
+
+	for _, field := range event.Fields { // Iterate over event fields, finding the ones with address type
+
+		if field.Type.T == abi.AddressTy { // If they have address type, retrieve those addresses
+			addrs := make([]string, 0)
+			pgStr := fmt.Sprintf("SELECT %s_ FROM %s_%s.%s_event", strings.ToLower(field.Name), r.mode.String(), strings.ToLower(con.Address), strings.ToLower(event.Name))
+			err := r.db.Select(&addrs, pgStr)
+			if err != nil {
+				return []string{}, err
+			}
+
+			transferAddrs = append(transferAddrs, addrs...) // And append them to the growing list
+		}
+	}
+
+	return transferAddrs, nil
+}
+
+func (r *addressRetriever) retrieveTokenMintees(con contract.Contract) ([]string, error) {
+	mintAddrs := make([]string, 0)
+	event := con.Events["Mint"]
+
+	for _, field := range event.Fields { // Iterate over event fields, finding the ones with address type
+
+		if field.Type.T == abi.AddressTy { // If they have address type, retrieve those addresses
+			addrs := make([]string, 0)
+			pgStr := fmt.Sprintf("SELECT %s_ FROM %s_%s.%s_event", strings.ToLower(field.Name), r.mode.String(), strings.ToLower(con.Address), strings.ToLower(event.Name))
+			err := r.db.Select(&addrs, pgStr)
+			if err != nil {
+				return []string{}, err
+			}
+
+			mintAddrs = append(mintAddrs, addrs...) // And append them to the growing list
+		}
+	}
+
+	return mintAddrs, nil
+}

pkg/eth/contract_watcher/shared/retriever/address_retriever_test.go

@@ -0,0 +1,107 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+var mockEvent = core.WatchedEvent{
+	Name:        constants.TransferEvent.String(),
+	BlockNumber: 5488076,
+	Address:     constants.TusdContractAddress,
+	TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+	Index:       110,
+	Topic0:      constants.TransferEvent.Signature(),
+	Topic1:      "0x000000000000000000000000000000000000000000000000000000000000af21",
+	Topic2:      "0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+	Topic3:      "",
+	Data:        "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+}
+
+var _ = Describe("Address Retriever Test", func() {
+	var db *postgres.DB
+	var dataStore repository.EventRepository
+	var info *contract.Contract
+	var vulcanizeLogId int64
+	var log *types.Log
+	var r retriever.AddressRetriever
+	var wantedEvents = []string{"Transfer"}
+
+	BeforeEach(func() {
+		db, info = test_helpers.SetupTusdRepo(&vulcanizeLogId, wantedEvents, []string{})
+		mockEvent.LogID = vulcanizeLogId
+
+		event := info.Events["Transfer"]
+		filterErr := info.GenerateFilters()
+		Expect(filterErr).ToNot(HaveOccurred())
+
+		c := converter.Converter{}
+		c.Update(info)
+		var convertErr error
+		log, convertErr = c.Convert(mockEvent, event)
+		Expect(convertErr).ToNot(HaveOccurred())
+
+		dataStore = repository.NewEventRepository(db, types.FullSync)
+		persistErr := dataStore.PersistLogs([]types.Log{*log}, event, info.Address, info.Name)
+		Expect(persistErr).ToNot(HaveOccurred())
+
+		r = retriever.NewAddressRetriever(db, types.FullSync)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("RetrieveTokenHolderAddresses", func() {
+		It("Retrieves a list of token holder addresses from persisted event logs", func() {
+			addresses, retrieveErr := r.RetrieveTokenHolderAddresses(*info)
+			Expect(retrieveErr).ToNot(HaveOccurred())
+
+			_, ok := addresses[common.HexToAddress("0x000000000000000000000000000000000000000000000000000000000000af21")]
+			Expect(ok).To(Equal(true))
+
+			_, ok = addresses[common.HexToAddress("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")]
+			Expect(ok).To(Equal(true))
+
+			_, ok = addresses[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = addresses[common.HexToAddress(constants.TusdContractAddress)]
+			Expect(ok).To(Equal(false))
+
+		})
+
+		It("Returns empty list when empty contract info is used", func() {
+			addresses, retrieveErr := r.RetrieveTokenHolderAddresses(contract.Contract{})
+			Expect(retrieveErr).ToNot(HaveOccurred())
+			Expect(len(addresses)).To(Equal(0))
+		})
+	})
+})

pkg/eth/contract_watcher/shared/retriever/retriever_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package retriever_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Address Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/eth/contract_watcher/shared/types/event.go

@@ -0,0 +1,99 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// Event is our custom event type
+type Event struct {
+	Name      string
+	Anonymous bool
+	Fields    []Field
+}
+
+// Field is our custom event field type which associates a postgres type with the field
+type Field struct {
+	abi.Argument        // Name, Type, Indexed
+	PgType       string // Holds type used when committing data held in this field to postgres
+}
+
+// Log is used to hold instance of an event log data
+type Log struct {
+	ID     int64             // VulcanizeIdLog for full sync and header ID for header sync contract watcher
+	Values map[string]string // Map of event input names to their values
+
+	// Used for full sync only
+	Block int64
+	Tx    string
+
+	// Used for headerSync only
+	LogIndex         uint
+	TransactionIndex uint
+	Raw              []byte // json.Unmarshalled byte array of geth/core/types.Log{}
+}
+
+// NewEvent unpacks abi.Event into our custom Event struct
+func NewEvent(e abi.Event) Event {
+	fields := make([]Field, len(e.Inputs))
+	for i, input := range e.Inputs {
+		fields[i] = Field{}
+		fields[i].Name = input.Name
+		fields[i].Type = input.Type
+		fields[i].Indexed = input.Indexed
+		// Fill in pg type based on abi type
+		switch fields[i].Type.T {
+		case abi.HashTy, abi.AddressTy:
+			fields[i].PgType = "CHARACTER VARYING(66)"
+		case abi.IntTy, abi.UintTy:
+			fields[i].PgType = "NUMERIC"
+		case abi.BoolTy:
+			fields[i].PgType = "BOOLEAN"
+		case abi.BytesTy, abi.FixedBytesTy:
+			fields[i].PgType = "BYTEA"
+		case abi.ArrayTy:
+			fields[i].PgType = "TEXT[]"
+		case abi.FixedPointTy:
+			fields[i].PgType = "MONEY" // use shopspring/decimal for fixed point numbers in go and money type in postgres?
+		default:
+			fields[i].PgType = "TEXT"
+		}
+	}
+
+	return Event{
+		Name:      e.Name,
+		Anonymous: e.Anonymous,
+		Fields:    fields,
+	}
+}
+
+// Sig returns the hash signature for an event
+func (e Event) Sig() common.Hash {
+	types := make([]string, len(e.Fields))
+
+	for i, input := range e.Fields {
+		types[i] = input.Type.String()
+	}
+
+	return crypto.Keccak256Hash([]byte(fmt.Sprintf("%v(%v)", e.Name, strings.Join(types, ","))))
+}

pkg/eth/contract_watcher/shared/types/method.go

@@ -0,0 +1,113 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// Method is our custom method struct
+type Method struct {
+	Name   string
+	Const  bool
+	Args   []Field
+	Return []Field
+}
+
+// Result is used to hold instance of result from method call with given inputs and block
+type Result struct {
+	Method
+	Inputs []interface{} // Will only use addresses
+	Output interface{}
+	PgType string // Holds output pg type
+	Block  int64
+}
+
+// NewMethod unpacks abi.Method into our custom Method struct
+func NewMethod(m abi.Method) Method {
+	inputs := make([]Field, len(m.Inputs))
+	for i, input := range m.Inputs {
+		inputs[i] = Field{}
+		inputs[i].Name = input.Name
+		inputs[i].Type = input.Type
+		inputs[i].Indexed = input.Indexed
+		switch inputs[i].Type.T {
+		case abi.HashTy, abi.AddressTy:
+			inputs[i].PgType = "CHARACTER VARYING(66)"
+		case abi.IntTy, abi.UintTy:
+			inputs[i].PgType = "NUMERIC"
+		case abi.BoolTy:
+			inputs[i].PgType = "BOOLEAN"
+		case abi.BytesTy, abi.FixedBytesTy:
+			inputs[i].PgType = "BYTEA"
+		case abi.ArrayTy:
+			inputs[i].PgType = "TEXT[]"
+		case abi.FixedPointTy:
+			inputs[i].PgType = "MONEY" // use shopspring/decimal for fixed point numbers in go and money type in postgres?
+		default:
+			inputs[i].PgType = "TEXT"
+		}
+	}
+
+	outputs := make([]Field, len(m.Outputs))
+	for i, output := range m.Outputs {
+		outputs[i] = Field{}
+		outputs[i].Name = output.Name
+		outputs[i].Type = output.Type
+		outputs[i].Indexed = output.Indexed
+		switch outputs[i].Type.T {
+		case abi.HashTy, abi.AddressTy:
+			outputs[i].PgType = "CHARACTER VARYING(66)"
+		case abi.IntTy, abi.UintTy:
+			outputs[i].PgType = "NUMERIC"
+		case abi.BoolTy:
+			outputs[i].PgType = "BOOLEAN"
+		case abi.BytesTy, abi.FixedBytesTy:
+			outputs[i].PgType = "BYTEA"
+		case abi.ArrayTy:
+			outputs[i].PgType = "TEXT[]"
+		case abi.FixedPointTy:
+			outputs[i].PgType = "MONEY" // use shopspring/decimal for fixed point numbers in go and money type in postgres?
+		default:
+			outputs[i].PgType = "TEXT"
+		}
+	}
+
+	return Method{
+		Name:   m.Name,
+		Const:  m.Const,
+		Args:   inputs,
+		Return: outputs,
+	}
+}
+
+// Sig returns the hash signature for the method
+func (m Method) Sig() common.Hash {
+	types := make([]string, len(m.Args))
+	i := 0
+	for _, arg := range m.Args {
+		types[i] = arg.Type.String()
+		i++
+	}
+
+	return crypto.Keccak256Hash([]byte(fmt.Sprintf("%v(%v)", m.Name, strings.Join(types, ","))))
+}

pkg/eth/contract_watcher/shared/types/mode.go

@@ -0,0 +1,43 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+// Mode is used to explicitly represent the operating mode of the transformer
+type Mode int
+
+// Mode enums
+const (
+	HeaderSync Mode = iota
+	FullSync
+)
+
+// IsValid returns true is the Mode is valid
+func (mode Mode) IsValid() bool {
+	return mode >= HeaderSync && mode <= FullSync
+}
+
+// String returns the string representation of the mode
+func (mode Mode) String() string {
+	switch mode {
+	case HeaderSync:
+		return "header"
+	case FullSync:
+		return "full"
+	default:
+		return "unknown"
+	}
+}

pkg/eth/converters/cold_db/transaction_converter.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 	"golang.org/x/sync/errgroup"
 )
 

pkg/eth/converters/common/block_converter.go

@@ -25,7 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 type BlockConverter struct {

pkg/eth/converters/common/block_converter_test.go

@@ -31,7 +31,7 @@ import (
 
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/converters/rpc"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("Conversion of GethBlock to core.Block", func() {

pkg/eth/converters/common/block_rewards.go

@@ -20,7 +20,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 func CalcBlockReward(block core.Block, uncles []*types.Header) *big.Int {

pkg/eth/converters/common/full_sync_log_converter.go

@@ -23,7 +23,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 func ToFullSyncLogs(gethLogs []types.Log) []core.FullSyncLog {

pkg/eth/converters/common/full_sync_log_converter_test.go

@@ -25,8 +25,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 var _ = Describe("Conversion of GethLog to core.FullSyncLog", func() {

pkg/eth/converters/common/header_converter.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/core/types"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 type HeaderConverter struct{}

pkg/eth/converters/common/header_converter_test.go

@@ -27,7 +27,7 @@ import (
 	. "github.com/onsi/gomega"
 
 	common2 "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("Block header converter", func() {

pkg/eth/converters/common/receipt_converter.go

@@ -23,7 +23,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 func ToCoreReceipts(gethReceipts types.Receipts) ([]core.Receipt, error) {

pkg/eth/converters/common/receipt_converter_test.go

@@ -25,8 +25,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 var _ = Describe("Conversion of GethReceipt to core.Receipt", func() {

pkg/eth/converters/common/transaction_converter.go

@@ -18,7 +18,7 @@ package common
 
 import (
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 type TransactionConverter interface {

pkg/eth/converters/rpc/transaction_converter.go

@@ -31,8 +31,8 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 	"golang.org/x/sync/errgroup"
 
-	"github.com/vulcanize/vulcanizedb/pkg/core"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
 )
 
 type RPCTransactionConverter struct {

pkg/eth/converters/rpc/transaction_converter_test.go

@@ -19,9 +19,9 @@ package rpc_test
 import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"github.com/vulcanize/vulcanizedb/pkg/core"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/converters/rpc"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
 )
 
 var _ = Describe("RPC transaction converter", func() {

pkg/eth/core/block.go

@@ -0,0 +1,37 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type Block struct {
+	Reward       string `db:"reward"`
+	Difficulty   int64  `db:"difficulty"`
+	ExtraData    string `db:"extra_data"`
+	GasLimit     uint64 `db:"gas_limit"`
+	GasUsed      uint64 `db:"gas_used"`
+	Hash         string `db:"hash"`
+	IsFinal      bool   `db:"is_final"`
+	Miner        string `db:"miner"`
+	Nonce        string `db:"nonce"`
+	Number       int64  `db:"number"`
+	ParentHash   string `db:"parent_hash"`
+	Size         string `db:"size"`
+	Time         uint64 `db:"time"`
+	Transactions []TransactionModel
+	UncleHash    string `db:"uncle_hash"`
+	UnclesReward string `db:"uncles_reward"`
+	Uncles       []Uncle
+}

pkg/eth/core/blockchain.go

@@ -0,0 +1,47 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type BlockChain interface {
+	ContractDataFetcher
+	AccountDataFetcher
+	GetBlockByNumber(blockNumber int64) (Block, error)
+	GetEthLogsWithCustomQuery(query ethereum.FilterQuery) ([]types.Log, error)
+	GetHeaderByNumber(blockNumber int64) (Header, error)
+	GetHeadersByNumbers(blockNumbers []int64) ([]Header, error)
+	GetFullSyncLogs(contract Contract, startingBlockNumber *big.Int, endingBlockNumber *big.Int) ([]FullSyncLog, error)
+	GetTransactions(transactionHashes []common.Hash) ([]TransactionModel, error)
+	LastBlock() (*big.Int, error)
+	Node() Node
+}
+
+type ContractDataFetcher interface {
+	FetchContractData(abiJSON string, address string, method string, methodArgs []interface{}, result interface{}, blockNumber int64) error
+}
+
+type AccountDataFetcher interface {
+	GetAccountBalance(address common.Address, blockNumber *big.Int) (*big.Int, error)
+}

pkg/eth/core/contract.go

@@ -0,0 +1,23 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type Contract struct {
+	Abi          string
+	Hash         string
+	Transactions []TransactionModel
+}

pkg/eth/core/eth_client.go

@@ -0,0 +1,36 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type EthClient interface {
+	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
+	CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
+	FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error)
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+	TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error)
+	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
+	BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
+}

pkg/eth/core/header.go

@@ -0,0 +1,48 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type Header struct {
+	ID          int64
+	BlockNumber int64 `db:"block_number"`
+	Hash        string
+	Raw         []byte
+	Timestamp   string `db:"block_timestamp"`
+}
+
+type POAHeader struct {
+	ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"`
+	UncleHash   common.Hash    `json:"sha3Uncles"       gencodec:"required"`
+	Coinbase    common.Address `json:"miner"            gencodec:"required"`
+	Root        common.Hash    `json:"stateRoot"        gencodec:"required"`
+	TxHash      common.Hash    `json:"transactionsRoot" gencodec:"required"`
+	ReceiptHash common.Hash    `json:"receiptsRoot"     gencodec:"required"`
+	Bloom       types.Bloom    `json:"logsBloom"        gencodec:"required"`
+	Difficulty  *hexutil.Big   `json:"difficulty"       gencodec:"required"`
+	Number      *hexutil.Big   `json:"number"           gencodec:"required"`
+	GasLimit    hexutil.Uint64 `json:"gasLimit"         gencodec:"required"`
+	GasUsed     hexutil.Uint64 `json:"gasUsed"          gencodec:"required"`
+	Time        hexutil.Uint64 `json:"timestamp"        gencodec:"required"`
+	Extra       hexutil.Bytes  `json:"extraData"        gencodec:"required"`
+	Hash        common.Hash    `json:"hash"`
+}

pkg/eth/core/log.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import "github.com/ethereum/go-ethereum/core/types"
+
+type FullSyncLog struct {
+	BlockNumber int64
+	TxHash      string
+	Address     string
+	Topics
+	Index int64
+	Data  string
+}
+
+type HeaderSyncLog struct {
+	ID          int64
+	HeaderID    int64 `db:"header_id"`
+	Log         types.Log
+	Transformed bool
+}

pkg/eth/core/node_info.go

@@ -0,0 +1,57 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"fmt"
+)
+
+type NodeType int
+
+const (
+	GETH NodeType = iota
+	PARITY
+	INFURA
+	GANACHE
+)
+
+const (
+	KOVAN_NETWORK_ID = 42
+)
+
+type Node struct {
+	GenesisBlock string
+	NetworkID    float64
+	ID           string
+	ClientName   string
+}
+
+type ParityNodeInfo struct {
+	Track         string
+	ParityVersion `json:"version"`
+	Hash          string
+}
+
+func (pn ParityNodeInfo) String() string {
+	return fmt.Sprintf("Parity/v%d.%d.%d/", pn.Major, pn.Minor, pn.Patch)
+}
+
+type ParityVersion struct {
+	Major int
+	Minor int
+	Patch int
+}

pkg/eth/core/receipts.go

@@ -0,0 +1,29 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type Receipt struct {
+	Bloom             string
+	ContractAddress   string `db:"contract_address"`
+	CumulativeGasUsed uint64 `db:"cumulative_gas_used"`
+	GasUsed           uint64 `db:"gas_used"`
+	Logs              []FullSyncLog
+	StateRoot         string `db:"state_root"`
+	Status            int
+	TxHash            string `db:"tx_hash"`
+	Rlp               []byte `db:"rlp"`
+}

pkg/eth/core/rpc_client.go

@@ -0,0 +1,33 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
+)
+
+type RPCClient interface {
+	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
+	BatchCall(batch []client.BatchElem) error
+	IpcPath() string
+	SupportedModules() (map[string]string, error)
+	Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error)
+}

pkg/eth/core/topics.go

@@ -0,0 +1,19 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type Topics [4]string

pkg/eth/core/transaction.go

@@ -0,0 +1,46 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type TransactionModel struct {
+	Data     []byte `db:"input_data"`
+	From     string `db:"tx_from"`
+	GasLimit uint64 `db:"gas_limit"`
+	GasPrice int64  `db:"gas_price"`
+	Hash     string
+	Nonce    uint64
+	Raw      []byte `db:"raw"`
+	Receipt
+	To      string `db:"tx_to"`
+	TxIndex int64  `db:"tx_index"`
+	Value   string
+}
+
+type RPCTransaction struct {
+	Nonce            string `json:"nonce"`
+	GasPrice         string `json:"gasPrice"`
+	GasLimit         string `json:"gas"`
+	Recipient        string `json:"to"`
+	Amount           string `json:"value"`
+	Payload          string `json:"input"`
+	V                string `json:"v"`
+	R                string `json:"r"`
+	S                string `json:"s"`
+	Hash             string
+	From             string
+	TransactionIndex string `json:"transactionIndex"`
+}

pkg/eth/core/uncle.go

@@ -0,0 +1,26 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type Uncle struct {
+	ID        int64
+	Miner     string
+	Reward    string
+	Hash      string
+	Timestamp string `db:"block_timestamp"`
+	Raw       []byte
+}

pkg/eth/core/watched_event_log.go

@@ -0,0 +1,31 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+type WatchedEvent struct {
+	LogID       int64  `json:"log_id" db:"id"`
+	Name        string `json:"name"`
+	BlockNumber int64  `json:"block_number" db:"block_number"`
+	Address     string `json:"address"`
+	TxHash      string `json:"tx_hash" db:"tx_hash"`
+	Index       int64  `json:"index"`
+	Topic0      string `json:"topic0"`
+	Topic1      string `json:"topic1"`
+	Topic2      string `json:"topic2"`
+	Topic3      string `json:"topic3"`
+	Data        string `json:"data"`
+}

pkg/eth/crypto/crypto_suite_test.go

@@ -0,0 +1,29 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package crypto_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestCrypto(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Crypto Suite")
+}

pkg/eth/crypto/parser.go

@@ -0,0 +1,37 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package crypto
+
+import (
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/p2p/discv5"
+)
+
+type PublicKeyParser interface {
+	ParsePublicKey(privateKey string) (string, error)
+}
+
+type EthPublicKeyParser struct{}
+
+func (EthPublicKeyParser) ParsePublicKey(privateKey string) (string, error) {
+	np, err := crypto.HexToECDSA(privateKey)
+	if err != nil {
+		return "", err
+	}
+	pubKey := discv5.PubkeyID(&np.PublicKey)
+	return pubKey.String(), nil
+}

pkg/eth/crypto/parser_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package crypto_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/crypto"
+)
+
+var _ = Describe("Public key parser", func() {
+	It("parses public key from private key", func() {
+		privKey := "0000000000000000000000000000000000000000000000000000000000000001"
+		parser := crypto.EthPublicKeyParser{}
+
+		pubKey, err := parser.ParsePublicKey(privKey)
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(pubKey).To(Equal("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"))
+	})
+})

pkg/eth/datastore/errors.go

@@ -0,0 +1,19 @@
+package datastore
+
+import "fmt"
+
+func ErrBlockDoesNotExist(blockNumber int64) error {
+	return fmt.Errorf("Block number %d does not exist", blockNumber)
+}
+
+func ErrContractDoesNotExist(contractHash string) error {
+	return fmt.Errorf("Contract %v does not exist", contractHash)
+}
+
+func ErrFilterDoesNotExist(name string) error {
+	return fmt.Errorf("filter %s does not exist", name)
+}
+
+func ErrReceiptDoesNotExist(txHash string) error {
+	return fmt.Errorf("Receipt for tx: %v does not exist", txHash)
+}

pkg/eth/datastore/ethereum/config.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package ethereum
+
+type DatabaseType int
+
+const (
+	Level DatabaseType = iota
+)
+
+type DatabaseConfig struct {
+	Type DatabaseType
+	Path string
+}
+
+func CreateDatabaseConfig(dbType DatabaseType, path string) DatabaseConfig {
+	return DatabaseConfig{
+		Type: dbType,
+		Path: path,
+	}
+}

pkg/eth/datastore/ethereum/database.go

@@ -0,0 +1,50 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package ethereum
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/sirupsen/logrus"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/ethereum/level"
+)
+
+type Database interface {
+	GetBlock(hash []byte, blockNumber int64) *types.Block
+	GetBlockHash(blockNumber int64) []byte
+	GetBlockReceipts(blockHash []byte, blockNumber int64) types.Receipts
+	GetHeadBlockNumber() int64
+}
+
+func CreateDatabase(config DatabaseConfig) (Database, error) {
+	switch config.Type {
+	case Level:
+		levelDBConnection, err := rawdb.NewLevelDBDatabase(config.Path, 128, 1024, "vdb")
+		if err != nil {
+			logrus.Error("CreateDatabase: error connecting to new LDBD: ", err)
+			return nil, err
+		}
+		levelDBReader := level.NewLevelDatabaseReader(levelDBConnection)
+		levelDB := level.NewLevelDatabase(levelDBReader)
+		return levelDB, nil
+	default:
+		return nil, fmt.Errorf("Unknown ethereum database: %s", config.Path)
+	}
+}

pkg/eth/datastore/ethereum/level/database.go

@@ -0,0 +1,56 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package level
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type LevelDatabase struct {
+	reader Reader
+}
+
+func NewLevelDatabase(ldbReader Reader) *LevelDatabase {
+	return &LevelDatabase{
+		reader: ldbReader,
+	}
+}
+
+func (l LevelDatabase) GetBlock(blockHash []byte, blockNumber int64) *types.Block {
+	n := uint64(blockNumber)
+	h := common.BytesToHash(blockHash)
+	return l.reader.GetBlock(h, n)
+}
+
+func (l LevelDatabase) GetBlockHash(blockNumber int64) []byte {
+	n := uint64(blockNumber)
+	h := l.reader.GetCanonicalHash(n)
+	return h.Bytes()
+}
+
+func (l LevelDatabase) GetBlockReceipts(blockHash []byte, blockNumber int64) types.Receipts {
+	n := uint64(blockNumber)
+	h := common.BytesToHash(blockHash)
+	return l.reader.GetBlockReceipts(h, n)
+}
+
+func (l LevelDatabase) GetHeadBlockNumber() int64 {
+	h := l.reader.GetHeadBlockHash()
+	n := l.reader.GetBlockNumber(h)
+	return int64(*n)
+}

pkg/eth/datastore/ethereum/level/database_reader.go

@@ -0,0 +1,61 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package level
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+type Reader interface {
+	GetBlock(hash common.Hash, number uint64) *types.Block
+	GetBlockNumber(hash common.Hash) *uint64
+	GetBlockReceipts(hash common.Hash, number uint64) types.Receipts
+	GetCanonicalHash(number uint64) common.Hash
+	GetHeadBlockHash() common.Hash
+}
+
+type LevelDatabaseReader struct {
+	reader ethdb.Reader
+}
+
+func NewLevelDatabaseReader(reader ethdb.Reader) *LevelDatabaseReader {
+	return &LevelDatabaseReader{reader: reader}
+}
+
+func (ldbr *LevelDatabaseReader) GetBlock(hash common.Hash, number uint64) *types.Block {
+	return rawdb.ReadBlock(ldbr.reader, hash, number)
+}
+
+func (ldbr *LevelDatabaseReader) GetBlockNumber(hash common.Hash) *uint64 {
+	return rawdb.ReadHeaderNumber(ldbr.reader, hash)
+}
+
+func (ldbr *LevelDatabaseReader) GetBlockReceipts(hash common.Hash, number uint64) types.Receipts {
+	return rawdb.ReadReceipts(ldbr.reader, hash, number, &params.ChainConfig{})
+}
+
+func (ldbr *LevelDatabaseReader) GetCanonicalHash(number uint64) common.Hash {
+	return rawdb.ReadCanonicalHash(ldbr.reader, number)
+}
+
+func (ldbr *LevelDatabaseReader) GetHeadBlockHash() common.Hash {
+	return rawdb.ReadHeadBlockHash(ldbr.reader)
+}

pkg/eth/datastore/ethereum/level/database_test.go

@@ -0,0 +1,87 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package level_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/ethereum/level"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/fakes"
+)
+
+var _ = Describe("Level database", func() {
+	Describe("Getting a block", func() {
+		It("converts block number to uint64 and hash to common.Hash to fetch block from reader", func() {
+			mockReader := fakes.NewMockLevelDatabaseReader()
+			ldb := level.NewLevelDatabase(mockReader)
+			blockHash := []byte{5, 4, 3, 2, 1}
+			blockNumber := int64(12345)
+
+			ldb.GetBlock(blockHash, blockNumber)
+
+			expectedBlockHash := common.BytesToHash(blockHash)
+			expectedBlockNumber := uint64(blockNumber)
+			mockReader.AssertGetBlockCalledWith(expectedBlockHash, expectedBlockNumber)
+		})
+	})
+
+	Describe("Getting a block hash", func() {
+		It("converts block number to uint64 to fetch hash from reader", func() {
+			mockReader := fakes.NewMockLevelDatabaseReader()
+			ldb := level.NewLevelDatabase(mockReader)
+			blockNumber := int64(12345)
+
+			ldb.GetBlockHash(blockNumber)
+
+			expectedBlockNumber := uint64(blockNumber)
+			mockReader.AssertGetCanonicalHashCalledWith(expectedBlockNumber)
+		})
+	})
+
+	Describe("Getting a block's receipts", func() {
+		It("converts block number to uint64 and hash to common.Hash to fetch receipts from reader", func() {
+			mockReader := fakes.NewMockLevelDatabaseReader()
+			ldb := level.NewLevelDatabase(mockReader)
+			blockHash := []byte{5, 4, 3, 2, 1}
+			blockNumber := int64(12345)
+
+			ldb.GetBlockReceipts(blockHash, blockNumber)
+
+			expectedBlockHash := common.BytesToHash(blockHash)
+			expectedBlockNumber := uint64(blockNumber)
+			mockReader.AssertGetBlockReceiptsCalledWith(expectedBlockHash, expectedBlockNumber)
+		})
+	})
+
+	Describe("Getting the latest block number", func() {
+		It("invokes the database reader to get the latest block number by hash and converts result to int64", func() {
+			mockReader := fakes.NewMockLevelDatabaseReader()
+			fakeHash := common.BytesToHash([]byte{1, 2, 3, 4, 5})
+			mockReader.SetHeadBlockHashReturnHash(fakeHash)
+			fakeBlockNumber := uint64(123456789)
+			mockReader.SetReturnBlockNumber(fakeBlockNumber)
+			ldb := level.NewLevelDatabase(mockReader)
+
+			result := ldb.GetHeadBlockNumber()
+
+			mockReader.AssertGetHeadBlockHashCalled()
+			mockReader.AssertGetBlockNumberCalledWith(fakeHash)
+			Expect(result).To(Equal(int64(fakeBlockNumber)))
+		})
+	})
+})

pkg/eth/datastore/ethereum/level/level_suite_test.go

@@ -0,0 +1,29 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package level_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestLevel(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Level Suite")
+}

pkg/eth/datastore/postgres/errors.go

@@ -0,0 +1,37 @@
+package postgres
+
+import (
+	"fmt"
+)
+
+const (
+	BeginTransactionFailedMsg = "failed to begin transaction"
+	DbConnectionFailedMsg     = "db connection failed"
+	DeleteQueryFailedMsg      = "delete query failed"
+	InsertQueryFailedMsg      = "insert query failed"
+	SettingNodeFailedMsg      = "unable to set db node"
+)
+
+func ErrBeginTransactionFailed(beginErr error) error {
+	return formatError(BeginTransactionFailedMsg, beginErr.Error())
+}
+
+func ErrDBConnectionFailed(connectErr error) error {
+	return formatError(DbConnectionFailedMsg, connectErr.Error())
+}
+
+func ErrDBDeleteFailed(deleteErr error) error {
+	return formatError(DeleteQueryFailedMsg, deleteErr.Error())
+}
+
+func ErrDBInsertFailed(insertErr error) error {
+	return formatError(InsertQueryFailedMsg, insertErr.Error())
+}
+
+func ErrUnableToSetNode(setErr error) error {
+	return formatError(SettingNodeFailedMsg, setErr.Error())
+}
+
+func formatError(msg, err string) error {
+	return fmt.Errorf("%s: %s", msg, err)
+}

pkg/eth/datastore/postgres/postgres.go

@@ -0,0 +1,64 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package postgres
+
+import (
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq" //postgres driver
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+)
+
+type DB struct {
+	*sqlx.DB
+	Node   core.Node
+	NodeID int64
+}
+
+func NewDB(databaseConfig config.Database, node core.Node) (*DB, error) {
+	connectString := config.DbConnectionString(databaseConfig)
+	db, connectErr := sqlx.Connect("postgres", connectString)
+	if connectErr != nil {
+		return &DB{}, ErrDBConnectionFailed(connectErr)
+	}
+	pg := DB{DB: db, Node: node}
+	nodeErr := pg.CreateNode(&node)
+	if nodeErr != nil {
+		return &DB{}, ErrUnableToSetNode(nodeErr)
+	}
+	return &pg, nil
+}
+
+func (db *DB) CreateNode(node *core.Node) error {
+	var nodeID int64
+	err := db.QueryRow(
+		`INSERT INTO eth_nodes (genesis_block, network_id, eth_node_id, client_name)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT (genesis_block, network_id, eth_node_id)
+                  DO UPDATE
+                    SET genesis_block = $1,
+                        network_id = $2,
+                        eth_node_id = $3,
+                        client_name = $4
+                RETURNING id`,
+		node.GenesisBlock, node.NetworkID, node.ID, node.ClientName).Scan(&nodeID)
+	if err != nil {
+		return ErrUnableToSetNode(err)
+	}
+	db.NodeID = nodeID
+	return nil
+}

pkg/eth/datastore/postgres/postgres_suite_test.go

@@ -0,0 +1,36 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package postgres_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	log "github.com/sirupsen/logrus"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func init() {
+	log.SetOutput(ioutil.Discard)
+}
+
+func TestPostgres(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Postgres Suite")
+}

pkg/eth/datastore/postgres/postgres_test.go

@@ -0,0 +1,165 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package postgres_test
+
+import (
+	"fmt"
+	"strings"
+
+	"math/big"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/test_config"
+)
+
+var _ = Describe("Postgres DB", func() {
+	var sqlxdb *sqlx.DB
+
+	It("connects to the database", func() {
+		var err error
+		pgConfig := config.DbConnectionString(test_config.DBConfig)
+
+		sqlxdb, err = sqlx.Connect("postgres", pgConfig)
+
+		Expect(err).Should(BeNil())
+		Expect(sqlxdb).ShouldNot(BeNil())
+	})
+
+	It("serializes big.Int to db", func() {
+		// postgres driver doesn't support go big.Int type
+		// various casts in golang uint64, int64, overflow for
+		// transaction value (in wei) even though
+		// postgres numeric can handle an arbitrary
+		// sized int, so use string representation of big.Int
+		// and cast on insert
+
+		pgConnectString := config.DbConnectionString(test_config.DBConfig)
+		db, err := sqlx.Connect("postgres", pgConnectString)
+		Expect(err).NotTo(HaveOccurred())
+
+		bi := new(big.Int)
+		bi.SetString("34940183920000000000", 10)
+		Expect(bi.String()).To(Equal("34940183920000000000"))
+
+		defer db.Exec(`DROP TABLE IF EXISTS example`)
+		_, err = db.Exec("CREATE TABLE example ( id INTEGER, data NUMERIC )")
+		Expect(err).ToNot(HaveOccurred())
+
+		sqlStatement := `  
+			INSERT INTO example (id, data)
+			VALUES (1, cast($1 AS NUMERIC))`
+		_, err = db.Exec(sqlStatement, bi.String())
+		Expect(err).ToNot(HaveOccurred())
+
+		var data string
+		err = db.QueryRow(`SELECT data FROM example WHERE id = 1`).Scan(&data)
+		Expect(err).ToNot(HaveOccurred())
+
+		Expect(bi.String()).To(Equal(data))
+		actual := new(big.Int)
+		actual.SetString(data, 10)
+		Expect(actual).To(Equal(bi))
+	})
+
+	It("does not commit block if block is invalid", func() {
+		//badNonce violates db Nonce field length
+		badNonce := fmt.Sprintf("x %s", strings.Repeat("1", 100))
+		badBlock := core.Block{
+			Number:       123,
+			Nonce:        badNonce,
+			Transactions: []core.TransactionModel{},
+		}
+		node := core.Node{GenesisBlock: "GENESIS", NetworkID: 1, ID: "x123", ClientName: "geth"}
+		db := test_config.NewTestDB(node)
+		test_config.CleanTestDB(db)
+		blocksRepository := repositories.NewBlockRepository(db)
+
+		_, err1 := blocksRepository.CreateOrUpdateBlock(badBlock)
+
+		Expect(err1).To(HaveOccurred())
+		savedBlock, err2 := blocksRepository.GetBlock(123)
+		Expect(err2).To(HaveOccurred())
+		Expect(savedBlock).To(BeZero())
+	})
+
+	It("throws error when can't connect to the database", func() {
+		invalidDatabase := config.Database{}
+		node := core.Node{GenesisBlock: "GENESIS", NetworkID: 1, ID: "x123", ClientName: "geth"}
+
+		_, err := postgres.NewDB(invalidDatabase, node)
+
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring(postgres.DbConnectionFailedMsg))
+	})
+
+	It("throws error when can't create node", func() {
+		badHash := fmt.Sprintf("x %s", strings.Repeat("1", 100))
+		node := core.Node{GenesisBlock: badHash, NetworkID: 1, ID: "x123", ClientName: "geth"}
+
+		_, err := postgres.NewDB(test_config.DBConfig, node)
+
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring(postgres.SettingNodeFailedMsg))
+	})
+
+	It("does not commit log if log is invalid", func() {
+		//badTxHash violates db tx_hash field length
+		badTxHash := fmt.Sprintf("x %s", strings.Repeat("1", 100))
+		badLog := core.FullSyncLog{
+			Address:     "x123",
+			BlockNumber: 1,
+			TxHash:      badTxHash,
+		}
+		node := core.Node{GenesisBlock: "GENESIS", NetworkID: 1, ID: "x123", ClientName: "geth"}
+		db, _ := postgres.NewDB(test_config.DBConfig, node)
+		logRepository := repositories.FullSyncLogRepository{DB: db}
+
+		err := logRepository.CreateLogs([]core.FullSyncLog{badLog}, 123)
+
+		Expect(err).ToNot(BeNil())
+		savedBlock, err := logRepository.GetLogs("x123", 1)
+		Expect(savedBlock).To(BeNil())
+		Expect(err).To(Not(HaveOccurred()))
+	})
+
+	It("does not commit block or transactions if transaction is invalid", func() {
+		//badHash violates db To field length
+		badHash := fmt.Sprintf("x %s", strings.Repeat("1", 100))
+		badTransaction := core.TransactionModel{To: badHash}
+		block := core.Block{
+			Number:       123,
+			Transactions: []core.TransactionModel{badTransaction},
+		}
+		node := core.Node{GenesisBlock: "GENESIS", NetworkID: 1, ID: "x123", ClientName: "geth"}
+		db, _ := postgres.NewDB(test_config.DBConfig, node)
+		blockRepository := repositories.NewBlockRepository(db)
+
+		_, err1 := blockRepository.CreateOrUpdateBlock(block)
+
+		Expect(err1).To(HaveOccurred())
+		savedBlock, err2 := blockRepository.GetBlock(123)
+		Expect(err2).To(HaveOccurred())
+		Expect(savedBlock).To(BeZero())
+	})
+})

pkg/eth/datastore/postgres/repositories/block_repository.go

@@ -0,0 +1,344 @@
+// VulcanizeDB
+// Copyright © 2019 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package repositories
+
+import (
+	"database/sql"
+	"errors"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/sirupsen/logrus"
+
+	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore"
+	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+)
+
+const (
+	blocksFromHeadBeforeFinal = 20
+)
+
+var ErrBlockExists = errors.New("Won't add block that already exists.")
+
+type BlockRepository struct {
+	database *postgres.DB
+}
+
+func NewBlockRepository(database *postgres.DB) *BlockRepository {
+	return &BlockRepository{database: database}
+}
+
+func (blockRepository BlockRepository) SetBlocksStatus(chainHead int64) error {
+	cutoff := chainHead - blocksFromHeadBeforeFinal
+	_, err := blockRepository.database.Exec(`
+                  UPDATE eth_blocks SET is_final = TRUE
+                  WHERE is_final = FALSE AND number < $1`,
+		cutoff)
+
+	return err
+}
+
+func (blockRepository BlockRepository) CreateOrUpdateBlock(block core.Block) (int64, error) {
+	var err error
+	var blockID int64
+	retrievedBlockHash, ok := blockRepository.getBlockHash(block)
+	if !ok {
+		return blockRepository.insertBlock(block)
+	}
+	if ok && retrievedBlockHash != block.Hash {
+		err = blockRepository.removeBlock(block.Number)
+		if err != nil {
+			return 0, err
+		}
+		return blockRepository.insertBlock(block)
+	}
+	return blockID, ErrBlockExists
+}
+
+func (blockRepository BlockRepository) MissingBlockNumbers(startingBlockNumber int64, highestBlockNumber int64, nodeID string) []int64 {
+	numbers := make([]int64, 0)
+	err := blockRepository.database.Select(&numbers,
+		`SELECT all_block_numbers
+          FROM (
+              SELECT generate_series($1::INT, $2::INT) AS all_block_numbers) series
+          WHERE all_block_numbers NOT IN (
+			  SELECT number FROM eth_blocks WHERE eth_node_fingerprint = $3
+		  ) `,
+		startingBlockNumber,
+		highestBlockNumber, nodeID)
+	if err != nil {
+		logrus.Error("MissingBlockNumbers: error getting blocks: ", err)
+	}
+	return numbers
+}
+
+func (blockRepository BlockRepository) GetBlock(blockNumber int64) (core.Block, error) {
+	blockRows := blockRepository.database.QueryRowx(
+		`SELECT id,
+                       number,
+                       gas_limit,
+                       gas_used,
+                       time,
+                       difficulty,
+                       hash,
+                       nonce,
+                       parent_hash,
+                       size,
+                       uncle_hash,
+                       is_final,
+                       miner,
+                       extra_data,
+                       reward,
+                       uncles_reward
+               FROM eth_blocks
+               WHERE eth_node_id = $1 AND number = $2`, blockRepository.database.NodeID, blockNumber)
+	savedBlock, err := blockRepository.loadBlock(blockRows)
+	if err != nil {
+		switch err {
+		case sql.ErrNoRows:
+			return core.Block{}, datastore.ErrBlockDoesNotExist(blockNumber)
+		default:
+			logrus.Error("GetBlock: error loading blocks: ", err)
+			return savedBlock, err
+		}
+	}
+	return savedBlock, nil
+}
+
+func (blockRepository BlockRepository) insertBlock(block core.Block) (int64, error) {
+	var blockID int64
+	tx, beginErr := blockRepository.database.Beginx()
+	if beginErr != nil {
+		return 0, postgres.ErrBeginTransactionFailed(beginErr)
+	}
+	insertBlockErr := tx.QueryRow(
+		`INSERT INTO eth_blocks
+                (eth_node_id, number, gas_limit, gas_used, time, difficulty, hash, nonce, parent_hash, size, uncle_hash, is_final, miner, extra_data, reward, uncles_reward, eth_node_fingerprint)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
+                RETURNING id `,
+		blockRepository.database.NodeID,
+		block.Number,
+		block.GasLimit,
+		block.GasUsed,
+		block.Time,
+		block.Difficulty,
+		block.Hash,
+		block.Nonce,
+		block.ParentHash,
+		block.Size,
+		block.UncleHash,
+		block.IsFinal,
+		block.Miner,
+		block.ExtraData,
+		nullStringToZero(block.Reward),
+		nullStringToZero(block.UnclesReward),
+		blockRepository.database.Node.ID).
+		Scan(&blockID)
+	if insertBlockErr != nil {
+		rollbackErr := tx.Rollback()
+		if rollbackErr != nil {
+			logrus.Error("failed to rollback transaction: ", rollbackErr)
+		}
+		return 0, postgres.ErrDBInsertFailed(insertBlockErr)
+	}
+	if len(block.Uncles) > 0 {
+		insertUncleErr := blockRepository.createUncles(tx, blockID, block.Hash, block.Uncles)
+		if insertUncleErr != nil {
+			tx.Rollback()
+			return 0, postgres.ErrDBInsertFailed(insertUncleErr)
+		}
+	}
+	if len(block.Transactions) > 0 {
+		insertTxErr := blockRepository.createTransactions(tx, blockID, block.Transactions)
+		if insertTxErr != nil {
+			rollbackErr := tx.Rollback()
+			if rollbackErr != nil {
+				logrus.Warn("failed to rollback transaction: ", rollbackErr)
+			}
+			return 0, postgres.ErrDBInsertFailed(insertTxErr)
+		}
+	}
+	commitErr := tx.Commit()
+	if commitErr != nil {
+		rollbackErr := tx.Rollback()
+		if rollbackErr != nil {
+			logrus.Warn("failed to rollback transaction: ", rollbackErr)
+		}
+		return 0, commitErr
+	}
+	return blockID, nil
+}
+
+func (blockRepository BlockRepository) createUncles(tx *sqlx.Tx, blockID int64, blockHash string, uncles []core.Uncle) error {
+	for _, uncle := range uncles {
+		err := blockRepository.createUncle(tx, blockID, uncle)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (blockRepository BlockRepository) createUncle(tx *sqlx.Tx, blockID int64, uncle core.Uncle) error {
+	_, err := tx.Exec(
+		`INSERT INTO uncles
+       (hash, block_id, reward, miner, raw, block_timestamp, eth_node_id, eth_node_fingerprint)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::NUMERIC, $8)
+       RETURNING id`,
+		uncle.Hash, blockID, nullStringToZero(uncle.Reward), uncle.Miner, uncle.Raw, uncle.Timestamp, blockRepository.database.NodeID, blockRepository.database.Node.ID)
+	return err
+}
+
+func (blockRepository BlockRepository) createTransactions(tx *sqlx.Tx, blockID int64, transactions []core.TransactionModel) error {
+	for _, transaction := range transactions {
+		err := blockRepository.createTransaction(tx, blockID, transaction)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+//Fields like value lose precision if converted to
+//int64 so convert to string instead. But nil
+//big.Int -> string = "" so convert to "0"
+func nullStringToZero(s string) string {
+	if s == "" {
+		return "0"
+	}
+	return s
+}
+
+func (blockRepository BlockRepository) createTransaction(tx *sqlx.Tx, blockID int64, transaction core.TransactionModel) error {
+	_, err := tx.Exec(
+		`INSERT INTO full_sync_transactions
+       (block_id, gas_limit, gas_price, hash, input_data, nonce, raw, tx_from, tx_index, tx_to, "value")
+       VALUES ($1, $2::NUMERIC, $3::NUMERIC, $4, $5, $6::NUMERIC, $7,  $8, $9::NUMERIC, $10, $11::NUMERIC)
+       RETURNING id`, blockID, transaction.GasLimit, transaction.GasPrice, transaction.Hash, transaction.Data,
+		transaction.Nonce, transaction.Raw, transaction.From, transaction.TxIndex, transaction.To, nullStringToZero(transaction.Value))
+	if err != nil {
+		return err
+	}
+	if hasReceipt(transaction) {
+		receiptRepo := FullSyncReceiptRepository{}
+		receiptID, err := receiptRepo.CreateFullSyncReceiptInTx(blockID, transaction.Receipt, tx)
+		if err != nil {
+			return err
+		}
+		if hasLogs(transaction) {
+			err = blockRepository.createLogs(tx, transaction.Receipt.Logs, receiptID)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func hasLogs(transaction core.TransactionModel) bool {
+	return len(transaction.Receipt.Logs) > 0
+}
+
+func hasReceipt(transaction core.TransactionModel) bool {
+	return transaction.Receipt.TxHash != ""
+}
+
+func (blockRepository BlockRepository) getBlockHash(block core.Block) (string, bool) {
+	var retrievedBlockHash string
+	// TODO: handle possible error
+	blockRepository.database.Get(&retrievedBlockHash,
+		`SELECT hash
+               FROM eth_blocks
+               WHERE number = $1 AND eth_node_id = $2`,
+		block.Number, blockRepository.database.NodeID)
+	return retrievedBlockHash, blockExists(retrievedBlockHash)
+}
+
+func (blockRepository BlockRepository) createLogs(tx *sqlx.Tx, logs []core.FullSyncLog, receiptID int64) error {
+	for _, tlog := range logs {
+		_, err := tx.Exec(
+			`INSERT INTO full_sync_logs (block_number, address, tx_hash, index, topic0, topic1, topic2, topic3, data, receipt_id)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+                `,
+			tlog.BlockNumber, tlog.Address, tlog.TxHash, tlog.Index, tlog.Topics[0], tlog.Topics[1], tlog.Topics[2], tlog.Topics[3], tlog.Data, receiptID,
+		)
+		if err != nil {
+			return postgres.ErrDBInsertFailed(err)
+		}
+	}
+	return nil
+}
+
+func blockExists(retrievedBlockHash string) bool {
+	return retrievedBlockHash != ""
+}
+
+func (blockRepository BlockRepository) removeBlock(blockNumber int64) error {
+	_, err := blockRepository.database.Exec(
+		`DELETE FROM eth_blocks WHERE number=$1 AND eth_node_id=$2`,
+		blockNumber, blockRepository.database.NodeID)
+	if err != nil {
+		return postgres.ErrDBDeleteFailed(err)
+	}
+	return nil
+}
+
+func (blockRepository BlockRepository) loadBlock(blockRows *sqlx.Row) (core.Block, error) {
+	type b struct {
+		ID int
+		core.Block
+	}
+	var block b
+	err := blockRows.StructScan(&block)
+	if err != nil {
+		logrus.Error("loadBlock: error loading block: ", err)
+		return core.Block{}, err
+	}
+	transactionRows, err := blockRepository.database.Queryx(`
+		SELECT hash,
+			gas_limit,
+			gas_price,
+			input_data,
+			nonce,
+			raw,
+			tx_from,
+			tx_index,
+			tx_to,
+			value
+		FROM full_sync_transactions
+		WHERE block_id = $1
+		ORDER BY hash`, block.ID)
+	if err != nil {
+		logrus.Error("loadBlock: error fetting transactions: ", err)
+		return core.Block{}, err
+	}
+	block.Transactions = blockRepository.LoadTransactions(transactionRows)
+	return block.Block, nil
+}
+
+func (blockRepository BlockRepository) LoadTransactions(transactionRows *sqlx.Rows) []core.TransactionModel {
+	var transactions []core.TransactionModel
+	for transactionRows.Next() {
+		var transaction core.TransactionModel
+		err := transactionRows.StructScan(&transaction)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+		transactions = append(transactions, transaction)
+	}
+	return transactions
+}