Flop kick (#28)

* FlopKick transformer
2018-09-26 09:42:52 -05:00
parent a0ba6ca6bd
commit 31516ea87e
25 changed files with 1247 additions and 100 deletions
@@ -0,0 +1,25 @@
+// 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 flop_kick
+
+import "github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+
+var Config = shared.TransformerConfig{
+	ContractAddress:     shared.FlopperContractAddress,
+	ContractAbi:         shared.FlopperABI,
+	Topics:              []string{shared.FlopKickSignature},
+	StartingBlockNumber: 0,
+	EndingBlockNumber:   10000000,
+}
@@ -0,0 +1,81 @@
+// 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 flop_kick
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+)
+
+type Converter interface {
+	ToEntities(contractAddress, contractAbi string, ethLogs []types.Log) ([]Entity, error)
+	ToModels(entities []Entity) ([]Model, error)
+}
+
+type FlopKickConverter struct{}
+
+func (FlopKickConverter) ToEntities(contractAddress, contractAbi string, ethLogs []types.Log) ([]Entity, error) {
+	var results []Entity
+	for _, ethLog := range ethLogs {
+		entity := Entity{}
+		address := common.HexToAddress(contractAddress)
+		abi, err := geth.ParseAbi(contractAbi)
+		if err != nil {
+			return nil, err
+		}
+
+		contract := bind.NewBoundContract(address, abi, nil, nil, nil)
+
+		err = contract.UnpackLog(&entity, "Kick", ethLog)
+		if err != nil {
+			return nil, err
+		}
+		entity.Raw = ethLog
+		entity.TransactionIndex = ethLog.TxIndex
+		results = append(results, entity)
+	}
+	return results, nil
+}
+
+func (FlopKickConverter) ToModels(entities []Entity) ([]Model, error) {
+	var results []Model
+	for _, entity := range entities {
+		endValue := shared.BigIntToInt64(entity.End)
+		rawLogJson, err := json.Marshal(entity.Raw)
+		if err != nil {
+			return nil, err
+		}
+
+		model := Model{
+			BidId:            shared.BigIntToString(entity.Id),
+			Lot:              shared.BigIntToString(entity.Lot),
+			Bid:              shared.BigIntToString(entity.Bid),
+			Gal:              entity.Gal.String(),
+			End:              time.Unix(endValue, 0),
+			TransactionIndex: entity.TransactionIndex,
+			Raw:              rawLogJson,
+		}
+		results = append(results, model)
+	}
+
+	return results, nil
+}
@@ -0,0 +1,82 @@
+// 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 flop_kick_test
+
+import (
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/flop_kick"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+var _ = Describe("FlopKick Converter", func() {
+	Describe("ToEntities", func() {
+		It("converts a log to a FlopKick entity", func() {
+			converter := flop_kick.FlopKickConverter{}
+			entities, err := converter.ToEntities(shared.FlopperContractAddress, shared.FlopperABI, []types.Log{test_data.FlopKickLog})
+
+			Expect(err).NotTo(HaveOccurred())
+			entity := entities[0]
+			Expect(entity.Id).To(Equal(test_data.FlopKickEntity.Id))
+			Expect(entity.Lot).To(Equal(test_data.FlopKickEntity.Lot))
+			Expect(entity.Bid).To(Equal(test_data.FlopKickEntity.Bid))
+			Expect(entity.Gal).To(Equal(test_data.FlopKickEntity.Gal))
+			Expect(entity.End).To(Equal(test_data.FlopKickEntity.End))
+			Expect(entity.TransactionIndex).To(Equal(test_data.FlopKickEntity.TransactionIndex))
+			Expect(entity.Raw).To(Equal(test_data.FlopKickEntity.Raw))
+		})
+
+		It("returns an error if converting the log to an entity fails", func() {
+			converter := flop_kick.FlopKickConverter{}
+			entities, err := converter.ToEntities(shared.FlopperContractAddress, "error abi", []types.Log{test_data.FlopKickLog})
+
+			Expect(err).To(HaveOccurred())
+			Expect(entities).To(BeNil())
+		})
+	})
+
+	Describe("ToModels", func() {
+		var emptyAddressHex = "0x0000000000000000000000000000000000000000"
+		var emptyString = ""
+		var emptyTime = time.Unix(0, 0)
+		var emptyEntities = []flop_kick.Entity{flop_kick.Entity{}}
+
+		It("converts an Entity to a Model", func() {
+			converter := flop_kick.FlopKickConverter{}
+			models, err := converter.ToModels([]flop_kick.Entity{test_data.FlopKickEntity})
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(models[0]).To(Equal(test_data.FlopKickModel))
+		})
+
+		It("handles nil values", func() {
+			converter := flop_kick.FlopKickConverter{}
+
+			models, err := converter.ToModels(emptyEntities)
+			model := models[0]
+			Expect(err).NotTo(HaveOccurred())
+			Expect(model.BidId).To(Equal(emptyString))
+			Expect(model.Lot).To(Equal(emptyString))
+			Expect(model.Bid).To(Equal(emptyString))
+			Expect(model.Gal).To(Equal(emptyAddressHex))
+			Expect(model.End).To(Equal(emptyTime))
+		})
+	})
+})
@@ -0,0 +1,32 @@
+// 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 flop_kick
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type Entity struct {
+	Id               *big.Int
+	Lot              *big.Int
+	Bid              *big.Int
+	Gal              common.Address
+	End              *big.Int
+	TransactionIndex uint
+	Raw              types.Log
+}
@@ -0,0 +1,13 @@
+package flop_kick_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestFlopKick(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "FlopKick Suite")
+}
@@ -0,0 +1,50 @@
+// 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 flop_kick_test
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/geth"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/flop_kick"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
+)
+
+var _ = Describe("Integration tests", func() {
+	It("unpacks an flop kick event log", func() {
+		address := common.HexToAddress(shared.FlopperContractAddress)
+		abi, err := geth.ParseAbi(shared.FlopperABI)
+		Expect(err).NotTo(HaveOccurred())
+
+		contract := bind.NewBoundContract(address, abi, nil, nil, nil)
+		entity := &flop_kick.Entity{}
+
+		var eventLog = test_data.FlopKickLog
+
+		err = contract.UnpackLog(entity, "Kick", eventLog)
+		Expect(err).NotTo(HaveOccurred())
+
+		expectedEntity := test_data.FlopKickEntity
+		Expect(entity.Id).To(Equal(expectedEntity.Id))
+		Expect(entity.Lot).To(Equal(expectedEntity.Lot))
+		Expect(entity.Bid).To(Equal(expectedEntity.Bid))
+		Expect(entity.Gal).To(Equal(expectedEntity.Gal))
+		Expect(entity.End).To(Equal(expectedEntity.End))
+	})
+})
@@ -0,0 +1,27 @@
+// 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 flop_kick
+
+import "time"
+
+type Model struct {
+	BidId            string `db:"bid_id"`
+	Lot              string
+	Bid              string
+	Gal              string
+	End              time.Time
+	TransactionIndex uint   `db:"tx_idx"`
+	Raw              []byte `db:"raw_log"`
+}
@@ -0,0 +1,89 @@
+// 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 flop_kick
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+)
+
+type Repository interface {
+	Create(headerId int64, flopKick []Model) error
+	MissingHeaders(startingBlockNumber, endingBlockNumber int64) ([]core.Header, error)
+	MarkHeaderChecked(headerId int64) error
+}
+
+type FlopKickRepository struct {
+	DB *postgres.DB
+}
+
+func NewFlopKickRepository(db *postgres.DB) FlopKickRepository {
+	return FlopKickRepository{DB: db}
+}
+
+func (r FlopKickRepository) Create(headerId int64, flopKicks []Model) error {
+	tx, err := r.DB.Begin()
+	if err != nil {
+		return err
+	}
+	for _, flopKick := range flopKicks {
+		_, err = tx.Exec(
+			`INSERT into maker.flop_kick (header_id, bid_id, lot, bid, gal, "end", tx_idx, raw_log)
+        VALUES($1, $2, $3, $4, $5, $6, $7, $8)`,
+			headerId, flopKick.BidId, flopKick.Lot, flopKick.Bid, flopKick.Gal, flopKick.End, flopKick.TransactionIndex, flopKick.Raw,
+		)
+		if err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	_, err = tx.Exec(`INSERT INTO public.checked_headers (header_id, flop_kick_checked)
+		VALUES ($1, $2)
+	ON CONFLICT (header_id) DO
+		UPDATE SET flop_kick_checked = $2`, headerId, true)
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (r FlopKickRepository) MarkHeaderChecked(headerId int64) error {
+	_, err := r.DB.Exec(`INSERT INTO public.checked_headers (header_id, flop_kick_checked)
+		VALUES ($1, $2)
+	ON CONFLICT (header_id) DO
+		UPDATE SET flop_kick_checked = $2`, headerId, true)
+	return err
+}
+
+func (r FlopKickRepository) MissingHeaders(startingBlockNumber, endingBlockNumber int64) ([]core.Header, error) {
+	var result []core.Header
+	err := r.DB.Select(
+		&result,
+		`SELECT headers.id, headers.block_number FROM headers
+               LEFT JOIN checked_headers on headers.id = header_id
+               WHERE (header_id ISNULL OR flop_kick_checked IS FALSE)
+               AND headers.block_number >= $1
+               AND headers.block_number <= $2
+               AND headers.eth_node_fingerprint = $3`,
+		startingBlockNumber,
+		endingBlockNumber,
+		r.DB.Node.ID,
+	)
+
+	return result, err
+}
@@ -0,0 +1,200 @@
+// 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 flop_kick_test
+
+import (
+	"math/rand"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/flop_kick"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
+	"github.com/vulcanize/vulcanizedb/test_config"
+)
+
+var _ = Describe("FlopRepository", func() {
+	var db *postgres.DB
+	var repository flop_kick.FlopKickRepository
+	var headerRepository repositories.HeaderRepository
+	var headerId int64
+	var err error
+	var dbResult test_data.FlopKickDBResult
+
+	BeforeEach(func() {
+		node := test_config.NewTestNode()
+		db = test_config.NewTestDB(node)
+		test_config.CleanTestDB(db)
+		repository = flop_kick.NewFlopKickRepository(db)
+		headerRepository = repositories.NewHeaderRepository(db)
+		headerId, err = headerRepository.CreateOrUpdateHeader(core.Header{})
+		Expect(err).NotTo(HaveOccurred())
+		dbResult = test_data.FlopKickDBResult{}
+	})
+
+	Describe("Create", func() {
+		It("creates FlopKick records", func() {
+			err := repository.Create(headerId, []flop_kick.Model{test_data.FlopKickModel})
+			Expect(err).NotTo(HaveOccurred())
+
+			err = db.QueryRowx(`SELECT * FROM maker.flop_kick WHERE header_id = $1`, headerId).StructScan(&dbResult)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(dbResult.HeaderId).To(Equal(headerId))
+			Expect(dbResult.BidId).To(Equal(test_data.FlopKickModel.BidId))
+			Expect(dbResult.Lot).To(Equal(test_data.FlopKickModel.Lot))
+			Expect(dbResult.Bid).To(Equal(test_data.FlopKickModel.Bid))
+			Expect(dbResult.Gal).To(Equal(test_data.FlopKickModel.Gal))
+			Expect(dbResult.End.Equal(test_data.FlopKickModel.End)).To(BeTrue())
+			Expect(dbResult.TransactionIndex).To(Equal(test_data.FlopKickModel.TransactionIndex))
+			Expect(dbResult.Raw).To(MatchJSON(test_data.FlopKickModel.Raw))
+		})
+
+		It("marks headerId as checked for flop kick logs", func() {
+			err = repository.Create(headerId, []flop_kick.Model{test_data.FlopKickModel})
+			Expect(err).NotTo(HaveOccurred())
+
+			var headerChecked bool
+			err = db.Get(&headerChecked, `SELECT flop_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(headerChecked).To(BeTrue())
+		})
+
+		It("returns an error if inserting the flop_kick record fails", func() {
+			err = repository.Create(headerId, []flop_kick.Model{test_data.FlopKickModel})
+			Expect(err).NotTo(HaveOccurred())
+
+			err = repository.Create(headerId, []flop_kick.Model{test_data.FlopKickModel})
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("pq: duplicate key value violates unique constraint"))
+		})
+
+		It("deletes the flop_kick records if its corresponding header record is deleted", func() {
+			err = repository.Create(headerId, []flop_kick.Model{test_data.FlopKickModel})
+			Expect(err).NotTo(HaveOccurred())
+
+			var flopKickCount int
+			err = db.QueryRow(`SELECT count(*) FROM maker.flop_kick`).Scan(&flopKickCount)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(flopKickCount).To(Equal(1))
+
+			_, err = db.Exec(`DELETE FROM headers where id = $1`, headerId)
+			Expect(err).NotTo(HaveOccurred())
+
+			err = db.QueryRow(`SELECT count(*) FROM maker.flop_kick`).Scan(&flopKickCount)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(flopKickCount).To(Equal(0))
+		})
+	})
+
+	Describe("MarkedHeadersChecked", func() {
+		It("creates a row for a new headerId", func() {
+			err := repository.MarkHeaderChecked(headerId)
+
+			Expect(err).NotTo(HaveOccurred())
+			var headerChecked bool
+			err = db.Get(&headerChecked, `SELECT flop_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(headerChecked).To(BeTrue())
+		})
+
+		It("updates row when headerId already exists", func() {
+			_, err = db.Exec(`INSERT INTO public.checked_headers (header_id) VALUES ($1)`, headerId)
+			err = repository.MarkHeaderChecked(headerId)
+
+			Expect(err).NotTo(HaveOccurred())
+			var headerChecked bool
+			err = db.Get(&headerChecked, `SELECT flop_kick_checked FROM public.checked_headers WHERE header_id = $1`, headerId)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(headerChecked).To(BeTrue())
+		})
+	})
+
+	Describe("MissingHeaders", func() {
+		var flopKickBlockNumber = rand.Int63()
+		var startingBlockNumber = flopKickBlockNumber - 1
+		var endingBlockNumber = flopKickBlockNumber + 1
+		var outOfRangeBlockNumber = flopKickBlockNumber + 2
+
+		It("returns headers haven't been checked", func() {
+			var headerIds []int64
+
+			for _, number := range []int64{startingBlockNumber, flopKickBlockNumber, endingBlockNumber, outOfRangeBlockNumber} {
+				headerId, err := headerRepository.CreateOrUpdateHeader(core.Header{BlockNumber: number})
+				Expect(err).NotTo(HaveOccurred())
+				headerIds = append(headerIds, headerId)
+			}
+
+			err = repository.MarkHeaderChecked(headerIds[1])
+			Expect(err).NotTo(HaveOccurred())
+
+			headers, err := repository.MissingHeaders(startingBlockNumber, endingBlockNumber)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(headers)).To(Equal(2))
+			Expect(headers[0].BlockNumber).To(Or(Equal(startingBlockNumber), Equal(endingBlockNumber)))
+			Expect(headers[1].BlockNumber).To(Or(Equal(startingBlockNumber), Equal(endingBlockNumber)))
+		})
+
+		It("only treats headers as checked if flop_kicks have been checked", func() {
+			var headerIds []int64
+			for _, number := range []int64{startingBlockNumber, flopKickBlockNumber, endingBlockNumber, outOfRangeBlockNumber} {
+				headerId, err := headerRepository.CreateOrUpdateHeader(core.Header{BlockNumber: number})
+				Expect(err).NotTo(HaveOccurred())
+				headerIds = append(headerIds, headerId)
+			}
+
+			_, err := db.Exec(`INSERT INTO public.checked_headers (header_id) VALUES ($1)`, headerIds[1])
+			Expect(err).NotTo(HaveOccurred())
+
+			headers, err := repository.MissingHeaders(startingBlockNumber, endingBlockNumber)
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(headers)).To(Equal(3))
+			Expect(headers[0].BlockNumber).To(Or(Equal(startingBlockNumber), Equal(endingBlockNumber), Equal(flopKickBlockNumber)))
+			Expect(headers[1].BlockNumber).To(Or(Equal(startingBlockNumber), Equal(endingBlockNumber), Equal(flopKickBlockNumber)))
+			Expect(headers[2].BlockNumber).To(Or(Equal(startingBlockNumber), Equal(endingBlockNumber), Equal(flopKickBlockNumber)))
+		})
+
+		It("only returns missing headers for the current node", func() {
+			var headerIds []int64
+			node2 := core.Node{}
+			db2 := test_config.NewTestDB(node2)
+			headerRepository2 := repositories.NewHeaderRepository(db2)
+			flopKickRepository2 := flop_kick.NewFlopKickRepository(db2)
+
+			for _, number := range []int64{startingBlockNumber, flopKickBlockNumber, endingBlockNumber} {
+				headerId, err := headerRepository.CreateOrUpdateHeader(core.Header{BlockNumber: number})
+				Expect(err).NotTo(HaveOccurred())
+				headerIds = append(headerIds, headerId)
+
+				headerRepository2.CreateOrUpdateHeader(core.Header{BlockNumber: number})
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			err = repository.MarkHeaderChecked(headerIds[1])
+			Expect(err).NotTo(HaveOccurred())
+
+			node1MissingHeaders, err := repository.MissingHeaders(startingBlockNumber, endingBlockNumber)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(node1MissingHeaders)).To(Equal(2))
+
+			node2MissingHeaders, err := flopKickRepository2.MissingHeaders(startingBlockNumber, endingBlockNumber)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(node2MissingHeaders)).To(Equal(3))
+		})
+	})
+})
@@ -0,0 +1,81 @@
+// 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 flop_kick
+
+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"
+)
+
+type Transformer struct {
+	Config     shared.TransformerConfig
+	Converter  Converter
+	Fetcher    shared.LogFetcher
+	Repository Repository
+}
+
+type FlopKickTransformerInitializer struct {
+	Config shared.TransformerConfig
+}
+
+func (i FlopKickTransformerInitializer) NewFlopKickTransformer(db *postgres.DB, blockChain core.BlockChain) shared.Transformer {
+	return Transformer{
+		Config:     i.Config,
+		Converter:  FlopKickConverter{},
+		Fetcher:    shared.NewFetcher(blockChain),
+		Repository: NewFlopKickRepository(db),
+	}
+}
+
+func (t Transformer) Execute() error {
+	config := t.Config
+	headers, err := t.Repository.MissingHeaders(config.StartingBlockNumber, config.EndingBlockNumber)
+	if err != nil {
+		return err
+	}
+
+	for _, header := range headers {
+		topics := [][]common.Hash{{common.HexToHash(shared.FlopKickSignature)}}
+		matchingLogs, err := t.Fetcher.FetchLogs(config.ContractAddress, topics, header.BlockNumber)
+		if err != nil {
+			return err
+		}
+		if len(matchingLogs) < 1 {
+			err := t.Repository.MarkHeaderChecked(header.Id)
+			if err != nil {
+				return err
+			}
+		}
+
+		entities, err := t.Converter.ToEntities(config.ContractAddress, config.ContractAbi, matchingLogs)
+		if err != nil {
+			return err
+		}
+
+		models, err := t.Converter.ToModels(entities)
+		if err != nil {
+			return err
+		}
+
+		err = t.Repository.Create(header.Id, models)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
@@ -0,0 +1,246 @@
+// 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 flop_kick_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/fakes"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/flop_kick"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
+	"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data/mocks"
+	flop_kick_mocks "github.com/vulcanize/vulcanizedb/pkg/transformers/test_data/mocks/flop_kick"
+)
+
+var _ = Describe("FlopKick Transformer", func() {
+	var fetcher mocks.MockLogFetcher
+	var converter flop_kick_mocks.MockConverter
+	var repository flop_kick_mocks.MockRepository
+	var config = flop_kick.Config
+	var headerOne core.Header
+	var headerTwo core.Header
+
+	BeforeEach(func() {
+		fetcher = mocks.MockLogFetcher{}
+		converter = flop_kick_mocks.MockConverter{}
+		repository = flop_kick_mocks.MockRepository{}
+		headerOne = core.Header{Id: GinkgoRandomSeed(), BlockNumber: GinkgoRandomSeed()}
+		headerTwo = core.Header{Id: GinkgoRandomSeed(), BlockNumber: GinkgoRandomSeed()}
+	})
+
+	It("gets missing headers for specified block numbers", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+
+		err := transformer.Execute()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(repository.PassedStartingBlockNumber).To(Equal(flop_kick.Config.StartingBlockNumber))
+		Expect(repository.PassedEndingBlockNumber).To(Equal(flop_kick.Config.EndingBlockNumber))
+	})
+
+	It("returns error if getting missing headers fails", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeadersError(fakes.FakeError)
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+
+	It("fetches logs for each missing header", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{headerOne, headerTwo})
+
+		err := transformer.Execute()
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(fetcher.FetchedBlocks).To(Equal([]int64{headerOne.BlockNumber, headerTwo.BlockNumber}))
+		Expect(fetcher.FetchedContractAddress).To(Equal(flop_kick.Config.ContractAddress))
+		Expect(fetcher.FetchedTopics).To(Equal([][]common.Hash{{common.HexToHash(shared.FlopKickSignature)}}))
+	})
+
+	It("returns error if fetcher returns error", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		fetcher.SetFetcherError(fakes.FakeError)
+		repository.SetMissingHeaders([]core.Header{{}})
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+
+	It("marks header as checked even if no logs were returned", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{headerOne, headerTwo})
+		fetcher.SetFetchedLogs([]types.Log{})
+
+		err := transformer.Execute()
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(repository.CheckedHeaderIds).To(ContainElement(headerOne.Id))
+		Expect(repository.CheckedHeaderIds).To(ContainElement(headerTwo.Id))
+	})
+
+	It("returns error if marking header checked returns err", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{headerOne, headerTwo})
+		repository.SetCheckedHeaderError(fakes.FakeError)
+		fetcher.SetFetchedLogs([]types.Log{})
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+
+	It("converts matching logs to entity", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{{BlockNumber: GinkgoRandomSeed()}})
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+
+		err := transformer.Execute()
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(converter.PassedContractAddress).To(Equal(flop_kick.Config.ContractAddress))
+		Expect(converter.PassedContractABI).To(Equal(flop_kick.Config.ContractAbi))
+		Expect(converter.PassedLogs).To(Equal([]types.Log{test_data.FlopKickLog}))
+	})
+
+	It("returns an error if converting logs to entity fails", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{{BlockNumber: GinkgoRandomSeed()}})
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+		converter.SetToEntityConverterError(fakes.FakeError)
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+
+	It("converts flop_kick entity to model", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{{}})
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+
+		err := transformer.Execute()
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(converter.PassedEntities).To(Equal([]flop_kick.Entity{test_data.FlopKickEntity}))
+	})
+
+	It("returns an error if there's a failure in converting to model", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{{}})
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+		converter.SetToModelConverterError(fakes.FakeError)
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+
+	It("persists the flop_kick model", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{headerOne, headerTwo})
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+
+		err := transformer.Execute()
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(repository.CreatedHeaderIds).To(ContainElement(headerOne.Id))
+		Expect(repository.CreatedHeaderIds).To(ContainElement(headerTwo.Id))
+		Expect(repository.CreatedModels).To(ContainElement(test_data.FlopKickModel))
+	})
+
+	It("returns error if repository returns error for create", func() {
+		transformer := flop_kick.Transformer{
+			Config:     config,
+			Converter:  &converter,
+			Fetcher:    &fetcher,
+			Repository: &repository,
+		}
+		repository.SetMissingHeaders([]core.Header{{}})
+		repository.SetCreateError(fakes.FakeError)
+		fetcher.SetFetchedLogs([]types.Log{test_data.FlopKickLog})
+
+		err := transformer.Execute()
+
+		Expect(err).To(HaveOccurred())
+		Expect(err).To(MatchError(fakes.FakeError))
+	})
+})