mv pkg/omni pkg/contract_watcher

pkg/contract_watcher/full/converter/converter.go

@@ -0,0 +1,122 @@
+// 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 (
+	"errors"
+	"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/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+)
+
+// Converter is used to convert watched event logs to
+// custom logs containing event input name => value maps
+type Converter interface {
+	Convert(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error)
+	Update(info *contract.Contract)
+}
+
+type converter struct {
+	ContractInfo *contract.Contract
+}
+
+func NewConverter(info *contract.Contract) *converter {
+	return &converter{
+		ContractInfo: info,
+	}
+}
+
+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(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error) {
+	contract := bind.NewBoundContract(common.HexToAddress(c.ContractInfo.Address), c.ContractInfo.ParsedAbi, nil, nil, nil)
+	values := make(map[string]interface{})
+	log := helpers.ConvertToLog(watchedEvent)
+	err := contract.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, errors.New(fmt.Sprintf("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/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/contract_watcher/full/converter/converter_test.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 converter_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/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.NewConverter(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.NewConverter(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.NewConverter(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.NewConverter(&contract.Contract{})
+			_, err = c.Convert(mocks.MockTranferEvent, event)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/contract_watcher/full/retriever/block_retriever.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 retriever
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+// Block retriever 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
+}
+
+func NewBlockRetriever(db *postgres.DB) (r *blockRetriever) {
+	return &blockRetriever{
+		db: db,
+	}
+}
+
+// Try 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 {
+		i, err = r.retrieveFirstBlockFromLogs(contractAddr)
+	}
+
+	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 int
+	err := r.db.Get(
+		&firstBlock,
+		`SELECT number FROM blocks
+		       WHERE id = (SELECT block_id FROM receipts
+               	           WHERE lower(contract_address) = $1
+		                   ORDER BY block_id ASC
+					       LIMIT 1)`,
+		contractAddr,
+	)
+
+	return int64(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 logs WHERE lower(address) = $1 ORDER BY block_number ASC LIMIT 1",
+		contractAddr,
+	)
+
+	return int64(firstBlock), err
+}
+
+// Method to retrieve the most recent block in vDB
+func (r *blockRetriever) RetrieveMostRecentBlock() (int64, error) {
+	var lastBlock int64
+	err := r.db.Get(
+		&lastBlock,
+		"SELECT number FROM blocks ORDER BY number DESC LIMIT 1",
+	)
+
+	return lastBlock, err
+}

pkg/contract_watcher/full/retriever/block_retriever_test.go

@@ -0,0 +1,218 @@
+// 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"
+	"strings"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/full/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+)
+
+var _ = Describe("Block Retriever", func() {
+	var db *postgres.DB
+	var r retriever.BlockRetriever
+	var blockRepository repositories.BlockRepository
+
+	// Contains no contract address
+	var block1 = core.Block{
+		Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+		Number:       1,
+		Transactions: []core.Transaction{},
+	}
+
+	BeforeEach(func() {
+		db, _ = test_helpers.SetupDBandBC()
+		blockRepository = *repositories.NewBlockRepository(db)
+		r = retriever.NewBlockRetriever(db)
+	})
+
+	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.Transaction{{
+					Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+						ContractAddress: constants.TusdContractAddress,
+						Logs:            []core.Log{},
+					},
+				}},
+			}
+
+			// Contains address in logs
+			block3 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number: 3,
+				Transactions: []core.Transaction{{
+					Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+						ContractAddress: constants.TusdContractAddress,
+						Logs: []core.Log{{
+							BlockNumber: 3,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+							Address:     constants.TusdContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+				}},
+			}
+
+			blockRepository.CreateOrUpdateBlock(block1)
+			blockRepository.CreateOrUpdateBlock(block2)
+			blockRepository.CreateOrUpdateBlock(block3)
+
+			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.Transaction{{
+					Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+						ContractAddress: "",
+						Logs: []core.Log{{
+							BlockNumber: 2,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
+							Address:     constants.DaiContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+				}},
+			}
+
+			block3 := core.Block{
+				Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number: 3,
+				Transactions: []core.Transaction{{
+					Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+					Receipt: core.Receipt{
+						TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+						ContractAddress: "",
+						Logs: []core.Log{{
+							BlockNumber: 3,
+							TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad234hfs",
+							Address:     constants.DaiContractAddress,
+							Topics: core.Topics{
+								constants.TransferEvent.Signature(),
+								"0x000000000000000000000000000000000000000000000000000000000000af21",
+								"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+								"",
+							},
+							Index: 1,
+							Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+						}},
+					},
+				}},
+			}
+
+			blockRepository.CreateOrUpdateBlock(block1)
+			blockRepository.CreateOrUpdateBlock(block2)
+			blockRepository.CreateOrUpdateBlock(block3)
+
+			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.Transaction{},
+			}
+
+			block3 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number:       3,
+				Transactions: []core.Transaction{},
+			}
+
+			blockRepository.CreateOrUpdateBlock(block1)
+			blockRepository.CreateOrUpdateBlock(block2)
+			blockRepository.CreateOrUpdateBlock(block3)
+
+			_, 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.Transaction{},
+			}
+
+			block3 := core.Block{
+				Hash:         "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad456yui",
+				Number:       3,
+				Transactions: []core.Transaction{},
+			}
+
+			blockRepository.CreateOrUpdateBlock(block1)
+			blockRepository.CreateOrUpdateBlock(block2)
+			blockRepository.CreateOrUpdateBlock(block3)
+
+			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/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Block Number Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/full/transformer/transformer.go

@@ -0,0 +1,215 @@
+// 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/vulcanize/vulcanizedb/pkg/config"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/full/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+)
+
+// Requires a fully synced vDB and a running eth node (or infura)
+type transformer struct {
+	// Database interfaces
+	datastore.FilterRepository       // Log filters repo; accepts filters generated by Contract.GenerateFilters()
+	datastore.WatchedEventRepository // Watched event log views, created by the log filters
+	repository.EventRepository       // Holds transformed watched event log data
+
+	// Pre-processing interfaces
+	parser.Parser            // Parses events and methods out of contract abi fetched using contract address
+	retriever.BlockRetriever // Retrieves first block for contract and current block height
+
+	// Processing interfaces
+	converter.Converter // Converts watched event logs into custom log
+	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
+}
+
+// Transformer takes in config for blockchain, database, and network id
+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),
+		BlockRetriever:         retriever.NewBlockRetriever(DB),
+		Converter:              converter.NewConverter(&contract.Contract{}),
+		Contracts:              map[string]*contract.Contract{},
+		WatchedEventRepository: repositories.WatchedEventRepository{DB: DB},
+		FilterRepository:       repositories.FilterRepository{DB: DB},
+		EventRepository:        repository.NewEventRepository(DB, types.FullSync),
+		Config:                 con,
+	}
+}
+
+// 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.BlockRetriever.RetrieveFirstBlock(contractAddr)
+		if err != nil {
+			return err
+		}
+		lastBlock, err := tr.BlockRetriever.RetrieveMostRecentBlock()
+		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)
+		tr.FetchContractData(tr.Abi(), contractAddr, "name", nil, &name, lastBlock)
+
+		// 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,
+			LastBlock:     lastBlock,
+			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.CreateFilter(filter)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Store contract info for further processing
+		tr.Contracts[contractAddr] = info
+	}
+
+	return nil
+}
+
+// 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 custuom 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.Update(con)
+
+		// Iterate through contract filters and get watched event logs
+		for eventSig, filter := range con.Filters {
+			watchedEvents, err := tr.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.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
+		// Run this in seperate goroutine?
+		if err := tr.PollContract(*con); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (tr *transformer) GetConfig() config.ContractConfig {
+	return tr.Config
+}

pkg/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestTransformer(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Transformer Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/full/transformer/transformer_test.go

@@ -0,0 +1,323 @@
+// 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 (
+	"fmt"
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/full/transformer"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+)
+
+var _ = Describe("Transformer", func() {
+	var db *postgres.DB
+	var err error
+	var blockChain core.BlockChain
+	var blockRepository repositories.BlockRepository
+	var ensAddr = strings.ToLower(constants.EnsContractAddress)
+	var tusdAddr = strings.ToLower(constants.TusdContractAddress)
+	rand.Seed(time.Now().UnixNano())
+
+	BeforeEach(func() {
+		db, blockChain = test_helpers.SetupDBandBC()
+		blockRepository = *repositories.NewBlockRepository(db)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Init", func() {
+		It("Initializes transformer's contract objects", func() {
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(int64(6194633)))
+			Expect(c.LastBlock).To(Equal(int64(6194634)))
+			Expect(c.Abi).To(Equal(constants.TusdAbiString))
+			Expect(c.Name).To(Equal("TrueUSD"))
+			Expect(c.Address).To(Equal(tusdAddr))
+		})
+
+		It("Fails to initialize if first and most recent blocks cannot be fetched from vDB", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("Does nothing if watched events are unset", func() {
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Events = nil
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).To(HaveOccurred())
+
+			_, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(false))
+		})
+	})
+
+	Describe("Execute", func() {
+		BeforeEach(func() {
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.TransferBlock2)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.TransferLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event WHERE block = 6194634", tusdAddr)).StructScan(&log)
+
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee"))
+			Expect(log.Block).To(Equal(int64(6194634)))
+			Expect(log.From).To(Equal("0x000000000000000000000000000000000000Af21"))
+			Expect(log.To).To(Equal("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391"))
+			Expect(log.Value).To(Equal("1097077688018008265106216665536940668749033598146"))
+		})
+
+		It("Keeps track of contract-related addresses while transforming event data if they need to be used for later method polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Methods = map[string][]string{
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			b, ok := c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843bCE061BA391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843b1234567890")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given methods using generated token holder address", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Methods = map[string][]string{
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.BalanceOf{}
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x000000000000000000000000000000000000Af21' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Balance).To(Equal("0"))
+			Expect(res.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843bCE061BA391' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Balance).To(Equal("0"))
+			Expect(res.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6194634'", tusdAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("Fails if initialization has not been done", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+
+			err = t.Execute()
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("Execute- against ENS registry contract", func() {
+		BeforeEach(func() {
+			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock1)
+			blockRepository.CreateOrUpdateBlock(mocks.NewOwnerBlock2)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer(mocks.ENSConfig, blockChain, db)
+
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.NewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
+
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.Tx).To(Equal("0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb"))
+			Expect(log.Block).To(Equal(int64(6194635)))
+			Expect(log.Node).To(Equal("0x0000000000000000000000000000000000000000000000000000c02aaa39b223"))
+			Expect(log.Label).To(Equal("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391"))
+			Expect(log.Owner).To(Equal("0x000000000000000000000000000000000000Af21"))
+		})
+
+		It("Keeps track of contract-related hashes while transforming event data if they need to be used for later method polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[ensAddr]
+			Expect(ok).To(Equal(true))
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(c.EmittedHashes)).To(Equal(3))
+
+			b, ok := c.EmittedHashes[common.HexToHash("0x0000000000000000000000000000000000000000000000000000c02aaa39b223")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedHashes[common.HexToHash("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			// Doesn't keep track of address since it wouldn't be used in calling the 'owner' method
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x000000000000000000000000000000000000Af21")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given methods using generated token holder address", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9THIS110dcc444fIS242510c09bbAbe21aFAKEcacNODE82f7b843HASH61ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("It does not perist events if they do not pass the emitted arg filter", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.EventArgs = map[string][]string{
+				ensAddr: {"fake_filter_value"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.LightNewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.newowner_event", ensAddr)).StructScan(&log)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("If a method arg filter is applied, only those arguments are used in polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			testConf.MethodArgs = map[string][]string{
+				ensAddr: {"0x0000000000000000000000000000000000000000000000000000c02aaa39b223"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x0000000000000000000000000000000000000000000000000000c02aaa39b223' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391' AND block = '6194636'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/contract_watcher/light/converter/converter.go

@@ -0,0 +1,213 @@
+// 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"
+	"errors"
+	"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/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+)
+
+type Converter 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)
+}
+
+type converter struct {
+	ContractInfo *contract.Contract
+}
+
+func NewConverter(info *contract.Contract) *converter {
+	return &converter{
+		ContractInfo: info,
+	}
+}
+
+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) {
+	contract := 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 := contract.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 byte:
+				b := input.(byte)
+				strValues[fieldName] = string(b)
+			default:
+				return nil, errors.New(fmt.Sprintf("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
+}
+
+// Convert 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) {
+	contract := 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 := contract.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 byte:
+						b := input.(byte)
+						strValues[fieldName] = string(b)
+					default:
+						return nil, errors.New(fmt.Sprintf("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
+}

pkg/contract_watcher/light/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, "Light Converter Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/light/converter/converter_test.go

@@ -0,0 +1,151 @@
+// 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/contract_watcher/light/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/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 err error
+
+	Describe("Update", func() {
+		It("Updates contract info held by the converter", func() {
+			con = test_helpers.SetupTusdContract(tusdWantedEvents, []string{})
+			c := converter.NewConverter(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.NewConverter(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.NewConverter(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.NewConverter(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("Fails with an empty contract", func() {
+			event := con.Events["Transfer"]
+			c := converter.NewConverter(&contract.Contract{})
+			_, err = c.Convert([]types.Log{mocks.MockTransferLog1}, event, 232)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/contract_watcher/light/fetcher/fetcher.go

@@ -0,0 +1,69 @@
+// 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/core"
+)
+
+type Fetcher interface {
+	FetchLogs(contractAddresses []string, topics []common.Hash, missingHeader core.Header) ([]types.Log, error)
+}
+
+type fetcher struct {
+	blockChain core.BlockChain
+}
+
+func NewFetcher(blockchain core.BlockChain) *fetcher {
+	return &fetcher{
+		blockChain: blockchain,
+	}
+}
+
+// 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/contract_watcher/light/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/contract_watcher/light/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/contract_watcher/light/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/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/contract_watcher/light/repository/header_repository.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 repository
+
+import (
+	"database/sql"
+	"fmt"
+
+	"github.com/hashicorp/golang-lru"
+
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+const columnCacheSize = 1000
+
+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
+}
+
+func NewHeaderRepository(db *postgres.DB) *headerRepository {
+	ccs, _ := lru.New(columnCacheSize)
+	return &headerRepository{
+		db:      db,
+		columns: ccs,
+	}
+}
+
+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
+}
+
+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
+}
+
+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
+}
+
+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
+}
+
+func (r *headerRepository) MarkHeadersCheckedForAll(headers []core.Header, ids []string) error {
+	tx, err := r.db.Begin()
+	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 {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+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 result, err
+}
+
+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 result, err
+}
+
+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 result, err
+}
+
+func (r *headerRepository) CheckCache(key string) (interface{}, bool) {
+	return r.columns.Get(key)
+}
+
+func MarkHeaderCheckedInTransaction(headerID int64, tx *sql.Tx, eventID string) error {
+	_, err := tx.Exec(`INSERT INTO public.checked_headers (header_id, `+eventID+`)
+		VALUES ($1, $2) 
+		ON CONFLICT (header_id) DO
+			UPDATE SET `+eventID+` = checked_headers.`+eventID+` + 1`, headerID, 1)
+	return err
+}

pkg/contract_watcher/light/repository/header_repository_test.go

@@ -0,0 +1,317 @@
+// 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/vulcanize/vulcanizedb/pkg/core"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+)
+
+var _ = Describe("Repository", func() {
+	var db *postgres.DB
+	var omniHeaderRepo repository.HeaderRepository   // omni/light 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()
+		omniHeaderRepo = 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 = omniHeaderRepo.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 := omniHeaderRepo.CheckCache(eventIDs[0])
+			Expect(ok).To(Equal(false))
+
+			err := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			v, ok := omniHeaderRepo.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 := omniHeaderRepo.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 := omniHeaderRepo.CheckCache(id)
+				Expect(ok).To(Equal(false))
+			}
+
+			err := omniHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			for _, id := range eventIDs {
+				v, ok := omniHeaderRepo.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 := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeaders(6194630, 6194635, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+		})
+
+		It("Returns unchecked headers in ascending order", func() {
+			addHeaders(coreHeaderRepo)
+			err := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeaders(6194630, 6194635, 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(int64(6194632)))
+			Expect(h2.BlockNumber).To(Equal(int64(6194633)))
+			Expect(h3.BlockNumber).To(Equal(int64(6194634)))
+		})
+
+		It("Fails if eventID does not yet exist in check_headers table", func() {
+			addHeaders(coreHeaderRepo)
+			err := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			_, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, "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 := omniHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeadersForAll(6194630, 6194635, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			err = omniHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = omniHeaderRepo.MissingHeadersForAll(6194630, 6194635, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			err = omniHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[1])
+			Expect(err).ToNot(HaveOccurred())
+			err = omniHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[2])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = omniHeaderRepo.MissingHeadersForAll(6194630, 6194635, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(2))
+		})
+
+		It("Fails if one of the eventIDs does not yet exist in check_headers table", func() {
+			addHeaders(coreHeaderRepo)
+			err := omniHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			badEventIDs := append(eventIDs, "notEventId")
+
+			_, err = omniHeaderRepo.MissingHeadersForAll(6194630, 6194635, badEventIDs)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("MarkHeaderChecked", func() {
+		It("Marks the header checked for the given eventID", func() {
+			addHeaders(coreHeaderRepo)
+			err := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeaders(6194630, 6194635, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].Id
+			err = omniHeaderRepo.MarkHeaderChecked(headerID, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, 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 := omniHeaderRepo.AddCheckColumn(eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeaders(6194630, 6194635, eventIDs[0])
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].Id
+			err = omniHeaderRepo.MarkHeaderChecked(headerID, "notEventId")
+			Expect(err).To(HaveOccurred())
+
+			missingHeaders, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, 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 := omniHeaderRepo.AddCheckColumns(eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err := omniHeaderRepo.MissingHeadersForAll(6194630, 6194635, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(missingHeaders)).To(Equal(3))
+
+			headerID := missingHeaders[0].Id
+			err = omniHeaderRepo.MarkHeaderCheckedForAll(headerID, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+
+			missingHeaders, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, 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 := omniHeaderRepo.AddCheckColumn(id)
+				Expect(err).ToNot(HaveOccurred())
+				missingHeaders, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, id)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(len(missingHeaders)).To(Equal(3))
+			}
+
+			err := omniHeaderRepo.MarkHeadersCheckedForAll(missingHeaders, methodIDs)
+			Expect(err).ToNot(HaveOccurred())
+			for _, id := range methodIDs {
+				missingHeaders, err = omniHeaderRepo.MissingHeaders(6194630, 6194635, 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 := omniHeaderRepo.AddCheckColumn(id)
+				Expect(err).ToNot(HaveOccurred())
+				err = omniHeaderRepo.AddCheckColumn(methodIDs[i])
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			missingHeaders, err := omniHeaderRepo.MissingHeaders(6194630, 6194635, 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 = omniHeaderRepo.MarkHeaderChecked(headerID, id)
+				Expect(err).ToNot(HaveOccurred())
+				err = omniHeaderRepo.MarkHeaderChecked(headerID2, id)
+				Expect(err).ToNot(HaveOccurred())
+				err = omniHeaderRepo.MarkHeaderChecked(headerID, methodIDs[i])
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			intersectionHeaders, err := omniHeaderRepo.MissingMethodsCheckedEventsIntersection(6194630, 6194635, methodIDs, eventIDs)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(intersectionHeaders)).To(Equal(1))
+			Expect(intersectionHeaders[0].Id).To(Equal(headerID2))
+
+		})
+	})
+})
+
+func addHeaders(coreHeaderRepo repositories.HeaderRepository) {
+	coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader1)
+	coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader2)
+	coreHeaderRepo.CreateOrUpdateHeader(mocks.MockHeader3)
+}

pkg/contract_watcher/light/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRepository(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Light Repository Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/light/retriever/block_retriever.go

@@ -0,0 +1,60 @@
+// 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/datastore/postgres"
+)
+
+// Block retriever 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
+}
+
+func NewBlockRetriever(db *postgres.DB) (r *blockRetriever) {
+	return &blockRetriever{
+		db: db,
+	}
+}
+
+// Retrieve 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
+}
+
+// Retrieve 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/contract_watcher/light/retriever/block_retriever_test.go

@@ -0,0 +1,79 @@
+// 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/contract_watcher/light/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/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() {
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader2)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+
+			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() {
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader2)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+
+			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/contract_watcher/light/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Light BLock Number Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/light/transformer/transformer.go

@@ -0,0 +1,320 @@
+// 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/vulcanize/vulcanizedb/pkg/config"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/poller"
+	srep "github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+// Requires a light synced vDB (headers) and a running eth node (or infura)
+type transformer struct {
+	// Database interfaces
+	srep.EventRepository        // Holds transformed watched event log data
+	repository.HeaderRepository // Interface for interaction with header repositories
+
+	// Pre-processing interfaces
+	parser.Parser            // Parses events and methods out of contract abi fetched using contract address
+	retriever.BlockRetriever // Retrieves first block for contract and current block height
+
+	// Processing interfaces
+	fetcher.Fetcher     // Fetches event logs, using header hashes
+	converter.Converter // Converts watched event logs into custom log
+	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
+
+// Transformer takes in config for blockchain, database, and network id
+func NewTransformer(con config.ContractConfig, bc core.BlockChain, db *postgres.DB) *transformer {
+
+	return &transformer{
+		Poller:           poller.NewPoller(bc, db, types.LightSync),
+		Fetcher:          fetcher.NewFetcher(bc),
+		Parser:           parser.NewParser(con.Network),
+		HeaderRepository: repository.NewHeaderRepository(db),
+		BlockRetriever:   retriever.NewBlockRetriever(db),
+		Converter:        converter.NewConverter(&contract.Contract{}),
+		Contracts:        map[string]*contract.Contract{},
+		EventRepository:  srep.NewEventRepository(db, types.LightSync),
+		Config:           con,
+	}
+}
+
+// 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 = 100000000000                        // Hold the lowest starting block and the highest ending block
+
+	// 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
+			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.BlockRetriever.RetrieveFirstBlock()
+		if err != nil {
+			return err
+		}
+		lastBlock, err := tr.BlockRetriever.RetrieveMostRecentBlock()
+		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)
+		tr.FetchContractData(tr.Abi(), contractAddr, "name", nil, &name, lastBlock)
+
+		// 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,
+			LastBlock:     -1,
+			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)
+			err := tr.HeaderRepository.AddCheckColumn(eventId)
+			if err != nil {
+				return err
+			}
+			// 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)
+			err := tr.HeaderRepository.AddCheckColumn(methodId)
+			if err != nil {
+				return err
+			}
+			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
+}
+
+func (tr *transformer) Execute() error {
+	if len(tr.Contracts) == 0 {
+		return errors.New("error: transformer has no initialized contracts")
+	}
+
+	// Map to sort batch fetched logs by which contract they belong to, for post fetch processing
+	sortedLogs := make(map[string][]gethTypes.Log)
+	for _, con := range tr.Contracts {
+		sortedLogs[con.Address] = []gethTypes.Log{}
+	}
+
+	// Find unchecked headers for all events across all contracts; these are returned in asc order
+	missingHeaders, err := tr.HeaderRepository.MissingHeadersForAll(tr.start, -1, tr.eventIds)
+	if err != nil {
+		return err
+	}
+
+	// Iterate over headers
+	for _, header := range missingHeaders {
+		// And fetch all event logs across contracts at this header
+		allLogs, err := tr.Fetcher.FetchLogs(tr.contractAddresses, tr.eventFilters, header)
+		if err != nil {
+			return err
+		}
+
+		// 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 {
+			err = tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, tr.eventIds)
+			if err != nil {
+				return err
+			}
+			err = tr.methodPolling(header, tr.sortedMethodIds)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Sort logs by the contract they belong to
+		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 {
+				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, err := tr.Converter.ConvertBatch(logs, con.Events, header.Id)
+			if err != nil {
+				return err
+			}
+			// 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 {
+					eventId := strings.ToLower(eventName + "_" + con.Address)
+					err = tr.HeaderRepository.MarkHeaderChecked(header.Id, eventId)
+					if err != nil {
+						return err
+					}
+					continue
+				}
+				// If logs aren't empty, persist them
+				// Header is marked checked in the transactions
+				err = tr.EventRepository.PersistLogs(logs, con.Events[eventName], con.Address, con.Name)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// Poll contracts at this block height
+		err = tr.methodPolling(header, tr.sortedMethodIds)
+		if err != nil {
+			return err
+		}
+	}
+
+	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 {
+			continue
+		}
+
+		// Poll all methods for this contract at this header
+		err := tr.Poller.PollContractAt(*con, header.BlockNumber)
+		if err != nil {
+			return err
+		}
+
+		// Mark this header checked for the methods
+		err = tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, sortedMethodIds[con.Address])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (tr *transformer) GetConfig() config.ContractConfig {
+	return tr.Config
+}

pkg/contract_watcher/light/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestTransformer(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Light Transformer Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/light/transformer/transformer_test.go

@@ -0,0 +1,462 @@
+// 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 (
+	"fmt"
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/transformer"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+)
+
+var _ = Describe("Transformer", func() {
+	var db *postgres.DB
+	var err error
+	var blockChain core.BlockChain
+	var headerRepository repositories.HeaderRepository
+	var headerID, headerID2 int64
+	var ensAddr = strings.ToLower(constants.EnsContractAddress)
+	var tusdAddr = strings.ToLower(constants.TusdContractAddress)
+
+	BeforeEach(func() {
+		db, blockChain = test_helpers.SetupDBandBC()
+		headerRepository = repositories.NewHeaderRepository(db)
+	})
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Init", func() {
+		It("Initializes transformer's contract objects", func() {
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+
+			Expect(c.StartingBlock).To(Equal(int64(6194632)))
+			Expect(c.LastBlock).To(Equal(int64(-1)))
+			Expect(c.Abi).To(Equal(constants.TusdAbiString))
+			Expect(c.Name).To(Equal("TrueUSD"))
+			Expect(c.Address).To(Equal(tusdAddr))
+		})
+
+		It("Fails to initialize if first and most recent block numbers cannot be fetched from vDB headers table", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("Does nothing if nothing if no addresses are configured", func() {
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader1)
+			headerRepository.CreateOrUpdateHeader(mocks.MockHeader3)
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Addresses = nil
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+
+			_, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(false))
+		})
+	})
+
+	Describe("Execute- against TrueUSD contract", func() {
+		BeforeEach(func() {
+			header1, err := blockChain.GetHeaderByNumber(6791668)
+			Expect(err).ToNot(HaveOccurred())
+			header2, err := blockChain.GetHeaderByNumber(6791669)
+			Expect(err).ToNot(HaveOccurred())
+			header3, err := blockChain.GetHeaderByNumber(6791670)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header1)
+			headerID, err = headerRepository.CreateOrUpdateHeader(header2)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header3)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.LightTransferLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", tusdAddr)).StructScan(&log)
+			Expect(err).ToNot(HaveOccurred())
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.HeaderID).To(Equal(headerID))
+			Expect(log.From).To(Equal("0x1062a747393198f70F71ec65A582423Dba7E5Ab3"))
+			Expect(log.To).To(Equal("0x2930096dB16b4A44Ecd4084EA4bd26F7EeF1AEf0"))
+			Expect(log.Value).To(Equal("9998940000000000000000"))
+		})
+
+		It("Keeps track of contract-related addresses while transforming event data if they need to be used for later method polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Methods = map[string][]string{
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			c, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(c.EmittedAddrs)).To(Equal(4))
+			Expect(len(c.EmittedHashes)).To(Equal(0))
+
+			b, ok := c.EmittedAddrs[common.HexToAddress("0x1062a747393198f70F71ec65A582423Dba7E5Ab3")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedAddrs[common.HexToAddress("0x2930096dB16b4A44Ecd4084EA4bd26F7EeF1AEf0")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedAddrs[common.HexToAddress("0x571A326f5B15E16917dC17761c340c1ec5d06f6d")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedAddrs[common.HexToAddress("0xFBb1b73C4f0BDa4f67dcA266ce6Ef42f520fBB98")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09BbBBE21a5975cAc061D82f7b843b1234567890")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x")]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given methods using generated token holder address", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.TusdConfig
+			testConf.Methods = map[string][]string{
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.BalanceOf{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", tusdAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Balance).To(Equal("55849938025000000000000"))
+			Expect(res.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", tusdAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("Fails if initialization has not been done", func() {
+			t := transformer.NewTransformer(mocks.TusdConfig, blockChain, db)
+			err = t.Execute()
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("Execute- against ENS registry contract", func() {
+		BeforeEach(func() {
+			header1, err := blockChain.GetHeaderByNumber(6885695)
+			Expect(err).ToNot(HaveOccurred())
+			header2, err := blockChain.GetHeaderByNumber(6885696)
+			Expect(err).ToNot(HaveOccurred())
+			header3, err := blockChain.GetHeaderByNumber(6885697)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header1)
+			headerID, err = headerRepository.CreateOrUpdateHeader(header2)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header3)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer(mocks.ENSConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.LightNewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&log)
+			Expect(err).ToNot(HaveOccurred())
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(log.HeaderID).To(Equal(headerID))
+			Expect(log.Node).To(Equal("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"))
+			Expect(log.Label).To(Equal("0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047"))
+			Expect(log.Owner).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+		})
+
+		It("Keeps track of contract-related hashes while transforming event data if they need to be used for later method polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			c, ok := t.Contracts[ensAddr]
+			Expect(ok).To(Equal(true))
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(c.EmittedHashes)).To(Equal(2))
+			Expect(len(c.EmittedAddrs)).To(Equal(0))
+
+			b, ok := c.EmittedHashes[common.HexToHash("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = c.EmittedHashes[common.HexToHash("0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			// Doesn't keep track of address since it wouldn't be used in calling the 'owner' method
+			_, ok = c.EmittedAddrs[common.HexToAddress("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef")]
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Polls given method using list of collected hashes", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x9THIS110dcc444fIS242510c09bbAbe21aFAKEcacNODE82f7b843HASH61ba391' AND block = '6885696'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("It does not persist events if they do not pass the emitted arg filter", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.EventArgs = map[string][]string{
+				ensAddr: {"fake_filter_value"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			log := test_helpers.LightNewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&log)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("If a method arg filter is applied, only those arguments are used in polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSConfig
+			testConf.Methods = map[string][]string{
+				ensAddr: {"owner"},
+			}
+			testConf.MethodArgs = map[string][]string{
+				ensAddr: {"0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			res := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&res)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(res.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+			Expect(res.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&res)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("Execute- against both ENS and TrueUSD", func() {
+		BeforeEach(func() {
+			header1, err := blockChain.GetHeaderByNumber(6791668)
+			Expect(err).ToNot(HaveOccurred())
+			header2, err := blockChain.GetHeaderByNumber(6791669)
+			Expect(err).ToNot(HaveOccurred())
+			header3, err := blockChain.GetHeaderByNumber(6791670)
+			Expect(err).ToNot(HaveOccurred())
+			header4, err := blockChain.GetHeaderByNumber(6885695)
+			Expect(err).ToNot(HaveOccurred())
+			header5, err := blockChain.GetHeaderByNumber(6885696)
+			Expect(err).ToNot(HaveOccurred())
+			header6, err := blockChain.GetHeaderByNumber(6885697)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header1)
+			headerID, err = headerRepository.CreateOrUpdateHeader(header2)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header3)
+			headerRepository.CreateOrUpdateHeader(header4)
+			headerID2, err = headerRepository.CreateOrUpdateHeader(header5)
+			Expect(err).ToNot(HaveOccurred())
+			headerRepository.CreateOrUpdateHeader(header6)
+		})
+
+		It("Transforms watched contract data into custom repositories", func() {
+			t := transformer.NewTransformer(mocks.ENSandTusdConfig, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			newOwnerLog := test_helpers.LightNewOwnerLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&newOwnerLog)
+			Expect(err).ToNot(HaveOccurred())
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(newOwnerLog.HeaderID).To(Equal(headerID2))
+			Expect(newOwnerLog.Node).To(Equal("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"))
+			Expect(newOwnerLog.Label).To(Equal("0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047"))
+			Expect(newOwnerLog.Owner).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+
+			transferLog := test_helpers.LightTransferLog{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", tusdAddr)).StructScan(&transferLog)
+			Expect(err).ToNot(HaveOccurred())
+			// We don't know vulcID, so compare individual fields instead of complete structures
+			Expect(transferLog.HeaderID).To(Equal(headerID))
+			Expect(transferLog.From).To(Equal("0x1062a747393198f70F71ec65A582423Dba7E5Ab3"))
+			Expect(transferLog.To).To(Equal("0x2930096dB16b4A44Ecd4084EA4bd26F7EeF1AEf0"))
+			Expect(transferLog.Value).To(Equal("9998940000000000000000"))
+		})
+
+		It("Keeps track of contract-related hashes and addresses while transforming event data if they need to be used for later method polling", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSandTusdConfig
+			testConf.Methods = map[string][]string{
+				ensAddr:  {"owner"},
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			ens, ok := t.Contracts[ensAddr]
+			Expect(ok).To(Equal(true))
+			tusd, ok := t.Contracts[tusdAddr]
+			Expect(ok).To(Equal(true))
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(ens.EmittedHashes)).To(Equal(2))
+			Expect(len(ens.EmittedAddrs)).To(Equal(0))
+			Expect(len(tusd.EmittedAddrs)).To(Equal(4))
+			Expect(len(tusd.EmittedHashes)).To(Equal(0))
+
+			b, ok := ens.EmittedHashes[common.HexToHash("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = ens.EmittedHashes[common.HexToHash("0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = tusd.EmittedAddrs[common.HexToAddress("0x1062a747393198f70F71ec65A582423Dba7E5Ab3")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = tusd.EmittedAddrs[common.HexToAddress("0x2930096dB16b4A44Ecd4084EA4bd26F7EeF1AEf0")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = tusd.EmittedAddrs[common.HexToAddress("0x571A326f5B15E16917dC17761c340c1ec5d06f6d")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = tusd.EmittedAddrs[common.HexToAddress("0xFBb1b73C4f0BDa4f67dcA266ce6Ef42f520fBB98")]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+		})
+
+		It("Polls given methods for each contract, using list of collected values", func() {
+			var testConf config.ContractConfig
+			testConf = mocks.ENSandTusdConfig
+			testConf.Methods = map[string][]string{
+				ensAddr:  {"owner"},
+				tusdAddr: {"balanceOf"},
+			}
+			t := transformer.NewTransformer(testConf, blockChain, db)
+			err = t.Init()
+			Expect(err).ToNot(HaveOccurred())
+			err = t.Execute()
+			Expect(err).ToNot(HaveOccurred())
+
+			owner := test_helpers.Owner{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&owner)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(owner.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+			Expect(owner.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&owner)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(owner.Address).To(Equal("0x0000000000000000000000000000000000000000"))
+			Expect(owner.TokenName).To(Equal(""))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ceMADEUPaaf4HASHc186badTHItransformers.8IS625bFAKE' AND block = '6885696'", ensAddr)).StructScan(&owner)
+			Expect(err).To(HaveOccurred())
+
+			bal := test_helpers.BalanceOf{}
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", tusdAddr)).StructScan(&bal)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(bal.Balance).To(Equal("55849938025000000000000"))
+			Expect(bal.TokenName).To(Equal("TrueUSD"))
+
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", tusdAddr)).StructScan(&bal)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

pkg/contract_watcher/shared/constants/interface.go

@@ -0,0 +1,127 @@
+// 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"
+)
+
+// 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 SupportsInterace = `{"constant":true,"inputs":[{"name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"}`
+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"}`
+
+var StartingBlock = int64(3648359)
+
+// Resolver interface signatures
+type Interface int
+
+const (
+	MetaSig Interface = iota
+	AddrChangeSig
+	ContentChangeSig
+	NameChangeSig
+	AbiChangeSig
+	PubkeyChangeSig
+	TextChangeSig
+	MultihashChangeSig
+	ContentHashChangeSig
+)
+
+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]
+}
+
+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
+}
+
+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]
+}
+
+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/contract_watcher/shared/contract/contract.go

@@ -0,0 +1,171 @@
+// 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/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/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
+	LastBlock      int64                        // Most recent block on the network
+	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
+}
+
+// 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
+}
+
+// Use contract info to generate event filters - full sync omni 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Add event emitted address 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
+		}
+	}
+}
+
+// Add event emitted hash 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
+		}
+	}
+}
+
+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/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/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/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/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/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/core"
+)
+
+// Fetcher serves as the lower level data fetcher that calls the underlying
+// blockchain's FetchConctractData method for a given return type
+
+// 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 // Underyling Blockchain
+}
+
+// Fetcher error
+type fetcherError struct {
+	err         string
+	fetchMethod string
+}
+
+// Fetcher 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
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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/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/contract_watcher/shared/getter/getter_test.go

@@ -0,0 +1,55 @@
+// 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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/getter"
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+	"github.com/vulcanize/vulcanizedb/pkg/geth/client"
+	rpc2 "github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
+	"github.com/vulcanize/vulcanizedb/pkg/geth/node"
+)
+
+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 + `]`
+
+			blockNumber := int64(6885696)
+			infuraIPC := "https://mainnet.infura.io/v3/b09888c1113640cc9ab42750ce750c05"
+			rawRpcClient, err := rpc.Dial(infuraIPC)
+			Expect(err).NotTo(HaveOccurred())
+			rpcClient := client.NewRpcClient(rawRpcClient, infuraIPC)
+			ethClient := ethclient.NewClient(rawRpcClient)
+			blockChainClient := client.NewEthClient(ethClient)
+			node := node.MakeNode(rpcClient)
+			transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+			blockChain := geth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
+			interfaceGetter := getter.NewInterfaceGetter(blockChain)
+			abi := interfaceGetter.GetABI(constants.PublicResolverAddress, blockNumber)
+			Expect(abi).To(Equal(expectedABI))
+			_, err = geth.ParseAbi(abi)
+			Expect(err).ToNot(HaveOccurred())
+		})
+	})
+})

pkg/contract_watcher/shared/getter/interface_getter.go

@@ -0,0 +1,105 @@
+// 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 (
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/fetcher"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+)
+
+type InterfaceGetter interface {
+	GetABI(resolverAddr string, blockNumber int64) string
+	GetBlockChain() core.BlockChain
+}
+
+type interfaceGetter struct {
+	fetcher.Fetcher
+}
+
+func NewInterfaceGetter(blockChain core.BlockChain) *interfaceGetter {
+	return &interfaceGetter{
+		Fetcher: fetcher.Fetcher{
+			BlockChain: blockChain,
+		},
+	}
+}
+
+// Used to construct a custom ABI based on the results from calling supportsInterface
+func (g *interfaceGetter) GetABI(resolverAddr string, blockNumber int64) string {
+	a := constants.SupportsInterfaceABI
+	args := make([]interface{}, 1)
+	args[0] = constants.MetaSig.Bytes()
+	supports, err := g.getSupportsInterface(a, resolverAddr, blockNumber, args)
+	if err != nil || !supports {
+		return ""
+	}
+	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
+}
+
+// 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)
+}
+
+// Method to retrieve the Getter's blockchain
+func (g *interfaceGetter) GetBlockChain() core.BlockChain {
+	return g.Fetcher.BlockChain
+}

pkg/contract_watcher/shared/helpers/helpers.go

@@ -0,0 +1,69 @@
+// 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/core"
+)
+
+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
+}
+
+func BigFromString(n string) *big.Int {
+	b := new(big.Int)
+	b.SetString(n, 10)
+	return b
+}
+
+func GenerateSignature(s string) string {
+	eventSignature := []byte(s)
+	hash := crypto.Keccak256Hash(eventSignature)
+	return hash.Hex()
+}

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

@@ -0,0 +1,290 @@
+// 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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+	"github.com/vulcanize/vulcanizedb/pkg/geth/client"
+	rpc2 "github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
+	"github.com/vulcanize/vulcanizedb/pkg/geth/node"
+)
+
+type TransferLog struct {
+	Id             int64  `db:"id"`
+	VulvanizeLogId 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"`
+	VulvanizeLogId 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 LightTransferLog 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 LightNewOwnerLog 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 SetupBC() core.BlockChain {
+	infuraIPC := "https://mainnet.infura.io/v3/b09888c1113640cc9ab42750ce750c05"
+	rawRpcClient, err := rpc.Dial(infuraIPC)
+	Expect(err).NotTo(HaveOccurred())
+	rpcClient := client.NewRpcClient(rawRpcClient, infuraIPC)
+	ethClient := ethclient.NewClient(rawRpcClient)
+	blockChainClient := client.NewEthClient(ethClient)
+	node := node.MakeNode(rpcClient)
+	transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+	blockChain := geth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
+
+	return blockChain
+}
+
+func SetupDBandBC() (*postgres.DB, core.BlockChain) {
+	infuraIPC := "https://mainnet.infura.io/v3/b09888c1113640cc9ab42750ce750c05"
+	rawRpcClient, err := rpc.Dial(infuraIPC)
+	Expect(err).NotTo(HaveOccurred())
+	rpcClient := client.NewRpcClient(rawRpcClient, infuraIPC)
+	ethClient := ethclient.NewClient(rawRpcClient)
+	blockChainClient := client.NewEthClient(ethClient)
+	node := node.MakeNode(rpcClient)
+	transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+	blockChain := geth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
+
+	db, err := postgres.NewDB(config.Database{
+		Hostname: "localhost",
+		Name:     "vulcanize_private",
+		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_private",
+		Port:     5432,
+	}, core.Node{})
+	Expect(err).NotTo(HaveOccurred())
+
+	receiptRepository := repositories.ReceiptRepository{DB: db}
+	logRepository := repositories.LogRepository{DB: db}
+	blockRepository := *repositories.NewBlockRepository(db)
+
+	blockNumber := rand.Int63()
+	blockId := CreateBlock(blockNumber, blockRepository)
+
+	receipts := []core.Receipt{{Logs: []core.Log{{}}}}
+
+	err = receiptRepository.CreateReceiptsAndLogs(blockId, receipts)
+	Expect(err).ToNot(HaveOccurred())
+
+	err = logRepository.Get(vulcanizeLogId, `SELECT id FROM 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()
+	Expect(err).ToNot(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "TrueUSD",
+		Address:       constants.TusdContractAddress,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		StartingBlock: 6194634,
+		LastBlock:     6507323,
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		MethodArgs:    map[string]bool{},
+		FilterArgs:    map[string]bool{},
+	}.Init()
+}
+
+func SetupENSRepo(vulcanizeLogId *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
+	db, err := postgres.NewDB(config.Database{
+		Hostname: "localhost",
+		Name:     "vulcanize_private",
+		Port:     5432,
+	}, core.Node{})
+	Expect(err).NotTo(HaveOccurred())
+
+	receiptRepository := repositories.ReceiptRepository{DB: db}
+	logRepository := repositories.LogRepository{DB: db}
+	blockRepository := *repositories.NewBlockRepository(db)
+
+	blockNumber := rand.Int63()
+	blockId := CreateBlock(blockNumber, blockRepository)
+
+	receipts := []core.Receipt{{Logs: []core.Log{{}}}}
+
+	err = receiptRepository.CreateReceiptsAndLogs(blockId, receipts)
+	Expect(err).ToNot(HaveOccurred())
+
+	err = logRepository.Get(vulcanizeLogId, `SELECT id FROM logs`)
+	Expect(err).ToNot(HaveOccurred())
+
+	info := SetupENSContract(wantedEvents, wantedMethods)
+
+	return db, info
+}
+
+func SetupENSContract(wantedEvents, wantedMethods []string) *contract.Contract {
+	p := mocks.NewParser(constants.ENSAbiString)
+	err := p.Parse()
+	Expect(err).ToNot(HaveOccurred())
+
+	return contract.Contract{
+		Name:          "ENS-Registry",
+		Address:       constants.EnsContractAddress,
+		Abi:           p.Abi(),
+		ParsedAbi:     p.ParsedAbi(),
+		StartingBlock: 6194634,
+		LastBlock:     6507323,
+		Events:        p.GetEvents(wantedEvents),
+		Methods:       p.GetSelectMethods(wantedMethods),
+		MethodArgs:    map[string]bool{},
+		FilterArgs:    map[string]bool{},
+	}.Init()
+}
+
+func TearDown(db *postgres.DB) {
+	tx, err := db.Begin()
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM blocks`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM headers`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM logs`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM log_filters`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM transactions`)
+	Expect(err).NotTo(HaveOccurred())
+
+	_, err = tx.Exec(`DELETE FROM 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 light_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 light_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) (blockId int64) {
+	blockId, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
+	Expect(err).NotTo(HaveOccurred())
+
+	return blockId
+}

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

@@ -0,0 +1,328 @@
+// 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"
+	"github.com/vulcanize/vulcanizedb/pkg/config"
+	"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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/filters"
+)
+
+var TransferBlock1 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ert",
+	Number: 6194633,
+	Transactions: []core.Transaction{{
+		Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+			ContractAddress: "",
+			Logs: []core.Log{{
+				BlockNumber: 6194633,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654aaa",
+				Address:     constants.TusdContractAddress,
+				Topics: core.Topics{
+					constants.TransferEvent.Signature(),
+					"0x000000000000000000000000000000000000000000000000000000000000af21",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+			}},
+		},
+	}},
+}
+
+var TransferBlock2 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ooo",
+	Number: 6194634,
+	Transactions: []core.Transaction{{
+		Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+			ContractAddress: "",
+			Logs: []core.Log{{
+				BlockNumber: 6194634,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654eee",
+				Address:     constants.TusdContractAddress,
+				Topics: core.Topics{
+					constants.TransferEvent.Signature(),
+					"0x000000000000000000000000000000000000000000000000000000000000af21",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000000000000000000000089d24a6b4ccb1b6faa2625fe562bdd9a23260359000000000000000000000000000000000000000000000000392d2e2bda9c00000000000000000000000000000000000000000000000000927f41fa0a4a418000000000000000000000000000000000000000000000000000000000005adcfebe",
+			}},
+		},
+	}},
+}
+
+var NewOwnerBlock1 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ppp",
+	Number: 6194635,
+	Transactions: []core.Transaction{{
+		Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+			ContractAddress: "",
+			Logs: []core.Log{{
+				BlockNumber: 6194635,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654bbb",
+				Address:     constants.EnsContractAddress,
+				Topics: core.Topics{
+					constants.NewOwnerEvent.Signature(),
+					"0x0000000000000000000000000000000000000000000000000000c02aaa39b223",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000000000000000000000000000000000000000af21",
+			}},
+		},
+	}},
+}
+
+var NewOwnerBlock2 = core.Block{
+	Hash:   "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad123ggg",
+	Number: 6194636,
+	Transactions: []core.Transaction{{
+		Hash: "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+		Receipt: core.Receipt{
+			TxHash:          "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+			ContractAddress: "",
+			Logs: []core.Log{{
+				BlockNumber: 6194636,
+				TxHash:      "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad654lll",
+				Address:     constants.EnsContractAddress,
+				Topics: core.Topics{
+					constants.NewOwnerEvent.Signature(),
+					"0x0000000000000000000000000000000000000000000000000000c02aaa39b223",
+					"0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba400",
+					"",
+				},
+				Index: 1,
+				Data:  "0x000000000000000000000000000000000000000000000000000000000000af21",
+			}},
+		},
+	}},
+}
+
+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 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 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: []string{"Transfer"},
+	},
+	Methods: map[string][]string{
+		tusd: nil,
+	},
+	MethodArgs: map[string][]string{
+		tusd: nil,
+	},
+	EventArgs: map[string][]string{
+		tusd: nil,
+	},
+}
+
+var ENSConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		ens: true,
+	},
+	Abis: map[string]string{
+		ens: "",
+	},
+	Events: map[string][]string{
+		ens: []string{"NewOwner"},
+	},
+	Methods: map[string][]string{
+		ens: nil,
+	},
+	MethodArgs: map[string][]string{
+		ens: nil,
+	},
+	EventArgs: map[string][]string{
+		ens: nil,
+	},
+}
+
+var ENSandTusdConfig = config.ContractConfig{
+	Network: "",
+	Addresses: map[string]bool{
+		ens:  true,
+		tusd: true,
+	},
+	Abis: map[string]string{
+		ens:  "",
+		tusd: "",
+	},
+	Events: map[string][]string{
+		ens:  []string{"NewOwner"},
+		tusd: []string{"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,
+	},
+}

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

@@ -0,0 +1,162 @@
+// 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/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+)
+
+// Mock parser
+// Is given ABI string instead of address
+// Performs all other functions of the real parser
+type parser struct {
+	abi       string
+	parsedAbi abi.ABI
+}
+
+func NewParser(abi string) *parser {
+
+	return &parser{
+		abi: abi,
+	}
+}
+
+func (p *parser) Abi() string {
+	return p.abi
+}
+
+func (p *parser) ParsedAbi() abi.ABI {
+	return p.parsedAbi
+}
+
+// Retrieves and parses the abi string
+// for the given contract address
+func (p *parser) Parse() error {
+	var err error
+	p.parsedAbi, err = geth.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 *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
+}
+
+// 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
+}
+
+// Returns wanted events as map of types.Events
+// If no events are specified, all events are returned
+func (p *parser) 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/contract_watcher/shared/parser/parser.go

@@ -0,0 +1,218 @@
+// 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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+)
+
+// 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    *geth.EtherScanAPI
+	abi       string
+	parsedAbi abi.ABI
+}
+
+func NewParser(network string) *parser {
+	url := geth.GenURL(network)
+
+	return &parser{
+		client: geth.NewEtherScanClient(url),
+	}
+}
+
+func (p *parser) Abi() string {
+	return p.abi
+}
+
+func (p *parser) ParsedAbi() abi.ABI {
+	return p.parsedAbi
+}
+
+// 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 = geth.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 = geth.ParseAbi(abiStr)
+
+	return err
+}
+
+// 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 = geth.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 tabe")
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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/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/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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/parser"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+)
+
+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()
+			Expect(err).ToNot(HaveOccurred())
+
+			parsedAbi := mp.ParsedAbi()
+			expectedAbi, err := geth.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 := geth.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(22))
+		})
+	})
+})

pkg/contract_watcher/shared/poller/poller.go

@@ -0,0 +1,292 @@
+// 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/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+type Poller interface {
+	PollContract(con contract.Contract) 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
+}
+
+func NewPoller(blockChain core.BlockChain, db *postgres.DB, mode types.Mode) *poller {
+	return &poller{
+		MethodRepository: repository.NewMethodRepository(db, mode),
+		bc:               blockChain,
+	}
+}
+
+func (p *poller) PollContract(con contract.Contract) error {
+	for i := con.StartingBlock; i <= con.LastBlock; i++ {
+		p.PollContractAt(con, i)
+	}
+
+	return nil
+}
+
+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 errors.New(fmt.Sprintf("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 errors.New(fmt.Sprintf("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 errors.New(fmt.Sprintf("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 errors.New(fmt.Sprintf("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 errors.New(fmt.Sprintf("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 errors.New(fmt.Sprintf("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
+}
+
+// This 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 an method return value if method piping is turned on
+func (p *poller) cache(out interface{}) {
+	// Cache returned value if piping is turned on
+	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/contract_watcher/shared/poller/poller_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 poller_test
+
+import (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestPoller(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Poller Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/shared/poller/poller_test.go

@@ -0,0 +1,257 @@
+// 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_test
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/poller"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+var _ = Describe("Poller", func() {
+
+	var p poller.Poller
+	var con *contract.Contract
+	var db *postgres.DB
+	var bc core.BlockChain
+
+	AfterEach(func() {
+		test_helpers.TearDown(db)
+	})
+
+	Describe("Full sync mode", func() {
+		BeforeEach(func() {
+			db, bc = test_helpers.SetupDBandBC()
+			p = poller.NewPoller(bc, db, types.FullSync)
+		})
+
+		Describe("PollContract", func() {
+			It("Polls specified contract methods using contract's argument list", func() {
+				con = test_helpers.SetupTusdContract(nil, []string{"balanceOf"})
+				Expect(con.Abi).To(Equal(constants.TusdAbiString))
+				con.StartingBlock = 6707322
+				con.LastBlock = 6707323
+				con.AddEmittedAddr(common.HexToAddress("0xfE9e8709d3215310075d67E3ed32A380CCf451C8"), common.HexToAddress("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE"))
+
+				err := p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("66386309548896882859581786"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707323'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("66386309548896882859581786"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("17982350181394112023885864"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE' AND block = '6707323'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("17982350181394112023885864"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+			})
+
+			It("Polls specified contract methods using contract's hash list", func() {
+				con = test_helpers.SetupENSContract(nil, []string{"owner"})
+				Expect(con.Abi).To(Equal(constants.ENSAbiString))
+				Expect(len(con.Methods)).To(Equal(1))
+				con.AddEmittedHash(common.HexToHash("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"), common.HexToHash("0x7e74a86b6e146964fb965db04dc2590516da77f720bb6759337bf5632415fd86"))
+
+				err := p.PollContractAt(*con, 6885877)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.Owner{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x7e74a86b6e146964fb965db04dc2590516da77f720bb6759337bf5632415fd86' AND block = '6885877'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x546aA2EaE2514494EeaDb7bbb35243348983C59d"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885877'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+			})
+
+			It("Does not poll and persist any methods if none are specified", func() {
+				con = test_helpers.SetupTusdContract(nil, nil)
+				Expect(con.Abi).To(Equal(constants.TusdAbiString))
+				con.StartingBlock = 6707322
+				con.LastBlock = 6707323
+				con.AddEmittedAddr(common.HexToAddress("0xfE9e8709d3215310075d67E3ed32A380CCf451C8"), common.HexToAddress("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE"))
+
+				err := p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+
+		Describe("FetchContractData", func() {
+			It("Calls a single contract method", func() {
+				var name = new(string)
+				err := p.FetchContractData(constants.TusdAbiString, constants.TusdContractAddress, "name", nil, &name, 6197514)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(*name).To(Equal("TrueUSD"))
+			})
+		})
+	})
+
+	Describe("Light sync mode", func() {
+		BeforeEach(func() {
+			db, bc = test_helpers.SetupDBandBC()
+			p = poller.NewPoller(bc, db, types.LightSync)
+		})
+
+		Describe("PollContract", func() {
+			It("Polls specified contract methods using contract's token holder address list", func() {
+				con = test_helpers.SetupTusdContract(nil, []string{"balanceOf"})
+				Expect(con.Abi).To(Equal(constants.TusdAbiString))
+				con.StartingBlock = 6707322
+				con.LastBlock = 6707323
+				con.AddEmittedAddr(common.HexToAddress("0xfE9e8709d3215310075d67E3ed32A380CCf451C8"), common.HexToAddress("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE"))
+
+				err := p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("66386309548896882859581786"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707323'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("66386309548896882859581786"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("17982350181394112023885864"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE' AND block = '6707323'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Balance).To(Equal("17982350181394112023885864"))
+				Expect(scanStruct.TokenName).To(Equal("TrueUSD"))
+			})
+
+			It("Polls specified contract methods using contract's hash list", func() {
+				con = test_helpers.SetupENSContract(nil, []string{"owner"})
+				Expect(con.Abi).To(Equal(constants.ENSAbiString))
+				Expect(len(con.Methods)).To(Equal(1))
+				con.AddEmittedHash(common.HexToHash("0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae"), common.HexToHash("0x7e74a86b6e146964fb965db04dc2590516da77f720bb6759337bf5632415fd86"))
+
+				err := p.PollContractAt(*con, 6885877)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.Owner{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x7e74a86b6e146964fb965db04dc2590516da77f720bb6759337bf5632415fd86' AND block = '6885877'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x546aA2EaE2514494EeaDb7bbb35243348983C59d"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885877'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+			})
+
+			It("Does not poll and persist any methods if none are specified", func() {
+				con = test_helpers.SetupTusdContract(nil, nil)
+				Expect(con.Abi).To(Equal(constants.TusdAbiString))
+				con.StartingBlock = 6707322
+				con.LastBlock = 6707323
+				con.AddEmittedAddr(common.HexToAddress("0xfE9e8709d3215310075d67E3ed32A380CCf451C8"), common.HexToAddress("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE"))
+
+				err := p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.BalanceOf{}
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0xfE9e8709d3215310075d67E3ed32A380CCf451C8' AND block = '6707322'", constants.TusdContractAddress)).StructScan(&scanStruct)
+				Expect(err).To(HaveOccurred())
+			})
+
+			It("Caches returned values of the appropriate types for downstream method polling if method piping is turned on", func() {
+				con = test_helpers.SetupENSContract(nil, []string{"resolver"})
+				Expect(con.Abi).To(Equal(constants.ENSAbiString))
+				con.StartingBlock = 6921967
+				con.LastBlock = 6921968
+				con.EmittedAddrs = map[interface{}]bool{}
+				con.Piping = false
+				con.AddEmittedHash(common.HexToHash("0x495b6e6efdedb750aa519919b5cf282bdaa86067b82a2293a3ff5723527141e8"))
+				err := p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				scanStruct := test_helpers.Resolver{}
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.resolver_method WHERE node_ = '0x495b6e6efdedb750aa519919b5cf282bdaa86067b82a2293a3ff5723527141e8' AND block = '6921967'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x5FfC014343cd971B7eb70732021E26C35B744cc4"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+				Expect(len(con.EmittedAddrs)).To(Equal(0)) // With piping off the address is not saved
+
+				test_helpers.TearDown(db)
+				db, bc = test_helpers.SetupDBandBC()
+				p = poller.NewPoller(bc, db, types.LightSync)
+
+				con.Piping = true
+				err = p.PollContract(*con)
+				Expect(err).ToNot(HaveOccurred())
+
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.resolver_method WHERE node_ = '0x495b6e6efdedb750aa519919b5cf282bdaa86067b82a2293a3ff5723527141e8' AND block = '6921967'", constants.EnsContractAddress)).StructScan(&scanStruct)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(scanStruct.Address).To(Equal("0x5FfC014343cd971B7eb70732021E26C35B744cc4"))
+				Expect(scanStruct.TokenName).To(Equal("ENS-Registry"))
+				Expect(len(con.EmittedAddrs)).To(Equal(1)) // With piping on it is saved
+				Expect(con.EmittedAddrs[common.HexToAddress("0x5FfC014343cd971B7eb70732021E26C35B744cc4")]).To(Equal(true))
+			})
+		})
+
+		Describe("FetchContractData", func() {
+			It("Calls a single contract method", func() {
+				var name = new(string)
+				err := p.FetchContractData(constants.TusdAbiString, constants.TusdContractAddress, "name", nil, &name, 6197514)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(*name).To(Equal("TrueUSD"))
+			})
+		})
+	})
+})

pkg/contract_watcher/shared/repository/event_repository.go

@@ -0,0 +1,313 @@
+// 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/vulcanize/vulcanizedb/pkg/contract_watcher/light/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+const (
+	// Number of contract address and method ids to keep in cache
+	contractCacheSize = 100
+	eventChacheSize   = 1000
+)
+
+// Event repository 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
+}
+
+func NewEventRepository(db *postgres.DB, mode types.Mode) *eventRepository {
+	ccs, _ := lru.New(contractCacheSize)
+	ecs, _ := lru.New(eventChacheSize)
+	return &eventRepository{
+		db:      db,
+		mode:    mode,
+		schemas: ccs,
+		tables:  ecs,
+	}
+}
+
+// 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")
+	}
+	_, err := r.CreateContractSchema(contractAddr)
+	if err != nil {
+		return err
+	}
+
+	_, err = r.CreateEventTable(contractAddr, eventInfo)
+	if err != nil {
+		return err
+	}
+
+	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.LightSync:
+		err = r.persistLightSyncLogs(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 light synced vDB)
+func (r *eventRepository) persistLightSyncLogs(logs []types.Log, eventInfo types.Event, contractAddr, contractName string) error {
+	tx, err := r.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	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 + ")"
+
+		// Add this query to the transaction
+		_, err = tx.Exec(pgStr, data...)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	// Mark header as checked for this eventId
+	eventId := strings.ToLower(eventInfo.Name + "_" + contractAddr)
+	err = repository.MarkHeaderCheckedInTransaction(logs[0].Id, tx, eventId) // This assumes all logs are from same block
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	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, err := r.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	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"
+
+		_, err = tx.Exec(pgStr, data...)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+// 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, err := r.checkForTable(contractAddr, event.Name)
+	if err != nil {
+		return false, err
+	}
+
+	if !tableExists {
+		err = r.newEventTable(tableID, event)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// 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 logs (id) ON DELETE CASCADE)"
+	case types.LightSync:
+		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
+}
+
+// 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, 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 *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
+}
+
+func (r *eventRepository) CheckSchemaCache(key string) (interface{}, bool) {
+	return r.schemas.Get(key)
+}
+
+func (r *eventRepository) CheckTableCache(key string) (interface{}, bool) {
+	return r.tables.Get(key)
+}

pkg/contract_watcher/shared/repository/event_repository_test.go

@@ -0,0 +1,351 @@
+// 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/contract_watcher/full/converter"
+	lc "github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/converter"
+	lr "github.com/vulcanize/vulcanizedb/pkg/contract_watcher/light/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers/mocks"
+	sr "github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/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.NewConverter(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,
+					VulvanizeLogId: 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,
+					VulvanizeLogId: 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 seperate 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("Light sync mode", func() {
+		BeforeEach(func() {
+			dataStore = sr.NewEventRepository(db, types.LightSync)
+		})
+
+		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.LightSync, 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.NewConverter(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 light_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(2))
+
+				scanLog := test_helpers.LightTransferLog{}
+				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%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())
+
+				// Try and fail to persist the same log twice in a single call
+				err = dataStore.PersistLogs([]types.Log{logs[0], logs[0]}, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+
+				// Successfuly persist the two unique logs
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).ToNot(HaveOccurred())
+
+				// Try and fail to persist the same logs again in separate call
+				err = dataStore.PersistLogs([]types.Log{*log}, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+
+				// Show that no new logs were entered
+				var count int
+				err = db.Get(&count, fmt.Sprintf("SELECT COUNT(*) FROM light_%s.transfer_event", constants.TusdContractAddress))
+				Expect(err).ToNot(HaveOccurred())
+				Expect(count).To(Equal(2))
+			})
+
+			It("Fails if the persisted event does not have a corresponding eventID column in the checked_headers table", func() {
+				err = dataStore.PersistLogs(logs, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+
+			It("Fails with empty log", func() {
+				err = dataStore.PersistLogs([]types.Log{}, event, con.Address, con.Name)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+})

pkg/contract_watcher/shared/repository/method_repository.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 repository
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/golang-lru"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+const methodCacheSize = 1000
+
+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
+}
+
+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,
+	}
+}
+
+// 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.Begin()
+	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 {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+// 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
+}
+
+// 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
+}
+
+func (r *methodRepository) CheckSchemaCache(key string) (interface{}, bool) {
+	return r.schemas.Get(key)
+}
+
+func (r *methodRepository) CheckTableCache(key string) (interface{}, bool) {
+	return r.tables.Get(key)
+}

pkg/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/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/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("Light Sync Mode", func() {
+		BeforeEach(func() {
+			dataStore = repository.NewMethodRepository(db, types.LightSync)
+		})
+
+		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.LightSync, 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 light 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 light_%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/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRepository(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Shared Repository Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/shared/retriever/address_retriever.go

@@ -0,0 +1,120 @@
+// 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"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+// Address retriever 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
+}
+
+func NewAddressRetriever(db *postgres.DB, mode types.Mode) (r *addressRetriever) {
+	return &addressRetriever{
+		db:   db,
+		mode: mode,
+	}
+}
+
+// Method 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/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/contract_watcher/full/converter"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/constants"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/repository"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/retriever"
+	"github.com/vulcanize/vulcanizedb/pkg/contract_watcher/shared/types"
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/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 err error
+	var info *contract.Contract
+	var vulcanizeLogId int64
+	var log *types.Log
+	var r retriever.AddressRetriever
+	var addresses map[common.Address]bool
+	var wantedEvents = []string{"Transfer"}
+
+	BeforeEach(func() {
+		db, info = test_helpers.SetupTusdRepo(&vulcanizeLogId, wantedEvents, []string{})
+		mockEvent.LogID = vulcanizeLogId
+
+		event := info.Events["Transfer"]
+		err = info.GenerateFilters()
+		Expect(err).ToNot(HaveOccurred())
+
+		c := converter.NewConverter(info)
+		log, err = c.Convert(mockEvent, event)
+		Expect(err).ToNot(HaveOccurred())
+
+		dataStore = repository.NewEventRepository(db, types.FullSync)
+		dataStore.PersistLogs([]types.Log{*log}, event, info.Address, info.Name)
+		Expect(err).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, err = r.RetrieveTokenHolderAddresses(*info)
+			Expect(err).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, err = r.RetrieveTokenHolderAddresses(contract.Contract{})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(len(addresses)).To(Equal(0))
+		})
+	})
+})

pkg/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 (
+	"github.com/sirupsen/logrus"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestRetriever(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Address Retriever Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	logrus.SetOutput(ioutil.Discard)
+})

pkg/contract_watcher/shared/types/event.go

@@ -0,0 +1,96 @@
+// 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"
+)
+
+type Event struct {
+	Name      string
+	Anonymous bool
+	Fields    []Field
+}
+
+type Field struct {
+	abi.Argument        // Name, Type, Indexed
+	PgType       string // Holds type used when committing data held in this field to postgres
+}
+
+// Struct to hold instance of an event log data
+type Log struct {
+	Id     int64             // VulcanizeIdLog for full sync and header ID for light sync omni watcher
+	Values map[string]string // Map of event input names to their values
+
+	// Used for full sync only
+	Block int64
+	Tx    string
+
+	// Used for lightSync only
+	LogIndex         uint
+	TransactionIndex uint
+	Raw              []byte // json.Unmarshalled byte array of geth/core/types.Log{}
+}
+
+// Unpack 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,
+	}
+}
+
+func (e Event) Sig() common.Hash {
+	types := make([]string, len(e.Fields))
+
+	for i, input := range e.Fields {
+		types[i] = input.Type.String()
+	}
+
+	return common.BytesToHash(crypto.Keccak256([]byte(fmt.Sprintf("%v(%v)", e.Name, strings.Join(types, ",")))))
+}

pkg/contract_watcher/shared/types/method.go

@@ -0,0 +1,111 @@
+// 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"
+)
+
+type Method struct {
+	Name   string
+	Const  bool
+	Args   []Field
+	Return []Field
+}
+
+// Struct 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
+}
+
+// Unpack 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,
+	}
+}
+
+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 common.BytesToHash(crypto.Keccak256([]byte(fmt.Sprintf("%v(%v)", m.Name, strings.Join(types, ",")))))
+}

pkg/contract_watcher/shared/types/mode.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 types
+
+import "fmt"
+
+type Mode int
+
+const (
+	LightSync Mode = iota
+	FullSync
+)
+
+func (mode Mode) IsValid() bool {
+	return mode >= LightSync && mode <= FullSync
+}
+
+func (mode Mode) String() string {
+	switch mode {
+	case LightSync:
+		return "light"
+	case FullSync:
+		return "full"
+	default:
+		return "unknown"
+	}
+}
+
+func (mode Mode) MarshalText() ([]byte, error) {
+	switch mode {
+	case LightSync:
+		return []byte("light"), nil
+	case FullSync:
+		return []byte("full"), nil
+	default:
+		return nil, fmt.Errorf("omni watcher: unknown mode %d, want LightSync or FullSync", mode)
+	}
+}
+
+func (mode *Mode) UnmarshalText(text []byte) error {
+	switch string(text) {
+	case "light":
+		*mode = LightSync
+	case "full":
+		*mode = FullSync
+	default:
+		return fmt.Errorf(`omni watcher: unknown mode %q, want "light" or "full"`, text)
+	}
+	return nil
+}