reorganizing omni directory and beginning light watcher work

pkg/omni/full/converter/converter.go

@@ -0,0 +1,112 @@
+// VulcanizeDB
+// Copyright © 2018 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/contract"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/helpers"
+	"github.com/vulcanize/vulcanizedb/pkg/omni/shared/types"
+)
+
+// Converter is used to convert watched event logs to
+// custom logs containing event input name => value maps
+type Converter interface {
+	Convert(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error)
+	Update(info *contract.Contract)
+}
+
+type converter struct {
+	ContractInfo *contract.Contract
+}
+
+func NewConverter(info *contract.Contract) *converter {
+	return &converter{
+		ContractInfo: info,
+	}
+}
+
+func (c *converter) Update(info *contract.Contract) {
+	c.ContractInfo = info
+}
+
+// Convert the given watched event log into a types.Log for the given event
+func (c *converter) Convert(watchedEvent core.WatchedEvent, event types.Event) (*types.Log, error) {
+	contract := bind.NewBoundContract(common.HexToAddress(c.ContractInfo.Address), c.ContractInfo.ParsedAbi, nil, nil, nil)
+	values := make(map[string]interface{})
+
+	for _, field := range event.Fields {
+		var i interface{}
+		values[field.Name] = i
+	}
+
+	log := helpers.ConvertToLog(watchedEvent)
+	err := contract.UnpackLogIntoMap(values, event.Name, log)
+	if err != nil {
+		return nil, err
+	}
+
+	strValues := make(map[string]string, len(values))
+
+	for fieldName, input := range values {
+		// Postgres cannot handle custom types, resolve to strings
+		switch input.(type) {
+		case *big.Int:
+			var b *big.Int
+			b = input.(*big.Int)
+			strValues[fieldName] = b.String()
+		case common.Address:
+			var a 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)
+			strValues[fieldName] = h.String()
+		case string:
+			strValues[fieldName] = input.(string)
+		case bool:
+			strValues[fieldName] = strconv.FormatBool(input.(bool))
+		default:
+			return nil, errors.New(fmt.Sprintf("error: unhandled abi type %T", input))
+		}
+	}
+
+	// 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,
+			Tx:     watchedEvent.TxHash,
+		}
+
+		return eventLog, nil
+	}
+
+	return nil, nil
+}

pkg/omni/full/converter/converter_suite_test.go

@@ -0,0 +1,35 @@
+// VulcanizeDB
+// Copyright © 2018 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"io/ioutil"
+	"log"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestConverter(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Full Converter Suite Test")
+}
+
+var _ = BeforeSuite(func() {
+	log.SetOutput(ioutil.Discard)
+})

pkg/omni/full/converter/converter_test.go

@@ -0,0 +1,82 @@
+// VulcanizeDB
+// Copyright © 2018 Vulcanize
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package converter_test
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vulcanize/vulcanizedb/pkg/omni/full/converter"
+	"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"
+)
+
+var _ = Describe("Converter", func() {
+	var info *contract.Contract
+	var wantedEvents = []string{"Transfer"}
+	var err error
+
+	BeforeEach(func() {
+		info = 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))
+
+			info := test_helpers.SetupTusdContract([]string{}, []string{})
+			c.Update(info)
+			Expect(c.ContractInfo).To(Equal(info))
+		})
+	})
+
+	Describe("Convert", func() {
+		It("Converts a watched event log to mapping of event input names to values", func() {
+			_, ok := info.Events["Approval"]
+			Expect(ok).To(Equal(false))
+
+			event, ok := info.Events["Transfer"]
+			Expect(ok).To(Equal(true))
+			err = info.GenerateFilters()
+			Expect(err).ToNot(HaveOccurred())
+
+			c := converter.NewConverter(info)
+			log, err := c.Convert(test_helpers.MockTranferEvent, event)
+			Expect(err).ToNot(HaveOccurred())
+
+			from := common.HexToAddress("0x000000000000000000000000000000000000000000000000000000000000af21")
+			to := common.HexToAddress("0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391")
+			value := helpers.BigFromString("1097077688018008265106216665536940668749033598146")
+
+			v := log.Values["value"]
+
+			Expect(log.Values["to"]).To(Equal(to.String()))
+			Expect(log.Values["from"]).To(Equal(from.String()))
+			Expect(v).To(Equal(value.String()))
+		})
+
+		It("Fails with an empty contract", func() {
+			event := info.Events["Transfer"]
+			c := converter.NewConverter(&contract.Contract{})
+			_, err = c.Convert(test_helpers.MockTranferEvent, event)
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})