finishing porting omni watcher to work with light sync; split into full, light,

and shared directories and refactor as much into shared; finish
lightSync omni watcher tests

pkg/omni/full/converter/converter.go

@@ -74,22 +74,25 @@ func (c *converter) Convert(watchedEvent core.WatchedEvent, event types.Event) (
 		// Postgres cannot handle custom types, resolve to strings
 		switch input.(type) {
 		case *big.Int:
-			var b *big.Int
-			b = input.(*big.Int)
+			b := input.(*big.Int)
 			strValues[fieldName] = b.String()
 		case common.Address:
-			var a common.Address
-			a = input.(common.Address)
+			a := input.(common.Address)
 			strValues[fieldName] = a.String()
 			c.ContractInfo.AddTokenHolderAddress(a.String()) // cache address in a list of contract's token holder addresses
 		case common.Hash:
-			var h common.Hash
-			h = input.(common.Hash)
+			h := input.(common.Hash)
 			strValues[fieldName] = h.String()
 		case string:
 			strValues[fieldName] = input.(string)
 		case bool:
 			strValues[fieldName] = strconv.FormatBool(input.(bool))
+		case []byte:
+			b := input.([]byte)
+			strValues[fieldName] = string(b)
+		case byte:
+			b := input.(byte)
+			strValues[fieldName] = string(b)
 		default:
 			return nil, errors.New(fmt.Sprintf("error: unhandled abi type %T", input))
 		}
@@ -98,7 +101,6 @@ func (c *converter) Convert(watchedEvent core.WatchedEvent, event types.Event) (
 	// Only hold onto logs that pass our address filter, if any
 	if c.ContractInfo.PassesEventFilter(strValues) {
 		eventLog := &types.Log{
-			Event:  event,
 			Id:     watchedEvent.LogID,
 			Values: strValues,
 			Block:  watchedEvent.BlockNumber,

pkg/omni/full/converter/converter_test.go

@@ -25,40 +25,41 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/contract"
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers"
 	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers/test_helpers/mocks"
 )
 
 var _ = Describe("Converter", func() {
-	var info *contract.Contract
+	var con *contract.Contract
 	var wantedEvents = []string{"Transfer"}
 	var err error
 
 	BeforeEach(func() {
-		info = test_helpers.SetupTusdContract(wantedEvents, []string{})
+		con = test_helpers.SetupTusdContract(wantedEvents, []string{})
 	})
 
 	Describe("Update", func() {
-		It("Updates contract info held by the converter", func() {
-			c := converter.NewConverter(info)
-			Expect(c.ContractInfo).To(Equal(info))
+		It("Updates contract con held by the converter", func() {
+			c := converter.NewConverter(con)
+			Expect(c.ContractInfo).To(Equal(con))
 
-			info := test_helpers.SetupTusdContract([]string{}, []string{})
-			c.Update(info)
-			Expect(c.ContractInfo).To(Equal(info))
+			con := test_helpers.SetupTusdContract([]string{}, []string{})
+			c.Update(con)
+			Expect(c.ContractInfo).To(Equal(con))
 		})
 	})
 
 	Describe("Convert", func() {
 		It("Converts a watched event log to mapping of event input names to values", func() {
-			_, ok := info.Events["Approval"]
+			_, ok := con.Events["Approval"]
 			Expect(ok).To(Equal(false))
 
-			event, ok := info.Events["Transfer"]
+			event, ok := con.Events["Transfer"]
 			Expect(ok).To(Equal(true))
-			err = info.GenerateFilters()
+			err = con.GenerateFilters()
 			Expect(err).ToNot(HaveOccurred())
 
-			c := converter.NewConverter(info)
-			log, err := c.Convert(test_helpers.MockTranferEvent, event)
+			c := converter.NewConverter(con)
+			log, err := c.Convert(mocks.MockTranferEvent, event)
 			Expect(err).ToNot(HaveOccurred())
 
 			from := common.HexToAddress("0x000000000000000000000000000000000000000000000000000000000000af21")
@@ -72,10 +73,36 @@ var _ = Describe("Converter", func() {
 			Expect(v).To(Equal(value.String()))
 		})
 
+		It("Keeps track of addresses it sees to grow a token holder address list for the contract", func() {
+			event, ok := con.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+
+			c := converter.NewConverter(con)
+			_, err := c.Convert(mocks.MockTranferEvent, event)
+			Expect(err).ToNot(HaveOccurred())
+
+			b, ok := con.TknHolderAddrs["0x000000000000000000000000000000000000Af21"]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			b, ok = con.TknHolderAddrs["0x09BbBBE21a5975cAc061D82f7b843bCE061BA391"]
+			Expect(ok).To(Equal(true))
+			Expect(b).To(Equal(true))
+
+			_, ok = con.TknHolderAddrs["0x"]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.TknHolderAddrs[""]
+			Expect(ok).To(Equal(false))
+
+			_, ok = con.TknHolderAddrs["0x09THISE21a5IS5cFAKE1D82fAND43bCE06MADEUP"]
+			Expect(ok).To(Equal(false))
+		})
+
 		It("Fails with an empty contract", func() {
-			event := info.Events["Transfer"]
+			event := con.Events["Transfer"]
 			c := converter.NewConverter(&contract.Contract{})
-			_, err = c.Convert(test_helpers.MockTranferEvent, event)
+			_, err = c.Convert(mocks.MockTranferEvent, event)
 			Expect(err).To(HaveOccurred())
 		})
 	})