Memoizing keccak hhash of address => transformer

libraries/shared/watcher/storage_watcher.go

@@ -33,22 +33,25 @@ import (
 )
 
 type StorageWatcher struct {
-	db             *postgres.DB
+	db                        *postgres.DB
-	diffSource     string
+	diffSource                string
-	StorageFetcher fetcher.IStorageFetcher
+	StorageFetcher            fetcher.IStorageFetcher
-	Queue          storage.IStorageQueue
+	Queue                     storage.IStorageQueue
-	Transformers   map[common.Address]transformer.StorageTransformer
+	Transformers              map[common.Address]transformer.StorageTransformer
+	KeccakAddressTransformers map[common.Address]transformer.StorageTransformer // keccak hash of an address => transformer
 }
 
 func NewStorageWatcher(fetcher fetcher.IStorageFetcher, db *postgres.DB) StorageWatcher {
-	transformers := make(map[common.Address]transformer.StorageTransformer)
 	queue := storage.NewStorageQueue(db)
+	transformers := make(map[common.Address]transformer.StorageTransformer)
+	keccakAddressTransformers := make(map[common.Address]transformer.StorageTransformer)
 	return StorageWatcher{
-		db:             db,
+		db:                        db,
-		diffSource:     "csv",
+		diffSource:                "csv",
-		StorageFetcher: fetcher,
+		StorageFetcher:            fetcher,
-		Queue:          queue,
+		Queue:                     queue,
-		Transformers:   transformers,
+		Transformers:              transformers,
+		KeccakAddressTransformers: keccakAddressTransformers,
 	}
 }
 
@@ -83,11 +86,16 @@ func (storageWatcher StorageWatcher) getTransformer(contractAddress common.Addre
 		storageTransformer, ok := storageWatcher.Transformers[contractAddress]
 		return storageTransformer, ok
 	} else if storageWatcher.diffSource == "geth" {
-		logrus.Debug("number of transformers", len(storageWatcher.Transformers))
+		storageTransformer, ok := storageWatcher.KeccakAddressTransformers[contractAddress]
-		for address, t := range storageWatcher.Transformers {
+		if ok {
-			keccakOfTransformerAddress := common.BytesToAddress(crypto.Keccak256(address[:]))
+			return storageTransformer, ok
-			if keccakOfTransformerAddress == contractAddress {
+		} else {
-				return t, true
+			for address, transformer := range storageWatcher.Transformers {
+				keccakOfTransformerAddress := common.BytesToAddress(crypto.Keccak256(address[:]))
+				if keccakOfTransformerAddress == contractAddress {
+					storageWatcher.KeccakAddressTransformers[contractAddress] = transformer
+					return transformer, true
+				}
 			}
 		}
 

libraries/shared/watcher/storage_watcher_test.go

@@ -56,12 +56,15 @@ var _ = Describe("Storage Watcher", func() {
 			gethDiff        utils.StorageDiff
 			diffs           chan utils.StorageDiff
 			storageWatcher  watcher.StorageWatcher
+			address         common.Address
+			keccakOfAddress common.Address
 		)
 
 		BeforeEach(func() {
 			errs = make(chan error)
 			diffs = make(chan utils.StorageDiff)
-			address := common.HexToAddress("0x0123456789abcdef")
+			address = common.HexToAddress("0x0123456789abcdef")
+			keccakOfAddress = common.BytesToAddress(crypto.Keccak256(address[:]))
 			mockFetcher = mocks.NewMockStorageFetcher()
 			mockQueue = &mocks.MockStorageQueue{}
 			mockTransformer = &mocks.MockStorageTransformer{Address: address}
@@ -75,7 +78,7 @@ var _ = Describe("Storage Watcher", func() {
 			}
 			gethDiff = utils.StorageDiff{
 				Id:           1338,
-				Contract:     common.BytesToAddress(crypto.Keccak256(address[:])),
+				Contract:     keccakOfAddress,
 				BlockHash:    common.HexToHash("0xfedcba9876543210"),
 				BlockHeight:  0,
 				StorageKey:   common.HexToHash("0xabcdef1234567890"),
@@ -208,6 +211,44 @@ var _ = Describe("Storage Watcher", func() {
 					}).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.Address]transformer.StorageTransformer)
+					m[keccakOfAddress] = mockTransformer
+
+					Eventually(func() map[common.Address]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.BytesToAddress(crypto.Keccak256(anotherAddress[:]))
+
+					anotherGethDiff := utils.StorageDiff{
+						Id:           1338,
+						Contract:     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)
+				})
 			})
 		})