Always hash storage diff contract addresses

- Enables syncing Geth and Parity diffs with same transformer lookup
- Maybe worth always hashing the storage key so we don't need a hashed
  and not-hashed version in the key lookups?

libraries/shared/watcher/csv_storage_watcher.go

@@ -1,46 +0,0 @@
-// Copyright 2018 Vulcanize
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package watcher
-
-import (
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/fetcher"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/storage"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
-)
-
-type CsvStorageWatcher struct {
-	StorageWatcher
-}
-
-func NewCsvStorageWatcher(fetcher fetcher.IStorageFetcher, db *postgres.DB) CsvStorageWatcher {
-	queue := storage.NewStorageQueue(db)
-	transformers := make(map[common.Address]transformer.StorageTransformer)
-	storageWatcher := StorageWatcher{
-		db:             db,
-		StorageFetcher: fetcher,
-		Queue:          queue,
-		Transformers:   transformers,
-	}
-	storageWatcher.transformerGetter = storageWatcher.getCsvTransformer
-	return CsvStorageWatcher{StorageWatcher: storageWatcher}
-}
-
-func (storageWatcher StorageWatcher) getCsvTransformer(diff utils.StorageDiff) (transformer.StorageTransformer, bool) {
-	storageTransformer, ok := storageWatcher.Transformers[diff.Contract]
-	return storageTransformer, ok
-}

libraries/shared/watcher/geth_storage_watcher.go

@@ -1,62 +0,0 @@
-// Copyright 2018 Vulcanize
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package watcher
-
-import (
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/fetcher"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/storage"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
-	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
-)
-
-type GethStorageWatcher struct {
-	StorageWatcher
-}
-
-func NewGethStorageWatcher(fetcher fetcher.IStorageFetcher, db *postgres.DB) GethStorageWatcher {
-	queue := storage.NewStorageQueue(db)
-	transformers := make(map[common.Address]transformer.StorageTransformer)
-	keccakAddressTransformers := make(map[common.Hash]transformer.StorageTransformer)
-	storageWatcher := StorageWatcher{
-		db:                        db,
-		StorageFetcher:            fetcher,
-		Queue:                     queue,
-		Transformers:              transformers,
-		KeccakAddressTransformers: keccakAddressTransformers,
-	}
-	storageWatcher.transformerGetter = storageWatcher.getTransformerForGethWatcher
-	return GethStorageWatcher{StorageWatcher: storageWatcher}
-}
-
-func (storageWatcher StorageWatcher) getTransformerForGethWatcher(diff utils.StorageDiff) (transformer.StorageTransformer, bool) {
-	keccakOfAddress := diff.KeccakOfContractAddress
-	storageTransformer, ok := storageWatcher.KeccakAddressTransformers[keccakOfAddress]
-	if ok {
-		return storageTransformer, ok
-	} else {
-		for address, transformer := range storageWatcher.Transformers {
-			keccakOfTransformerAddress := common.BytesToHash(crypto.Keccak256(address[:]))
-			if keccakOfTransformerAddress == keccakOfAddress {
-				storageWatcher.KeccakAddressTransformers[keccakOfAddress] = transformer
-				return transformer, true
-			}
-		}
-	}
-
-	return nil, false
-}

libraries/shared/watcher/geth_storage_watcher_test.go

@@ -1,269 +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 watcher_test
-
-import (
-	"github.com/ethereum/go-ethereum/crypto"
-	"io/ioutil"
-	"os"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	"github.com/sirupsen/logrus"
-
-	"github.com/vulcanize/vulcanizedb/libraries/shared/mocks"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
-	"github.com/vulcanize/vulcanizedb/libraries/shared/watcher"
-	"github.com/vulcanize/vulcanizedb/pkg/fakes"
-	"github.com/vulcanize/vulcanizedb/test_config"
-)
-
-var _ = Describe("Geth Storage Watcher", func() {
-	It("adds transformers", func() {
-		fakeAddress := common.HexToAddress("0x12345")
-		fakeTransformer := &mocks.MockStorageTransformer{Address: fakeAddress}
-		w := watcher.NewGethStorageWatcher(mocks.NewMockStorageFetcher(), test_config.NewTestDB(test_config.NewTestNode()))
-
-		w.AddTransformers([]transformer.StorageTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
-
-		Expect(w.Transformers[fakeAddress]).To(Equal(fakeTransformer))
-	})
-
-	Describe("executing watcher", func() {
-		var (
-			errs            chan error
-			mockFetcher     *mocks.MockStorageFetcher
-			mockQueue       *mocks.MockStorageQueue
-			mockTransformer *mocks.MockStorageTransformer
-			gethDiff        utils.StorageDiff
-			diffs           chan utils.StorageDiff
-			storageWatcher  watcher.GethStorageWatcher
-			address         common.Address
-			keccakOfAddress common.Hash
-		)
-
-		BeforeEach(func() {
-			errs = make(chan error)
-			diffs = make(chan utils.StorageDiff)
-			address = common.HexToAddress("0x0123456789abcdef")
-			keccakOfAddress = common.BytesToHash(crypto.Keccak256(address[:]))
-			mockFetcher = mocks.NewMockStorageFetcher()
-			mockQueue = &mocks.MockStorageQueue{}
-			mockTransformer = &mocks.MockStorageTransformer{Address: address}
-			gethDiff = utils.StorageDiff{
-				Id:                      1338,
-				KeccakOfContractAddress: keccakOfAddress,
-				BlockHash:               common.HexToHash("0xfedcba9876543210"),
-				BlockHeight:             0,
-				StorageKey:              common.HexToHash("0xabcdef1234567890"),
-				StorageValue:            common.HexToHash("0x9876543210abcdef"),
-			}
-		})
-
-		It("logs error if fetching storage diffs fails", func(done Done) {
-			mockFetcher.ErrsToReturn = []error{fakes.FakeError}
-			storageWatcher = watcher.NewGethStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
-			storageWatcher.Queue = mockQueue
-			storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
-			tempFile, fileErr := ioutil.TempFile("", "log")
-			Expect(fileErr).NotTo(HaveOccurred())
-			defer os.Remove(tempFile.Name())
-			logrus.SetOutput(tempFile)
-
-			go storageWatcher.Execute(diffs, errs, time.Hour)
-
-			Eventually(func() (string, error) {
-				logContent, err := ioutil.ReadFile(tempFile.Name())
-				return string(logContent), err
-			}).Should(ContainSubstring(fakes.FakeError.Error()))
-			close(done)
-		})
-
-		Describe("transforming new storage diffs", func() {
-			BeforeEach(func() {
-				mockFetcher.DiffsToReturn = []utils.StorageDiff{gethDiff}
-				storageWatcher = watcher.NewGethStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
-				storageWatcher.Queue = mockQueue
-				storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
-			})
-
-			It("executes transformer for recognized storage diff", func(done Done) {
-				go storageWatcher.Execute(diffs, errs, time.Hour)
-
-				Eventually(func() utils.StorageDiff {
-					return mockTransformer.PassedDiff
-				}).Should(Equal(gethDiff))
-				close(done)
-			})
-
-			It("queues diff for later processing if transformer execution fails", func(done Done) {
-				mockTransformer.ExecuteErr = fakes.FakeError
-
-				go storageWatcher.Execute(diffs, errs, time.Hour)
-
-				Expect(<-errs).To(BeNil())
-				Eventually(func() bool {
-					return mockQueue.AddCalled
-				}).Should(BeTrue())
-				Eventually(func() utils.StorageDiff {
-					return mockQueue.AddPassedDiff
-				}).Should(Equal(gethDiff))
-				close(done)
-			})
-
-			It("logs error if queueing diff fails", func(done Done) {
-				mockTransformer.ExecuteErr = utils.ErrStorageKeyNotFound{}
-				mockQueue.AddError = fakes.FakeError
-				tempFile, fileErr := ioutil.TempFile("", "log")
-				Expect(fileErr).NotTo(HaveOccurred())
-				defer os.Remove(tempFile.Name())
-				logrus.SetOutput(tempFile)
-
-				go storageWatcher.Execute(diffs, errs, time.Hour)
-
-				Eventually(func() bool {
-					return mockQueue.AddCalled
-				}).Should(BeTrue())
-				Eventually(func() (string, error) {
-					logContent, err := ioutil.ReadFile(tempFile.Name())
-					return string(logContent), err
-				}).Should(ContainSubstring(fakes.FakeError.Error()))
-				close(done)
-			})
-
-			It("keeps track transformers by the keccak256 hash of their contract address ", func(done Done) {
-				go storageWatcher.Execute(diffs, errs, time.Hour)
-
-				m := make(map[common.Hash]transformer.StorageTransformer)
-				m[keccakOfAddress] = mockTransformer
-
-				Eventually(func() map[common.Hash]transformer.StorageTransformer {
-					return storageWatcher.KeccakAddressTransformers
-				}).Should(Equal(m))
-
-				close(done)
-			})
-
-			It("gets the transformer from the known keccak address map first", func(done Done) {
-				anotherAddress := common.HexToAddress("0xafakeaddress")
-				anotherTransformer := &mocks.MockStorageTransformer{Address: anotherAddress}
-				keccakOfAnotherAddress := common.BytesToHash(crypto.Keccak256(anotherAddress[:]))
-
-				anotherGethDiff := utils.StorageDiff{
-					Id:                      1338,
-					KeccakOfContractAddress: keccakOfAnotherAddress,
-					BlockHash:               common.HexToHash("0xfedcba9876543210"),
-					BlockHeight:             0,
-					StorageKey:              common.HexToHash("0xabcdef1234567890"),
-					StorageValue:            common.HexToHash("0x9876543210abcdef"),
-				}
-				mockFetcher.DiffsToReturn = []utils.StorageDiff{anotherGethDiff}
-				storageWatcher.KeccakAddressTransformers[keccakOfAnotherAddress] = anotherTransformer
-
-				go storageWatcher.Execute(diffs, errs, time.Hour)
-
-				Eventually(func() utils.StorageDiff {
-					return anotherTransformer.PassedDiff
-				}).Should(Equal(anotherGethDiff))
-
-				close(done)
-			})
-		})
-
-		Describe("transforming queued storage diffs", func() {
-			BeforeEach(func() {
-				mockQueue.DiffsToReturn = []utils.StorageDiff{gethDiff}
-				storageWatcher = watcher.NewGethStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
-				storageWatcher.Queue = mockQueue
-				storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
-			})
-
-			It("executes transformer for storage diff", func(done Done) {
-				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
-
-				Eventually(func() utils.StorageDiff {
-					return mockTransformer.PassedDiff
-				}).Should(Equal(gethDiff))
-				close(done)
-			})
-
-			It("deletes diff from queue if transformer execution successful", func(done Done) {
-				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
-
-				Eventually(func() int {
-					return mockQueue.DeletePassedId
-				}).Should(Equal(gethDiff.Id))
-				close(done)
-			})
-
-			It("logs error if deleting persisted diff fails", func(done Done) {
-				mockQueue.DeleteErr = fakes.FakeError
-				tempFile, fileErr := ioutil.TempFile("", "log")
-				Expect(fileErr).NotTo(HaveOccurred())
-				defer os.Remove(tempFile.Name())
-				logrus.SetOutput(tempFile)
-
-				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
-
-				Eventually(func() (string, error) {
-					logContent, err := ioutil.ReadFile(tempFile.Name())
-					return string(logContent), err
-				}).Should(ContainSubstring(fakes.FakeError.Error()))
-				close(done)
-			})
-
-			It("deletes obsolete diff from queue if contract not recognized", func(done Done) {
-				obsoleteDiff := utils.StorageDiff{
-					Id:       gethDiff.Id + 1,
-					Contract: common.HexToAddress("0xfedcba9876543210"),
-				}
-				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}
-
-				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
-
-				Eventually(func() int {
-					return mockQueue.DeletePassedId
-				}).Should(Equal(obsoleteDiff.Id))
-				close(done)
-			})
-
-			It("logs error if deleting obsolete diff fails", func(done Done) {
-				obsoleteDiff := utils.StorageDiff{
-					Id:       gethDiff.Id + 1,
-					Contract: common.HexToAddress("0xfedcba9876543210"),
-				}
-				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}
-				mockQueue.DeleteErr = fakes.FakeError
-				tempFile, fileErr := ioutil.TempFile("", "log")
-				Expect(fileErr).NotTo(HaveOccurred())
-				defer os.Remove(tempFile.Name())
-				logrus.SetOutput(tempFile)
-
-				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
-
-				Eventually(func() (string, error) {
-					logContent, err := ioutil.ReadFile(tempFile.Name())
-					return string(logContent), err
-				}).Should(ContainSubstring(fakes.FakeError.Error()))
-				close(done)
-			})
-		})
-	})
-})

libraries/shared/watcher/storage_watcher.go

@@ -18,17 +18,14 @@ package watcher
 
 import (
 	"fmt"
-	"reflect"
-	"time"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/sirupsen/logrus"
-
 	"github.com/vulcanize/vulcanizedb/libraries/shared/fetcher"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/storage"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"time"
 )
 
 type IStorageWatcher interface {
@@ -40,15 +37,24 @@ type StorageWatcher struct {
 	db                        *postgres.DB
 	StorageFetcher            fetcher.IStorageFetcher
 	Queue                     storage.IStorageQueue
-	Transformers              map[common.Address]transformer.StorageTransformer
 	KeccakAddressTransformers map[common.Hash]transformer.StorageTransformer // keccak hash of an address => transformer
-	transformerGetter         func(diff utils.StorageDiff) (transformer.StorageTransformer, bool)
+}
+
+func NewStorageWatcher(fetcher fetcher.IStorageFetcher, db *postgres.DB) StorageWatcher {
+	queue := storage.NewStorageQueue(db)
+	transformers := make(map[common.Hash]transformer.StorageTransformer)
+	return StorageWatcher{
+		db:                        db,
+		StorageFetcher:            fetcher,
+		Queue:                     queue,
+		KeccakAddressTransformers: transformers,
+	}
 }
 
 func (storageWatcher StorageWatcher) AddTransformers(initializers []transformer.StorageTransformerInitializer) {
 	for _, initializer := range initializers {
 		storageTransformer := initializer(storageWatcher.db)
-		storageWatcher.Transformers[storageTransformer.ContractAddress()] = storageTransformer
+		storageWatcher.KeccakAddressTransformers[storageTransformer.KeccakContractAddress()] = storageTransformer
 	}
 }
 
@@ -68,7 +74,8 @@ func (storageWatcher StorageWatcher) Execute(diffsChan chan utils.StorageDiff, e
 }
 
 func (storageWatcher StorageWatcher) getTransformer(diff utils.StorageDiff) (transformer.StorageTransformer, bool) {
-	return storageWatcher.transformerGetter(diff)
+	storageTransformer, ok := storageWatcher.KeccakAddressTransformers[diff.KeccakOfContractAddress]
+	return storageTransformer, ok
 }
 
 func (storageWatcher StorageWatcher) processRow(diff utils.StorageDiff) {
@@ -112,7 +119,3 @@ func (storageWatcher StorageWatcher) deleteRow(id int) {
 		logrus.Warn(fmt.Sprintf("error deleting persisted diff from queue: %s", deleteErr))
 	}
 }
-
-func isKeyNotFound(executeErr error) bool {
-	return reflect.TypeOf(executeErr) == reflect.TypeOf(utils.ErrStorageKeyNotFound{})
-}

libraries/shared/watcher/storage_watcher_test.go

@@ -17,35 +17,36 @@
 package watcher_test
 
 import (
-	"io/ioutil"
-	"os"
-	"time"
-
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/sirupsen/logrus"
-
 	"github.com/vulcanize/vulcanizedb/libraries/shared/mocks"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/storage/utils"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
 	"github.com/vulcanize/vulcanizedb/libraries/shared/watcher"
 	"github.com/vulcanize/vulcanizedb/pkg/fakes"
 	"github.com/vulcanize/vulcanizedb/test_config"
+	"io/ioutil"
+	"os"
+	"time"
 )
 
-var _ = Describe("Csv Storage Watcher", func() {
-	It("adds transformers", func() {
-		fakeAddress := common.HexToAddress("0x12345")
-		fakeTransformer := &mocks.MockStorageTransformer{Address: fakeAddress}
-		w := watcher.NewCsvStorageWatcher(mocks.NewMockStorageFetcher(), test_config.NewTestDB(test_config.NewTestNode()))
+var _ = Describe("Storage Watcher", func() {
+	Describe("AddTransformer", func() {
+		It("adds transformers", func() {
+			fakeHashedAddress := common.BytesToHash(crypto.Keccak256(common.FromHex("0x12345")))
+			fakeTransformer := &mocks.MockStorageTransformer{KeccakOfAddress: fakeHashedAddress}
+			w := watcher.NewStorageWatcher(mocks.NewMockStorageFetcher(), test_config.NewTestDB(test_config.NewTestNode()))
 
-		w.AddTransformers([]transformer.StorageTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
+			w.AddTransformers([]transformer.StorageTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
 
-		Expect(w.Transformers[fakeAddress]).To(Equal(fakeTransformer))
+			Expect(w.KeccakAddressTransformers[fakeHashedAddress]).To(Equal(fakeTransformer))
+		})
 	})
 
-	Describe("executing watcher", func() {
+	Describe("Execute", func() {
 		var (
 			errs            chan error
 			mockFetcher     *mocks.MockStorageFetcher
@@ -53,30 +54,30 @@ var _ = Describe("Csv Storage Watcher", func() {
 			mockTransformer *mocks.MockStorageTransformer
 			csvDiff         utils.StorageDiff
 			diffs           chan utils.StorageDiff
-			storageWatcher  watcher.CsvStorageWatcher
-			address         common.Address
+			storageWatcher  watcher.StorageWatcher
+			hashedAddress   common.Hash
 		)
 
 		BeforeEach(func() {
 			errs = make(chan error)
 			diffs = make(chan utils.StorageDiff)
-			address = common.HexToAddress("0x0123456789abcdef")
+			hashedAddress = common.BytesToHash(crypto.Keccak256(common.FromHex("0x0123456789abcdef")))
 			mockFetcher = mocks.NewMockStorageFetcher()
 			mockQueue = &mocks.MockStorageQueue{}
-			mockTransformer = &mocks.MockStorageTransformer{Address: address}
+			mockTransformer = &mocks.MockStorageTransformer{KeccakOfAddress: hashedAddress}
 			csvDiff = utils.StorageDiff{
-				Id:           1337,
-				Contract:     address,
-				BlockHash:    common.HexToHash("0xfedcba9876543210"),
-				BlockHeight:  0,
-				StorageKey:   common.HexToHash("0xabcdef1234567890"),
-				StorageValue: common.HexToHash("0x9876543210abcdef"),
+				Id:                      1337,
+				KeccakOfContractAddress: hashedAddress,
+				BlockHash:               common.HexToHash("0xfedcba9876543210"),
+				BlockHeight:             0,
+				StorageKey:              common.HexToHash("0xabcdef1234567890"),
+				StorageValue:            common.HexToHash("0x9876543210abcdef"),
 			}
 		})
 
 		It("logs error if fetching storage diffs fails", func(done Done) {
 			mockFetcher.ErrsToReturn = []error{fakes.FakeError}
-			storageWatcher = watcher.NewCsvStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
+			storageWatcher = watcher.NewStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
 			storageWatcher.Queue = mockQueue
 			storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
 			tempFile, fileErr := ioutil.TempFile("", "log")
@@ -96,7 +97,7 @@ var _ = Describe("Csv Storage Watcher", func() {
 		Describe("transforming new storage diffs from csv", func() {
 			BeforeEach(func() {
 				mockFetcher.DiffsToReturn = []utils.StorageDiff{csvDiff}
-				storageWatcher = watcher.NewCsvStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
+				storageWatcher = watcher.NewStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
 				storageWatcher.Queue = mockQueue
 				storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
 			})
@@ -149,7 +150,7 @@ var _ = Describe("Csv Storage Watcher", func() {
 		Describe("transforming queued storage diffs", func() {
 			BeforeEach(func() {
 				mockQueue.DiffsToReturn = []utils.StorageDiff{csvDiff}
-				storageWatcher = watcher.NewCsvStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
+				storageWatcher = watcher.NewStorageWatcher(mockFetcher, test_config.NewTestDB(test_config.NewTestNode()))
 				storageWatcher.Queue = mockQueue
 				storageWatcher.AddTransformers([]transformer.StorageTransformerInitializer{mockTransformer.FakeTransformerInitializer})
 			})
@@ -190,8 +191,8 @@ var _ = Describe("Csv Storage Watcher", func() {
 
 			It("deletes obsolete diff from queue if contract not recognized", func(done Done) {
 				obsoleteDiff := utils.StorageDiff{
-					Id:       csvDiff.Id + 1,
-					Contract: common.HexToAddress("0xfedcba9876543210"),
+					Id:                      csvDiff.Id + 1,
+					KeccakOfContractAddress: common.BytesToHash(crypto.Keccak256(common.FromHex("0xfedcba9876543210"))),
 				}
 				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}
 
@@ -205,8 +206,8 @@ var _ = Describe("Csv Storage Watcher", func() {
 
 			It("logs error if deleting obsolete diff fails", func(done Done) {
 				obsoleteDiff := utils.StorageDiff{
-					Id:       csvDiff.Id + 1,
-					Contract: common.HexToAddress("0xfedcba9876543210"),
+					Id:                      csvDiff.Id + 1,
+					KeccakOfContractAddress: common.BytesToHash(crypto.Keccak256(common.FromHex("0xfedcba9876543210"))),
 				}
 				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}
 				mockQueue.DeleteErr = fakes.FakeError