major refactor part 2: remove cold import, full sync, generalize node table

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -23,7 +23,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 const columnCacheSize = 1000

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

@@ -26,8 +26,8 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 var _ = Describe("Repository", func() {

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

@@ -17,7 +17,7 @@
 package retriever
 
 import (
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 // BlockRetriever is used to retrieve the first block for a given contract and the most recent block

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

@@ -23,8 +23,8 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/header/retriever"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 var _ = Describe("Block Retriever", func() {

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

@@ -38,7 +38,7 @@ import (
 	srep "github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 // Transformer is the top level struct for transforming watched contract data

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

@@ -17,8 +17,6 @@
 package test_helpers
 
 import (
-	"math/rand"
-
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
 	. "github.com/onsi/gomega"
@@ -31,9 +29,8 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers/mocks"
 	rpc2 "github.com/vulcanize/vulcanizedb/pkg/eth/converters/rpc"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres/repositories"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/node"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 	"github.com/vulcanize/vulcanizedb/test_config"
 )
 
@@ -129,34 +126,6 @@ func SetupDBandBC() (*postgres.DB, core.BlockChain) {
 	return db, blockChain
 }
 
-func SetupTusdRepo(vulcanizeLogID *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
-	db, err := postgres.NewDB(config.Database{
-		Hostname: "localhost",
-		Name:     "vulcanize_testing",
-		Port:     5432,
-	}, core.Node{})
-	Expect(err).NotTo(HaveOccurred())
-
-	receiptRepository := repositories.FullSyncReceiptRepository{DB: db}
-	logRepository := repositories.FullSyncLogRepository{DB: db}
-	blockRepository := *repositories.NewBlockRepository(db)
-
-	blockNumber := rand.Int63()
-	blockID := CreateBlock(blockNumber, blockRepository)
-
-	receipts := []core.Receipt{{Logs: []core.FullSyncLog{{}}}}
-
-	err = receiptRepository.CreateReceiptsAndLogs(blockID, receipts)
-	Expect(err).ToNot(HaveOccurred())
-
-	err = logRepository.Get(vulcanizeLogID, `SELECT id FROM full_sync_logs`)
-	Expect(err).ToNot(HaveOccurred())
-
-	info := SetupTusdContract(wantedEvents, wantedMethods)
-
-	return db, info
-}
-
 func SetupTusdContract(wantedEvents, wantedMethods []string) *contract.Contract {
 	p := mocks.NewParser(constants.TusdAbiString)
 	err := p.Parse(constants.TusdContractAddress)
@@ -237,27 +206,12 @@ func TearDown(db *postgres.DB) {
 	_, err = tx.Exec(`DELETE FROM addresses`)
 	Expect(err).NotTo(HaveOccurred())
 
-	_, err = tx.Exec(`DELETE FROM eth_blocks`)
-	Expect(err).NotTo(HaveOccurred())
-
 	_, err = tx.Exec(`DELETE FROM headers`)
 	Expect(err).NotTo(HaveOccurred())
 
-	_, err = tx.Exec(`DELETE FROM full_sync_logs`)
-	Expect(err).NotTo(HaveOccurred())
-
-	_, err = tx.Exec(`DELETE FROM log_filters`)
-	Expect(err).NotTo(HaveOccurred())
-
-	_, err = tx.Exec(`DELETE FROM full_sync_transactions`)
-	Expect(err).NotTo(HaveOccurred())
-
 	_, err = tx.Exec("DELETE FROM header_sync_transactions")
 	Expect(err).NotTo(HaveOccurred())
 
-	_, err = tx.Exec(`DELETE FROM full_sync_receipts`)
-	Expect(err).NotTo(HaveOccurred())
-
 	_, err = tx.Exec(`DELETE FROM header_sync_receipts`)
 	Expect(err).NotTo(HaveOccurred())
 
@@ -287,10 +241,3 @@ func TearDown(db *postgres.DB) {
 	_, err = db.Exec(`VACUUM checked_headers`)
 	Expect(err).NotTo(HaveOccurred())
 }
-
-func CreateBlock(blockNumber int64, repository repositories.BlockRepository) int64 {
-	blockID, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
-	Expect(err).NotTo(HaveOccurred())
-
-	return blockID
-}

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

@@ -30,7 +30,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/core"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 // Poller is the interface for polling public contract methods

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

@@ -25,7 +25,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 const (

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

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

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

@@ -25,7 +25,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 const methodCacheSize = 1000

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

@@ -28,7 +28,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/helpers/test_helpers"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/repository"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 var _ = Describe("Repository", func() {

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

@@ -25,7 +25,7 @@ import (
 
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/contract"
 	"github.com/vulcanize/vulcanizedb/pkg/eth/contract_watcher/shared/types"
-	"github.com/vulcanize/vulcanizedb/pkg/eth/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/postgres"
 )
 
 // AddressRetriever is used to retrieve the addresses associated with a contract

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

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

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

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