* update transformer to able to recheck headers (#4)

* update transformer to able to recheck headers
* put cap on rechecking header
* integration test for recheck headers
* use enum for recheck headers param; make recheck cap configurable
* update integration tests with new test config
* update omni pkg with new recheck header column type
* update migration with new migration tool and final tweaks needed to accommodate changes in omni pkg

pkg/transformers/integration_tests/bite.go

@@ -73,7 +73,7 @@ var _ = Describe("Bite Transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []bite.BiteModel
@@ -108,4 +108,71 @@ var _ = Describe("Bite Transformer", func() {
 		Expect(entity.Ilk).To(Equal(expectedEntity.Ilk))
 		Expect(entity.Ink).To(Equal(expectedEntity.Ink))
 	})
+
+	It("rechecks header for bite event", func() {
+		blockNumber := int64(8956422)
+		config := testBiteConfig
+		config.StartingBlockNumber = blockNumber
+		config.EndingBlockNumber = blockNumber
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer := factories.Transformer{
+			Config:     config,
+			Converter:  &bite.BiteConverter{},
+			Repository: &bite.BiteRepository{},
+		}
+		transformer := initializer.NewTransformer(db)
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			[]common.Address{common.HexToAddress(config.ContractAddresses[0])},
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var biteChecked []int
+		err = db.Select(&biteChecked, `SELECT bite_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(biteChecked[0]).To(Equal(2))
+	})
+
+	It("unpacks an event log", func() {
+		address := common.HexToAddress(test_data.KovanCatContractAddress)
+		abi, err := geth.ParseAbi(test_data.KovanCatABI)
+		Expect(err).NotTo(HaveOccurred())
+
+		contract := bind.NewBoundContract(address, abi, nil, nil, nil)
+		entity := &bite.BiteEntity{}
+
+		var eventLog = test_data.EthBiteLog
+
+		err = contract.UnpackLog(entity, "Bite", eventLog)
+		Expect(err).NotTo(HaveOccurred())
+
+		expectedEntity := test_data.BiteEntity
+		Expect(entity.Art).To(Equal(expectedEntity.Art))
+		Expect(entity.Ilk).To(Equal(expectedEntity.Ilk))
+		Expect(entity.Ink).To(Equal(expectedEntity.Ink))
+	})
 })

pkg/transformers/integration_tests/cat_file.go

@@ -87,7 +87,7 @@ var _ = Describe("Cat File transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []chop_lump.CatFileChopLumpModel
@@ -108,6 +108,51 @@ var _ = Describe("Cat File transformer", func() {
 		Expect(dbResult[1].LogIndex).To(Equal(uint(4)))
 	})
 
+	It("rechecks header for chop lump event", func() {
+		// transaction: 0x98574bfba4d05c3875be10d2376e678d005dbebe9a4520363407508fd21f4014
+		chopLumpBlockNumber := int64(8762253)
+		header, err := persistHeader(db, chopLumpBlockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		config := shared.TransformerConfig{
+			TransformerName:     constants.CatFileChopLumpLabel,
+			ContractAddresses:   []string{test_data.KovanCatContractAddress},
+			ContractAbi:         test_data.KovanCatABI,
+			Topic:               test_data.KovanCatFileChopLumpSignature,
+			StartingBlockNumber: chopLumpBlockNumber,
+			EndingBlockNumber:   chopLumpBlockNumber,
+		}
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &chop_lump.CatFileChopLumpConverter{},
+			Repository: &chop_lump.CatFileChopLumpRepository{},
+		}
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		logs, err := fetcher.FetchLogs(
+			[]common.Address{common.HexToAddress(config.ContractAddresses[0])},
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, chopLumpBlockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var catChopLumpChecked []int
+		err = db.Select(&catChopLumpChecked, `SELECT cat_file_chop_lump_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(catChopLumpChecked[0]).To(Equal(2))
+	})
+
 	It("persists a flip event", func() {
 		// transaction: 0x44bc18fdb1a5a263db114e7879653304db3e19ceb4e4496f21bc0a76c5faccbe
 		flipBlockNumber := int64(8751794)
@@ -137,7 +182,7 @@ var _ = Describe("Cat File transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []flip.CatFileFlipModel
@@ -150,6 +195,52 @@ var _ = Describe("Cat File transformer", func() {
 		Expect(dbResult[0].Flip).To(Equal("0x32D496Ad866D110060866B7125981C73642cc509"))
 	})
 
+	It("rechecks a flip event", func() {
+		// transaction: 0x44bc18fdb1a5a263db114e7879653304db3e19ceb4e4496f21bc0a76c5faccbe
+		flipBlockNumber := int64(8751794)
+		header, err := persistHeader(db, flipBlockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		config := shared.TransformerConfig{
+			TransformerName:     constants.CatFileFlipLabel,
+			ContractAddresses:   []string{test_data.KovanCatContractAddress},
+			ContractAbi:         test_data.KovanCatABI,
+			Topic:               test_data.KovanCatFileFlipSignature,
+			StartingBlockNumber: flipBlockNumber,
+			EndingBlockNumber:   flipBlockNumber,
+		}
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &flip.CatFileFlipConverter{},
+			Repository: &flip.CatFileFlipRepository{},
+		}
+
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		logs, err := fetcher.FetchLogs(
+			[]common.Address{common.HexToAddress(config.ContractAddresses[0])},
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, flipBlockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var catFlipChecked []int
+		err = db.Select(&catFlipChecked, `SELECT cat_file_flip_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(catFlipChecked[0]).To(Equal(2))
+	})
+
 	It("persists a pit vow event", func() {
 		// transaction: 0x44bc18fdb1a5a263db114e7879653304db3e19ceb4e4496f21bc0a76c5faccbe
 		pitVowBlockNumber := int64(8751794)
@@ -178,7 +269,7 @@ var _ = Describe("Cat File transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []pit_vow.CatFilePitVowModel

pkg/transformers/integration_tests/deal.go

@@ -84,7 +84,7 @@ var _ = Describe("Deal transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []deal.DealModel
@@ -96,6 +96,34 @@ var _ = Describe("Deal transformer", func() {
 		Expect(dbResult[0].ContractAddress).To(Equal(test_data.KovanFlipperContractAddress))
 	})
 
+	It("rechecks flip deal event", func() {
+		// transaction: 0x05b5eabac2ace136f0f7e0efc61d7d42abe8e8938cc0f04fbf1a6ba545d59e58
+		flipBlockNumber := int64(8958007)
+		header, err := persistHeader(db, flipBlockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer.Config.StartingBlockNumber = flipBlockNumber
+		initializer.Config.EndingBlockNumber = flipBlockNumber
+
+		logs, err := fetcher.FetchLogs(addresses, topics, header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewLogNoteTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, flipBlockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var dentChecked []int
+		err = db.Select(&dentChecked, `SELECT deal_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+	})
+
 	It("persists a flop deal log event", func() {
 		//TODO: There are currently no Flop.deal events on Kovan
 	})
@@ -112,7 +140,7 @@ var _ = Describe("Deal transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []deal.DealModel

pkg/transformers/integration_tests/dent.go

@@ -67,7 +67,7 @@ var _ = Describe("Dent transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer = initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []dent.DentModel
@@ -88,6 +88,35 @@ var _ = Describe("Dent transformer", func() {
 		Expect(dbTic).To(Equal(actualTic))
 	})
 
+	It("rechecks header for flop dent log event", func() {
+		blockNumber := int64(8955613)
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		logs, err := fetcher.FetchLogs(addresses, topics, header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer = initializer.NewLogNoteTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var dentChecked []int
+		err = db.Select(&dentChecked, `SELECT dent_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(dentChecked[0]).To(Equal(2))
+	})
+
 	It("persists a flip dent log event", func() {
 		//TODO: There are currently no Flip.dent events on Kovan
 	})

pkg/transformers/integration_tests/drip_drip.go

@@ -27,6 +27,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
 
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/drip_drip"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
 	"github.com/vulcanize/vulcanizedb/test_config"
 )
 
@@ -76,7 +77,7 @@ var _ = Describe("DripDrip Transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResults []drip_drip.DripDripModel
@@ -87,4 +88,41 @@ var _ = Describe("DripDrip Transformer", func() {
 		dbResult := dbResults[0]
 		Expect(dbResult.Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
 	})
+
+	It("rechecks drip drip event", func() {
+		blockNumber := int64(8934775)
+		config.StartingBlockNumber = blockNumber
+		config.EndingBlockNumber = blockNumber
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &drip_drip.DripDripConverter{},
+			Repository: &drip_drip.DripDripRepository{},
+		}
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var dripdripChecked []int
+		err = db.Select(&dripdripChecked, `SELECT drip_drip_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+	})
 })

pkg/transformers/integration_tests/drip_file_vow.go

@@ -24,10 +24,10 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/factories"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
-	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
 
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/drip_file/vow"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
 	"github.com/vulcanize/vulcanizedb/test_config"
 )
 
@@ -74,7 +74,7 @@ var _ = Describe("Drip File Vow LogNoteTransformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []vow.DripFileVowModel
@@ -85,4 +85,49 @@ var _ = Describe("Drip File Vow LogNoteTransformer", func() {
 		Expect(dbResult[0].What).To(Equal("vow"))
 		Expect(dbResult[0].Data).To(Equal("0x3728e9777B2a0a611ee0F89e00E01044ce4736d1"))
 	})
+
+	It("rechecks drip file vow event", func() {
+		blockNumber := int64(8762197)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.DripFileVowLabel,
+			ContractAddresses:   []string{test_data.KovanDripContractAddress},
+			ContractAbi:         test_data.KovanDripABI,
+			Topic:               test_data.KovanDripFileVowSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vow.DripFileVowConverter{},
+			Repository: &vow.DripFileVowRepository{},
+		}
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var dripfilevowChecked []int
+		err = db.Select(&dripfilevowChecked, `SELECT drip_file_vow_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(dripfilevowChecked[0]).To(Equal(2))
+	})
 })

pkg/transformers/integration_tests/flap_kick.go

@@ -20,7 +20,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/vulcanize/vulcanizedb/pkg/core"
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
-	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
 	"github.com/vulcanize/vulcanizedb/test_config"
 	"time"
@@ -31,6 +30,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/factories"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/flap_kick"
 	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared/constants"
 )
 
 var _ = Describe("FlapKick Transformer", func() {
@@ -75,7 +75,7 @@ var _ = Describe("FlapKick Transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []flap_kick.FlapKickModel
@@ -89,4 +89,48 @@ var _ = Describe("FlapKick Transformer", func() {
 		Expect(dbResult[0].Gal).To(Equal("0x0000d8b4147eDa80Fec7122AE16DA2479Cbd7ffB"))
 		Expect(dbResult[0].Lot).To(Equal("1000000000000000000"))
 	})
+
+	It("rechecks flap kick transformer", func() {
+		blockNumber := int64(9002933)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.FlapKickLabel,
+			ContractAddresses:   []string{test_data.KovanFlapperContractAddress},
+			ContractAbi:         test_data.KovanFlapperABI,
+			Topic:               test_data.KovanFlapKickSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.Transformer{
+			Config:     config,
+			Converter:  &flap_kick.FlapKickConverter{},
+			Repository: &flap_kick.FlapKickRepository{},
+		}.NewTransformer(db)
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var flapkickChecked []int
+		err = db.Select(&flapkickChecked, `SELECT flap_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(flapkickChecked[0]).To(Equal(2))
+	})
 })

pkg/transformers/integration_tests/flip_kick.go

@@ -91,7 +91,7 @@ var _ = Describe("FlipKick Transformer", func() {
 			header)
 		Expect(err).NotTo(HaveOccurred())
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []flip_kick.FlipKickModel
@@ -105,4 +105,55 @@ var _ = Describe("FlipKick Transformer", func() {
 		Expect(dbResult[0].Gal).To(Equal("0x3728e9777B2a0a611ee0F89e00E01044ce4736d1"))
 		Expect(dbResult[0].Lot).To(Equal("1000000000000000000"))
 	})
+
+	It("rechecks flip kick event", func() {
+		blockNumber := int64(8956476)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.FlipKickLabel,
+			ContractAddresses:   []string{test_data.KovanFlipperContractAddress},
+			ContractAbi:         test_data.KovanFlipperABI,
+			Topic:               test_data.KovanFlipKickSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.Transformer{
+			Config:     config,
+			Converter:  &flip_kick.FlipKickConverter{},
+			Repository: &flip_kick.FlipKickRepository{},
+		}.NewTransformer(db)
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var flipkickChecked []int
+		err = db.Select(&flipkickChecked, `SELECT flip_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(flipkickChecked[0]).To(Equal(2))
+	})
 })

pkg/transformers/integration_tests/flop_kick.go

@@ -86,7 +86,7 @@ var _ = Describe("FlopKick Transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []flop_kick.Model
@@ -102,6 +102,47 @@ var _ = Describe("FlopKick Transformer", func() {
 		Expect(dbResult[0].Lot).To(Equal("115792089237316195423570985008687907853269984665640564039457584007913129639935"))
 	})
 
+	It("rechecks flop kick event", func() {
+		blockNumber := int64(8672119)
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		logs, err := fetcher.FetchLogs(addresses, topics, header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var dbResult []flop_kick.Model
+		err = db.Select(&dbResult, `SELECT bid, bid_id, "end", gal, lot FROM maker.flop_kick`)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var flopKickChecked []int
+		err = db.Select(&flopKickChecked, `SELECT flop_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(flopKickChecked[0]).To(Equal(2))
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Bid).To(Equal("0"))
+		Expect(dbResult[0].BidId).To(Equal("1"))
+		Expect(dbResult[0].End.Equal(time.Unix(1536726768, 0))).To(BeTrue())
+		Expect(dbResult[0].Gal).To(Equal("0x9B870D55BaAEa9119dBFa71A92c5E26E79C4726d"))
+		// this very large number appears to be derived from the data including: "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+		Expect(dbResult[0].Lot).To(Equal("115792089237316195423570985008687907853269984665640564039457584007913129639935"))
+	})
+
 	It("fetches and transforms another FlopKick event from Kovan chain", func() {
 		blockNumber := int64(8955611)
 		initializer.Config.StartingBlockNumber = blockNumber
@@ -114,7 +155,7 @@ var _ = Describe("FlopKick Transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []flop_kick.Model

pkg/transformers/integration_tests/frob.go

@@ -82,7 +82,7 @@ var _ = Describe("Frob Transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []frob.FrobModel
@@ -99,6 +99,51 @@ var _ = Describe("Frob Transformer", func() {
 		Expect(dbResult[0].Urn).To(Equal("0xc8E093e5f3F9B5Aa6A6b33ea45960b93C161430C"))
 	})
 
+	It("rechecks frob event", func() {
+		blockNumber := int64(8935258)
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var frobChecked []int
+		err = db.Select(&frobChecked, `SELECT frob_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(frobChecked[0]).To(Equal(2))
+
+		var dbResult []frob.FrobModel
+		err = db.Select(&dbResult, `SELECT art, dart, dink, iart, ilk, ink, urn from maker.frob`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Art).To(Equal("10000000000000000"))
+		Expect(dbResult[0].Dart).To(Equal("0"))
+		Expect(dbResult[0].Dink).To(Equal("10000000000000"))
+		Expect(dbResult[0].IArt).To(Equal("1495509999999999999992"))
+		Expect(dbResult[0].Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].Ink).To(Equal("10050100000000000"))
+		Expect(dbResult[0].Urn).To(Equal("0xc8E093e5f3F9B5Aa6A6b33ea45960b93C161430C"))
+	})
+
 	It("unpacks an event log", func() {
 		address := common.HexToAddress(test_data.KovanPitContractAddress)
 		abi, err := geth.ParseAbi(test_data.KovanPitABI)

pkg/transformers/integration_tests/pit_file_debt_ceiling.go

@@ -74,7 +74,7 @@ var _ = Describe("PitFileDebtCeiling LogNoteTransformer", func() {
 		}
 		transformer := initializer.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []debt_ceiling.PitFileDebtCeilingModel
@@ -85,4 +85,57 @@ var _ = Describe("PitFileDebtCeiling LogNoteTransformer", func() {
 		Expect(dbResult[0].What).To(Equal("Line"))
 		Expect(dbResult[0].Data).To(Equal("10000000.000000000000000000"))
 	})
+
+	It("rechecks pit file debt ceiling event", func() {
+		blockNumber := int64(8535578)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.PitFileDebtCeilingLabel,
+			ContractAddresses:   []string{test_data.KovanPitContractAddress},
+			ContractAbi:         test_data.KovanPitABI,
+			Topic:               test_data.KovanPitFileDebtCeilingSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &debt_ceiling.PitFileDebtCeilingConverter{},
+			Repository: &debt_ceiling.PitFileDebtCeilingRepository{},
+		}
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var pitFileDebtCeilingChecked []int
+		err = db.Select(&pitFileDebtCeilingChecked, `SELECT pit_file_debt_ceiling_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(pitFileDebtCeilingChecked[0]).To(Equal(2))
+
+		var dbResult []debt_ceiling.PitFileDebtCeilingModel
+		err = db.Select(&dbResult, `SELECT what, data from maker.pit_file_debt_ceiling`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].What).To(Equal("Line"))
+		Expect(dbResult[0].Data).To(Equal("10000000.000000000000000000"))
+	})
 })

pkg/transformers/integration_tests/pit_file_ilk.go

@@ -79,7 +79,7 @@ var _ = Describe("PitFileIlk LogNoteTransformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []ilk.PitFileIlkModel
@@ -92,6 +92,45 @@ var _ = Describe("PitFileIlk LogNoteTransformer", func() {
 		Expect(dbResult[0].Data).To(Equal("139.840000000000003410605131648"))
 	})
 
+	It("rechecks pit file ilk event", func() {
+		blockNumber := int64(9103223)
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(addresses, topics, header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewLogNoteTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var pitFileIlkChecked []int
+		err = db.Select(&pitFileIlkChecked, `SELECT pit_file_ilk_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(pitFileIlkChecked[0]).To(Equal(2))
+
+		var dbResult []ilk.PitFileIlkModel
+		err = db.Select(&dbResult, `SELECT ilk, what, data from maker.pit_file_ilk`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Ilk).To(Equal("0x4554480000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].What).To(Equal("spot"))
+		Expect(dbResult[0].Data).To(Equal("139.840000000000003410605131648"))
+	})
+
 	It("fetches and transforms a Pit.file ilk 'line' event from Kovan", func() {
 		blockNumber := int64(8762253)
 		initializer.Config.StartingBlockNumber = blockNumber
@@ -105,7 +144,7 @@ var _ = Describe("PitFileIlk LogNoteTransformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []ilk.PitFileIlkModel

pkg/transformers/integration_tests/price_feeds.go

@@ -75,7 +75,7 @@ var _ = Describe("Price feeds transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 
 		Expect(err).NotTo(HaveOccurred())
 		var model price_feeds.PriceFeedModel
@@ -85,6 +85,45 @@ var _ = Describe("Price feeds transformer", func() {
 		Expect(model.MedianizerAddress).To(Equal(addresses[0]))
 	})
 
+	It("rechecks price feed event", func() {
+		blockNumber := int64(8763054)
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+		addresses := []string{test_data.KovanPipContractAddress}
+		initializer.Config.ContractAddresses = addresses
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(addresses),
+			topics,
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewLogNoteTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var priceFeedChecked []int
+		err = db.Select(&priceFeedChecked, `SELECT price_feeds_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(priceFeedChecked[0]).To(Equal(2))
+
+		var model price_feeds.PriceFeedModel
+		err = db.Get(&model, `SELECT block_number, medianizer_address, usd_value, tx_idx, raw_log FROM maker.price_feeds WHERE block_number = $1`, initializer.Config.StartingBlockNumber)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(model.UsdValue).To(Equal("207.314891143000011198"))
+		Expect(model.MedianizerAddress).To(Equal(addresses[0]))
+	})
+
 	It("persists a MKR/USD price feed event", func() {
 		blockNumber := int64(8763059)
 		header, err := persistHeader(db, blockNumber, blockChain)
@@ -101,7 +140,7 @@ var _ = Describe("Price feeds transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 
 		Expect(err).NotTo(HaveOccurred())
 		var model price_feeds.PriceFeedModel
@@ -127,7 +166,7 @@ var _ = Describe("Price feeds transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 
 		Expect(err).NotTo(HaveOccurred())
 		var model price_feeds.PriceFeedModel

pkg/transformers/integration_tests/tend.go

@@ -81,7 +81,7 @@ var _ = Describe("Tend LogNoteTransformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []tend.TendModel
@@ -102,6 +102,52 @@ var _ = Describe("Tend LogNoteTransformer", func() {
 		Expect(dbTic).To(Equal(actualTic))
 	})
 
+	It("rechecks tend event", func() {
+		blockNumber := int64(8935601)
+		initializer.Config.StartingBlockNumber = blockNumber
+		initializer.Config.EndingBlockNumber = blockNumber
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		logs, err := fetcher.FetchLogs(addresses, topics, header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := initializer.NewLogNoteTransformer(db)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var tendChecked []int
+		err = db.Select(&tendChecked, `SELECT tend_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(tendChecked[0]).To(Equal(2))
+
+		var dbResult []tend.TendModel
+		err = db.Select(&dbResult, `SELECT bid, bid_id, guy, lot from maker.tend where header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Bid).To(Equal("4000"))
+		Expect(dbResult[0].BidId).To(Equal("3"))
+		Expect(dbResult[0].Guy).To(Equal("0x0000d8b4147eDa80Fec7122AE16DA2479Cbd7ffB"))
+		Expect(dbResult[0].Lot).To(Equal("1000000000000000000"))
+
+		var dbTic int64
+		err = db.Get(&dbTic, `SELECT tic FROM maker.tend`)
+		Expect(err).NotTo(HaveOccurred())
+
+		actualTic := 1538490276 + constants.TTL
+		Expect(dbTic).To(Equal(actualTic))
+	})
+
 	It("fetches and transforms a subsequent Flip Tend event from Kovan chain for the same auction", func() {
 		blockNumber := int64(8935731)
 		initializer.Config.StartingBlockNumber = blockNumber
@@ -114,7 +160,7 @@ var _ = Describe("Tend LogNoteTransformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []tend.TendModel
@@ -147,7 +193,7 @@ var _ = Describe("Tend LogNoteTransformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		transformer := initializer.NewLogNoteTransformer(db)
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []tend.TendModel

pkg/transformers/integration_tests/vat_flux.go

@@ -66,7 +66,7 @@ var _ = Describe("VatFlux LogNoteTransformer", func() {
 		}
 		transformer := initializer.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []vat_flux.VatFluxModel
@@ -80,4 +80,68 @@ var _ = Describe("VatFlux LogNoteTransformer", func() {
 		Expect(dbResult[0].Rad).To(Equal("1800000000000000000000000000000000000000000000"))
 		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
 	})
+
+	It("rechecks vat flux event", func() {
+		blockNumber := int64(9004474)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatFluxLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatFluxSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		initializer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_flux.VatFluxConverter{},
+			Repository: &vat_flux.VatFluxRepository{},
+		}
+		transformer := initializer.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatFluxChecked []int
+		err = db.Select(&vatFluxChecked, `SELECT vat_flux_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatFluxChecked[0]).To(Equal(2))
+
+		var dbResult []vat_flux.VatFluxModel
+		err = db.Select(&dbResult, `SELECT ilk, src, dst, rad from maker.vat_flux`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Ilk).To(Equal("5245500000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].Src).To(Equal("0xC0851F73CC8DD5c0765E71980eC7E7Fd1EF74434"))
+		Expect(dbResult[0].Dst).To(Equal("0x0000d8b4147eDa80Fec7122AE16DA2479Cbd7ffB"))
+		Expect(dbResult[0].Rad).To(Equal("1800000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
+	})
 })

pkg/transformers/integration_tests/vat_fold.go

@@ -73,7 +73,7 @@ var _ = Describe("VatFold Transformer", func() {
 			Repository: &vat_fold.VatFoldRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResults []vat_fold.VatFoldModel
@@ -86,4 +86,58 @@ var _ = Describe("VatFold Transformer", func() {
 		Expect(dbResult.Urn).To(Equal(common.HexToAddress("0x0000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1").String()))
 		Expect(dbResult.Rate).To(Equal("0.000000000000000000000000000"))
 	})
+
+	It("rechecks vat fold event", func() {
+		blockNumber := int64(9367233)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatFoldLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatFoldSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_fold.VatFoldConverter{},
+			Repository: &vat_fold.VatFoldRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatFoldChecked []int
+		err = db.Select(&vatFoldChecked, `SELECT vat_fold_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatFoldChecked[0]).To(Equal(2))
+
+		var dbResults []vat_fold.VatFoldModel
+		err = db.Select(&dbResults, `SELECT ilk, urn, rate from maker.vat_fold`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResults)).To(Equal(1))
+		dbResult := dbResults[0]
+		Expect(dbResult.Ilk).To(Equal("5245500000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult.Urn).To(Equal(common.HexToAddress("0x0000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1").String()))
+		Expect(dbResult.Rate).To(Equal("0.000000000000000000000000000"))
+	})
 })

pkg/transformers/integration_tests/vat_grab.go

@@ -67,7 +67,7 @@ var _ = Describe("Vat Grab Transformer", func() {
 			Repository: &vat_grab.VatGrabRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []vat_grab.VatGrabModel
@@ -87,4 +87,72 @@ var _ = Describe("Vat Grab Transformer", func() {
 		Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
 		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
 	})
+
+	It("rechecks vat grab event", func() {
+		blockNumber := int64(8958230)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatGrabLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatGrabSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_grab.VatGrabConverter{},
+			Repository: &vat_grab.VatGrabRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatGrabChecked []int
+		err = db.Select(&vatGrabChecked, `SELECT vat_grab_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatGrabChecked[0]).To(Equal(2))
+
+		var dbResult []vat_grab.VatGrabModel
+		err = db.Select(&dbResult, `SELECT ilk, urn, v, w, dink, dart from maker.vat_grab`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Ilk).To(Equal("5245500000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].Urn).To(Equal("0x6a3AE20C315E845B2E398e68EfFe39139eC6060C"))
+		Expect(dbResult[0].V).To(Equal("0x2F34f22a00eE4b7a8F8BBC4eAee1658774c624e0")) //cat contract address
+		Expect(dbResult[0].W).To(Equal("0x3728e9777B2a0a611ee0F89e00E01044ce4736d1"))
+		expectedDink := new(big.Int)
+		expectedDink.SetString("115792089237316195423570985008687907853269984665640564039455584007913129639936", 10)
+		Expect(dbResult[0].Dink).To(Equal(expectedDink.String()))
+		expectedDart := new(big.Int)
+		expectedDart.SetString("115792089237316195423570985008687907853269984665640564039441803007913129639936", 10)
+		Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
+		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
+	})
 })

pkg/transformers/integration_tests/vat_heal.go

@@ -65,7 +65,7 @@ var _ = Describe("VatHeal Transformer", func() {
 			Repository: &vat_heal.VatHealRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResults []vat_heal.VatHealModel
@@ -78,4 +78,65 @@ var _ = Describe("VatHeal Transformer", func() {
 		Expect(dbResult.V).To(Equal(common.HexToAddress("0x0000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1").String()))
 		Expect(dbResult.Rad).To(Equal("1000000000000000000000000000"))
 	})
+
+	It("rechecks vat heal event", func() {
+		blockNumber := int64(8935578)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatHealLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatHealSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_heal.VatHealConverter{},
+			Repository: &vat_heal.VatHealRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatHealChecked []int
+		err = db.Select(&vatHealChecked, `SELECT vat_heal_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatHealChecked[0]).To(Equal(2))
+
+		var dbResults []vat_heal.VatHealModel
+		err = db.Select(&dbResults, `SELECT urn, v, rad from maker.vat_heal`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResults)).To(Equal(1))
+		dbResult := dbResults[0]
+		Expect(dbResult.Urn).To(Equal(common.HexToAddress("0x0000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1").String()))
+		Expect(dbResult.V).To(Equal(common.HexToAddress("0x0000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1").String()))
+		Expect(dbResult.Rad).To(Equal("1000000000000000000000000000"))
+	})
 })

pkg/transformers/integration_tests/vat_init.go

@@ -65,7 +65,7 @@ var _ = Describe("VatInit LogNoteTransformer", func() {
 			Repository: &vat_init.VatInitRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResults []vat_init.VatInitModel
@@ -76,4 +76,64 @@ var _ = Describe("VatInit LogNoteTransformer", func() {
 		dbResult := dbResults[0]
 		Expect(dbResult.Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
 	})
+
+	It("rechecks vat init event", func() {
+		blockNumber := int64(8535561)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatInitLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatInitSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_init.VatInitConverter{},
+			Repository: &vat_init.VatInitRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatInitChecked []int
+		err = db.Select(&vatInitChecked, `SELECT vat_init_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatInitChecked[0]).To(Equal(2))
+
+		var dbResults []vat_init.VatInitModel
+		err = db.Select(&dbResults, `SELECT ilk from maker.vat_init`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResults)).To(Equal(1))
+		dbResult := dbResults[0]
+		Expect(dbResult.Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
+	})
 })

pkg/transformers/integration_tests/vat_move.go

@@ -65,7 +65,7 @@ var _ = Describe("VatMove LogNoteTransformer", func() {
 			Repository: &vat_move.VatMoveRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResults []vat_move.VatMoveModel
@@ -78,4 +78,66 @@ var _ = Describe("VatMove LogNoteTransformer", func() {
 		Expect(dbResult.Dst).To(Equal(common.HexToAddress("0x0000d8b4147eda80fec7122ae16da2479cbd7ffb").String()))
 		Expect(dbResult.Rad).To(Equal("1000000000000000000000000000000000000000000000"))
 	})
+
+	It("rechecks vat move event", func() {
+		blockNumber := int64(9004628)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatMoveLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatMoveSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_move.VatMoveConverter{},
+			Repository: &vat_move.VatMoveRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatMoveChecked []int
+		err = db.Select(&vatMoveChecked, `SELECT vat_move_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatMoveChecked[0]).To(Equal(2))
+
+		var dbResults []vat_move.VatMoveModel
+		err = db.Select(&dbResults, `SELECT src, dst, rad from maker.vat_move`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResults)).To(Equal(1))
+		dbResult := dbResults[0]
+		Expect(dbResult.Src).To(Equal(common.HexToAddress("0x8868bad8e74fca4505676d1b5b21ecc23328d132").String()))
+		Expect(dbResult.Dst).To(Equal(common.HexToAddress("0x0000d8b4147eda80fec7122ae16da2479cbd7ffb").String()))
+		Expect(dbResult.Rad).To(Equal("1000000000000000000000000000000000000000000000"))
+	})
 })

pkg/transformers/integration_tests/vat_slip.go

@@ -57,7 +57,7 @@ var _ = Describe("Vat slip transformer", func() {
 			Repository: &vat_slip.VatSlipRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 
 		Expect(err).NotTo(HaveOccurred())
 		var headerID int64
@@ -75,4 +75,62 @@ var _ = Describe("Vat slip transformer", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(headerChecked).To(BeTrue())
 	})
+
+	It("rechecks vat slip event", func() {
+		blockNumber := int64(8953655)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatSlipLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatSlipSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_slip.VatSlipConverter{},
+			Repository: &vat_slip.VatSlipRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatSlipChecked []int
+		err = db.Select(&vatSlipChecked, `SELECT vat_slip_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatSlipChecked[0]).To(Equal(2))
+
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+		var model vat_slip.VatSlipModel
+		err = db.Get(&model, `SELECT ilk, guy, rad, tx_idx FROM maker.vat_slip WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(model.Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
+		Expect(model.Guy).To(Equal("0xDA15dCE70ab462E66779f23ee14F21d993789eE3"))
+		Expect(model.Rad).To(Equal("100000000000000000000000000000000000000000000000"))
+		Expect(model.TransactionIndex).To(Equal(uint(0)))
+		var headerChecked int
+		err = db.Get(&headerChecked, `SELECT vat_slip_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(headerChecked).To(Equal(2))
+	})
 })

pkg/transformers/integration_tests/vat_tune.go

@@ -67,7 +67,7 @@ var _ = Describe("VatTune LogNoteTransformer", func() {
 			Repository: &vat_tune.VatTuneRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []vat_tune.VatTuneModel
@@ -85,4 +85,71 @@ var _ = Describe("VatTune LogNoteTransformer", func() {
 		Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
 		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
 	})
+
+	It("transforms VatTune log events", func() {
+		blockNumber := int64(8761670)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VatTuneLabel,
+			ContractAddresses:   []string{test_data.KovanVatContractAddress},
+			ContractAbi:         test_data.KovanVatABI,
+			Topic:               test_data.KovanVatTuneSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		rpcClient, ethClient, err := getClients(ipc)
+		Expect(err).NotTo(HaveOccurred())
+		blockChain, err := getBlockChain(rpcClient, ethClient)
+		Expect(err).NotTo(HaveOccurred())
+
+		db := test_config.NewTestDB(blockChain.Node())
+		test_config.CleanTestDB(db)
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vat_tune.VatTuneConverter{},
+			Repository: &vat_tune.VatTuneRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vatTuneChecked []int
+		err = db.Select(&vatTuneChecked, `SELECT vat_tune_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vatTuneChecked[0]).To(Equal(2))
+
+		var dbResult []vat_tune.VatTuneModel
+		err = db.Select(&dbResult, `SELECT ilk, urn, v, w, dink, dart from maker.vat_tune`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(len(dbResult)).To(Equal(1))
+		Expect(dbResult[0].Ilk).To(Equal("4554480000000000000000000000000000000000000000000000000000000000"))
+		Expect(dbResult[0].Urn).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
+		Expect(dbResult[0].V).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
+		Expect(dbResult[0].W).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
+		Expect(dbResult[0].Dink).To(Equal("0"))
+		expectedDart := new(big.Int)
+		expectedDart.SetString("115792089237316195423570985008687907853269984665640564039455584007913129639936", 10)
+		Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
+		Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
+	})
 })

pkg/transformers/integration_tests/vow_flog.go

@@ -73,7 +73,7 @@ var _ = Describe("VowFlog LogNoteTransformer", func() {
 			Repository: &vow_flog.VowFlogRepository{},
 		}.NewLogNoteTransformer(db)
 
-		err = transformer.Execute(logs, header)
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
 		Expect(err).NotTo(HaveOccurred())
 
 		var dbResult []vow_flog.VowFlogModel
@@ -84,4 +84,55 @@ var _ = Describe("VowFlog LogNoteTransformer", func() {
 		Expect(dbResult[0].LogIndex).To(Equal(uint(2)))
 		Expect(dbResult[0].TransactionIndex).To(Equal(uint(2)))
 	})
+
+	It("rechecks vow flog event", func() {
+		blockNumber := int64(8946819)
+		config := shared.TransformerConfig{
+			TransformerName:     constants.VowFlogLabel,
+			ContractAddresses:   []string{test_data.KovanVowContractAddress},
+			ContractAbi:         test_data.KovanVowABI,
+			Topic:               test_data.KovanVowFlogSignature,
+			StartingBlockNumber: blockNumber,
+			EndingBlockNumber:   blockNumber,
+		}
+
+		header, err := persistHeader(db, blockNumber, blockChain)
+		Expect(err).NotTo(HaveOccurred())
+
+		fetcher := shared.NewFetcher(blockChain)
+		logs, err := fetcher.FetchLogs(
+			shared.HexStringsToAddresses(config.ContractAddresses),
+			[]common.Hash{common.HexToHash(config.Topic)},
+			header)
+		Expect(err).NotTo(HaveOccurred())
+		transformer := factories.LogNoteTransformer{
+			Config:     config,
+			Converter:  &vow_flog.VowFlogConverter{},
+			Repository: &vow_flog.VowFlogRepository{},
+		}.NewLogNoteTransformer(db)
+
+		err = transformer.Execute(logs, header, constants.HeaderMissing)
+		Expect(err).NotTo(HaveOccurred())
+
+		err = transformer.Execute(logs, header, constants.HeaderRecheck)
+		Expect(err).NotTo(HaveOccurred())
+
+		var headerID int64
+		err = db.Get(&headerID, `SELECT id FROM public.headers WHERE block_number = $1`, blockNumber)
+		Expect(err).NotTo(HaveOccurred())
+
+		var vowFlogChecked []int
+		err = db.Select(&vowFlogChecked, `SELECT vow_flog_checked FROM public.checked_headers WHERE header_id = $1`, headerID)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(vowFlogChecked[0]).To(Equal(2))
+
+		var dbResult []vow_flog.VowFlogModel
+		err = db.Select(&dbResult, `SELECT era, log_idx, tx_idx from maker.vow_flog`)
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(dbResult[0].Era).To(Equal("1538558052"))
+		Expect(dbResult[0].LogIndex).To(Equal(uint(2)))
+		Expect(dbResult[0].TransactionIndex).To(Equal(uint(2)))
+	})
 })