moving some memory allocation to init function rather than within

execution cycles and fixing test db tear down so that it drops
checked_headers table instead of individual columns (droping columns
only hides them, they remain in memory and continue to contribute to the
1600 column limit which causes us to eventually exceed it)

pkg/omni/light/transformer/transformer.go

@@ -49,7 +49,7 @@ type transformer struct {
 	// Processing interfaces
 	fetcher.Fetcher     // Fetches event logs, using header hashes
 	converter.Converter // Converts watched event logs into custom log
-	poller.Poller       // Polls methods using contract's token holder addresses and persists them using method datastore
+	poller.Poller       // Polls methods using arguments collected from events and persists them using a method datastore
 
 	// Ethereum network name; default "" is mainnet
 	Network string
@@ -58,15 +58,15 @@ type transformer struct {
 	Contracts map[string]*contract.Contract
 
 	// Targeted subset of events/methods
-	// Stored as map sof contract address to events/method names of interest
+	// Stored as maps of contract address to events/method names of interest
 	WatchedEvents map[string][]string // Default/empty event list means all are watched
 	WantedMethods map[string][]string // Default/empty method list means none are polled
 
-	// Block ranges to watch contracts
-	ContractRanges map[string][2]int64
+	// Starting block number for each contract
+	ContractStart map[string]int64
 
-	// Lists of addresses to filter event or method data
-	// before persisting; if empty no filter is applied
+	// Lists of argument values to filter event or
+	// method data with; if empty no filter is applied
 	EventArgs  map[string][]string
 	MethodArgs map[string][]string
 
@@ -76,13 +76,21 @@ type transformer struct {
 
 	// Method piping on/off for a contract
 	Piping map[string]bool
+
+	// Internally configured transformer variables
+	contractAddresses []string            // Holds all contract addresses, for batch fetching of logs
+	sortedEventIds    map[string][]string // Map to sort event column ids by contract, for post fetch processing and persisting of logs
+	sortedMethodIds   map[string][]string // Map to sort method column ids by contract, for post fetch method polling
+	eventIds          []string            // Holds event column ids across all contract, for batch fetching of headers
+	eventFilters      []common.Hash       // Holds topic0 hashes across all contracts, for batch fetching of logs
+	start             int64               // Hold the lowest starting block and the highest ending block
 }
 
 // Order-of-operations:
 // 1. Create new transformer
 // 2. Load contract addresses and their parameters
 // 3. Init
-// 3. Execute
+// 4. Execute
 
 // Transformer takes in config for blockchain, database, and network id
 func NewTransformer(network string, bc core.BlockChain, db *postgres.DB) *transformer {
@@ -98,12 +106,13 @@ func NewTransformer(network string, bc core.BlockChain, db *postgres.DB) *transf
 		EventRepository:  srep.NewEventRepository(db, types.LightSync),
 		WatchedEvents:    map[string][]string{},
 		WantedMethods:    map[string][]string{},
-		ContractRanges:   map[string][2]int64{},
+		ContractStart:    map[string]int64{},
 		EventArgs:        map[string][]string{},
 		MethodArgs:       map[string][]string{},
 		CreateAddrList:   map[string]bool{},
 		CreateHashList:   map[string]bool{},
 		Piping:           map[string]bool{},
+		Network:          network,
 	}
 }
 
@@ -112,6 +121,14 @@ func NewTransformer(network string, bc core.BlockChain, db *postgres.DB) *transf
 // Uses parser to pull event info from abi
 // Use this info to generate event filters
 func (tr *transformer) Init() error {
+	// Initialize internally configured transformer settings
+	tr.contractAddresses = make([]string, 0)       // Holds all contract addresses, for batch fetching of logs
+	tr.sortedEventIds = make(map[string][]string)  // Map to sort event column ids by contract, for post fetch processing and persisting of logs
+	tr.sortedMethodIds = make(map[string][]string) // Map to sort method column ids by contract, for post fetch method polling
+	tr.eventIds = make([]string, 0)                // Holds event column ids across all contract, for batch fetching of headers
+	tr.eventFilters = make([]common.Hash, 0)       // Holds topic0 hashes across all contracts, for batch fetching of logs
+	tr.start = 100000000000                        // Hold the lowest starting block and the highest ending block
+
 	// Iterate through all internal contract addresses
 	for contractAddr, subset := range tr.WatchedEvents {
 		// Get Abi
@@ -131,11 +148,8 @@ func (tr *transformer) Init() error {
 		}
 
 		// Set to specified range if it falls within the bounds
-		if firstBlock < tr.ContractRanges[contractAddr][0] {
-			firstBlock = tr.ContractRanges[contractAddr][0]
-		}
-		if lastBlock > tr.ContractRanges[contractAddr][1] && tr.ContractRanges[contractAddr][1] > firstBlock {
-			lastBlock = tr.ContractRanges[contractAddr][1]
+		if firstBlock < tr.ContractStart[contractAddr] {
+			firstBlock = tr.ContractStart[contractAddr]
 		}
 
 		// Get contract name if it has one
@@ -153,14 +167,14 @@ func (tr *transformer) Init() error {
 		}
 
 		// Aggregate info into contract object and store for execution
-		tr.Contracts[contractAddr] = contract.Contract{
+		con := contract.Contract{
 			Name:           *name,
 			Network:        tr.Network,
 			Address:        contractAddr,
 			Abi:            tr.Parser.Abi(),
 			ParsedAbi:      tr.Parser.ParsedAbi(),
 			StartingBlock:  firstBlock,
-			LastBlock:      lastBlock,
+			LastBlock:      -1,
 			Events:         tr.Parser.GetEvents(subset),
 			Methods:        tr.Parser.GetSelectMethods(tr.WantedMethods[contractAddr]),
 			FilterArgs:     eventArgs,
@@ -169,67 +183,57 @@ func (tr *transformer) Init() error {
 			CreateHashList: tr.CreateHashList[contractAddr],
 			Piping:         tr.Piping[contractAddr],
 		}.Init()
-	}
+		tr.Contracts[contractAddr] = con
+		tr.contractAddresses = append(tr.contractAddresses, con.Address)
 
-	return nil
-}
-
-func (tr *transformer) Execute() error {
-	cLen := len(tr.Contracts)
-	if cLen == 0 {
-		return errors.New("error: transformer has no initialized contracts")
-	}
-	contractAddresses := make([]string, 0, cLen)   // Holds all contract addresses, for batch fetching of logs
-	sortedEventIds := make(map[string][]string)    // Map to sort event column ids by contract, for post fetch processing and persisting of logs
-	sortedMethodIds := make(map[string][]string)   // Map to sort method column ids by contract, for post fetch method polling
-	eventIds := make([]string, 0)                  // Holds event column ids across all contract, for batch fetching of headers
-	eventFilters := make([]common.Hash, 0)         // Holds topic0 hashes across all contracts, for batch fetching of logs
-	sortedLogs := make(map[string][]gethTypes.Log) // Map to sort batch fetched logs by which contract they belong to, for post fetch processing
-	var start, end int64                           // Hold the lowest starting block and the highest ending block
-	start = 100000000000
-	end = -1
-
-	// Cycle through all contracts and extract info needed for fetching and post-processing
-	for _, con := range tr.Contracts {
-		sortedLogs[con.Address] = []gethTypes.Log{}
-		sortedEventIds[con.Address] = make([]string, 0, len(con.Events))
-		contractAddresses = append(contractAddresses, con.Address)
+		// Create checked_headers columns for each event id and append to list of all event ids
+		tr.sortedEventIds[con.Address] = make([]string, 0, len(con.Events))
 		for _, event := range con.Events {
-			// Generate eventID and use it to create a checked_header column if one does not already exist
 			eventId := strings.ToLower(event.Name + "_" + con.Address)
 			err := tr.HeaderRepository.AddCheckColumn(eventId)
 			if err != nil {
 				return err
 			}
 			// Keep track of this event id; sorted and unsorted
-			sortedEventIds[con.Address] = append(sortedEventIds[con.Address], eventId)
-			eventIds = append(eventIds, eventId)
+			tr.sortedEventIds[con.Address] = append(tr.sortedEventIds[con.Address], eventId)
+			tr.eventIds = append(tr.eventIds, eventId)
 			// Append this event sig to the filters
-			eventFilters = append(eventFilters, event.Sig())
+			tr.eventFilters = append(tr.eventFilters, event.Sig())
 		}
 
-		// Create checked_headers columns for each method id and generate list of all method ids
-		sortedMethodIds[con.Address] = make([]string, 0, len(con.Methods))
+		// Create checked_headers columns for each method id and append list of all method ids
+		tr.sortedMethodIds[con.Address] = make([]string, 0, len(con.Methods))
 		for _, m := range con.Methods {
 			methodId := strings.ToLower(m.Name + "_" + con.Address)
 			err := tr.HeaderRepository.AddCheckColumn(methodId)
 			if err != nil {
 				return err
 			}
-			sortedMethodIds[con.Address] = append(sortedMethodIds[con.Address], methodId)
+			tr.sortedMethodIds[con.Address] = append(tr.sortedMethodIds[con.Address], methodId)
 		}
 
-		// Update start to the lowest block and end to the highest block
-		if con.StartingBlock < start {
-			start = con.StartingBlock
-		}
-		if con.LastBlock > end {
-			end = con.LastBlock
+		// Update start to the lowest block
+		if con.StartingBlock < tr.start {
+			tr.start = con.StartingBlock
 		}
 	}
 
+	return nil
+}
+
+func (tr *transformer) Execute() error {
+	if len(tr.Contracts) == 0 {
+		return errors.New("error: transformer has no initialized contracts")
+	}
+
+	// Map to sort batch fetched logs by which contract they belong to, for post fetch processing
+	sortedLogs := make(map[string][]gethTypes.Log)
+	for _, con := range tr.Contracts {
+		sortedLogs[con.Address] = []gethTypes.Log{}
+	}
+
 	// Find unchecked headers for all events across all contracts; these are returned in asc order
-	missingHeaders, err := tr.HeaderRepository.MissingHeadersForAll(start, end, eventIds)
+	missingHeaders, err := tr.HeaderRepository.MissingHeadersForAll(tr.start, -1, tr.eventIds)
 	if err != nil {
 		return err
 	}
@@ -237,37 +241,45 @@ func (tr *transformer) Execute() error {
 	// Iterate over headers
 	for _, header := range missingHeaders {
 		// And fetch all event logs across contracts at this header
-		allLogs, err := tr.Fetcher.FetchLogs(contractAddresses, eventFilters, header)
+		allLogs, err := tr.Fetcher.FetchLogs(tr.contractAddresses, tr.eventFilters, header)
 		if err != nil {
 			return err
 		}
 
-		// Mark the header checked for all of these eventIDs and continue to method polling and then the next iteration if no logs are found
+		// If no logs are found mark the header checked for all of these eventIDs
+		// and continue to method polling and onto the next iteration
 		if len(allLogs) < 1 {
-			err = tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, eventIds)
+			err = tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, tr.eventIds)
 			if err != nil {
 				return err
 			}
-			goto Polling
+			err = tr.methodPolling(header, tr.sortedMethodIds)
+			if err != nil {
+				return err
+			}
+			continue
 		}
 
 		// Sort logs by the contract they belong to
 		for _, log := range allLogs {
-			sortedLogs[log.Address.Hex()] = append(sortedLogs[log.Address.Hex()], log)
+			addr := strings.ToLower(log.Address.Hex())
+			sortedLogs[addr] = append(sortedLogs[addr], log)
 		}
 
 		// Process logs for each contract
 		for conAddr, logs := range sortedLogs {
+			if logs == nil {
+				continue
+			}
 			// Configure converter with this contract
 			con := tr.Contracts[conAddr]
 			tr.Converter.Update(con)
 
-			// Convert logs into batches of log mappings (event => []types.Log)
+			// Convert logs into batches of log mappings (eventName => []types.Logs
 			convertedLogs, err := tr.Converter.ConvertBatch(logs, con.Events, header.Id)
 			if err != nil {
 				return err
 			}
-
 			// Cycle through each type of event log and persist them
 			for eventName, logs := range convertedLogs {
 				// If logs for this event are empty, mark them checked at this header and continue
@@ -288,9 +300,8 @@ func (tr *transformer) Execute() error {
 			}
 		}
 
-	Polling:
 		// Poll contracts at this block height
-		err = tr.pollContracts(header, sortedMethodIds)
+		err = tr.methodPolling(header, tr.sortedMethodIds)
 		if err != nil {
 			return err
 		}
@@ -300,7 +311,7 @@ func (tr *transformer) Execute() error {
 }
 
 // Used to poll contract methods at a given header
-func (tr *transformer) pollContracts(header core.Header, sortedMethodIds map[string][]string) error {
+func (tr *transformer) methodPolling(header core.Header, sortedMethodIds map[string][]string) error {
 	for _, con := range tr.Contracts {
 		// Skip method polling processes if no methods are specified
 		// Also don't try to poll methods below this contract's specified starting block
@@ -326,40 +337,40 @@ func (tr *transformer) pollContracts(header core.Header, sortedMethodIds map[str
 
 // Used to set which contract addresses and which of their events to watch
 func (tr *transformer) SetEvents(contractAddr string, filterSet []string) {
-	tr.WatchedEvents[contractAddr] = filterSet
+	tr.WatchedEvents[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set subset of account addresses to watch events for
 func (tr *transformer) SetEventArgs(contractAddr string, filterSet []string) {
-	tr.EventArgs[contractAddr] = filterSet
+	tr.EventArgs[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set which contract addresses and which of their methods to call
 func (tr *transformer) SetMethods(contractAddr string, filterSet []string) {
-	tr.WantedMethods[contractAddr] = filterSet
+	tr.WantedMethods[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set subset of account addresses to poll methods on
 func (tr *transformer) SetMethodArgs(contractAddr string, filterSet []string) {
-	tr.MethodArgs[contractAddr] = filterSet
+	tr.MethodArgs[strings.ToLower(contractAddr)] = filterSet
 }
 
 // Used to set the block range to watch for a given address
-func (tr *transformer) SetRange(contractAddr string, rng [2]int64) {
-	tr.ContractRanges[contractAddr] = rng
+func (tr *transformer) SetStartingBlock(contractAddr string, start int64) {
+	tr.ContractStart[strings.ToLower(contractAddr)] = start
 }
 
 // Used to set whether or not to persist an account address list
 func (tr *transformer) SetCreateAddrList(contractAddr string, on bool) {
-	tr.CreateAddrList[contractAddr] = on
+	tr.CreateAddrList[strings.ToLower(contractAddr)] = on
 }
 
 // Used to set whether or not to persist an hash list
 func (tr *transformer) SetCreateHashList(contractAddr string, on bool) {
-	tr.CreateHashList[contractAddr] = on
+	tr.CreateHashList[strings.ToLower(contractAddr)] = on
 }
 
 // Used to turn method piping on for a contract
 func (tr *transformer) SetPiping(contractAddr string, on bool) {
-	tr.Piping[contractAddr] = on
+	tr.Piping[strings.ToLower(contractAddr)] = on
 }

pkg/omni/light/transformer/transformer_test.go

@@ -18,6 +18,7 @@ package transformer_test
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
 	. "github.com/onsi/ginkgo"
@@ -38,6 +39,8 @@ var _ = Describe("Transformer", func() {
 	var blockChain core.BlockChain
 	var headerRepository repositories.HeaderRepository
 	var headerID, headerID2 int64
+	var ensAddr = strings.ToLower(constants.EnsContractAddress)
+	var tusdAddr = strings.ToLower(constants.TusdContractAddress)
 
 	BeforeEach(func() {
 		db, blockChain = test_helpers.SetupDBandBC()
@@ -53,7 +56,7 @@ var _ = Describe("Transformer", func() {
 			watchedEvents := []string{"Transfer", "Mint"}
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetEvents(constants.TusdContractAddress, watchedEvents)
-			Expect(t.WatchedEvents[constants.TusdContractAddress]).To(Equal(watchedEvents))
+			Expect(t.WatchedEvents[tusdAddr]).To(Equal(watchedEvents))
 		})
 	})
 
@@ -62,7 +65,7 @@ var _ = Describe("Transformer", func() {
 			eventAddrs := []string{"test1", "test2"}
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetEventArgs(constants.TusdContractAddress, eventAddrs)
-			Expect(t.EventArgs[constants.TusdContractAddress]).To(Equal(eventAddrs))
+			Expect(t.EventArgs[tusdAddr]).To(Equal(eventAddrs))
 		})
 	})
 
@@ -71,7 +74,7 @@ var _ = Describe("Transformer", func() {
 			watchedMethods := []string{"balanceOf", "totalSupply"}
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetMethods(constants.TusdContractAddress, watchedMethods)
-			Expect(t.WantedMethods[constants.TusdContractAddress]).To(Equal(watchedMethods))
+			Expect(t.WantedMethods[tusdAddr]).To(Equal(watchedMethods))
 		})
 	})
 
@@ -80,16 +83,15 @@ var _ = Describe("Transformer", func() {
 			methodAddrs := []string{"test1", "test2"}
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetMethodArgs(constants.TusdContractAddress, methodAddrs)
-			Expect(t.MethodArgs[constants.TusdContractAddress]).To(Equal(methodAddrs))
+			Expect(t.MethodArgs[tusdAddr]).To(Equal(methodAddrs))
 		})
 	})
 
-	Describe("SetRange", func() {
+	Describe("SetStartingBlock", func() {
 		It("Sets the block range that the contract should be watched within", func() {
-			rng := [2]int64{1, 100000}
 			t := transformer.NewTransformer("", blockChain, db)
-			t.SetRange(constants.TusdContractAddress, rng)
-			Expect(t.ContractRanges[constants.TusdContractAddress]).To(Equal(rng))
+			t.SetStartingBlock(constants.TusdContractAddress, 11)
+			Expect(t.ContractStart[tusdAddr]).To(Equal(int64(11)))
 		})
 	})
 
@@ -97,7 +99,7 @@ var _ = Describe("Transformer", func() {
 		It("Sets the block range that the contract should be watched within", func() {
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetCreateAddrList(constants.TusdContractAddress, true)
-			Expect(t.CreateAddrList[constants.TusdContractAddress]).To(Equal(true))
+			Expect(t.CreateAddrList[tusdAddr]).To(Equal(true))
 		})
 	})
 
@@ -105,7 +107,7 @@ var _ = Describe("Transformer", func() {
 		It("Sets the block range that the contract should be watched within", func() {
 			t := transformer.NewTransformer("", blockChain, db)
 			t.SetCreateHashList(constants.TusdContractAddress, true)
-			Expect(t.CreateHashList[constants.TusdContractAddress]).To(Equal(true))
+			Expect(t.CreateHashList[tusdAddr]).To(Equal(true))
 		})
 	})
 
@@ -118,14 +120,14 @@ var _ = Describe("Transformer", func() {
 			err = t.Init()
 			Expect(err).ToNot(HaveOccurred())
 
-			c, ok := t.Contracts[constants.TusdContractAddress]
+			c, ok := t.Contracts[tusdAddr]
 			Expect(ok).To(Equal(true))
 
 			Expect(c.StartingBlock).To(Equal(int64(6194632)))
-			Expect(c.LastBlock).To(Equal(int64(6194634)))
+			Expect(c.LastBlock).To(Equal(int64(-1)))
 			Expect(c.Abi).To(Equal(constants.TusdAbiString))
 			Expect(c.Name).To(Equal("TrueUSD"))
-			Expect(c.Address).To(Equal(constants.TusdContractAddress))
+			Expect(c.Address).To(Equal(tusdAddr))
 		})
 
 		It("Fails to initialize if first and most recent block numbers cannot be fetched from vDB headers table", func() {
@@ -142,7 +144,7 @@ var _ = Describe("Transformer", func() {
 			err = t.Init()
 			Expect(err).ToNot(HaveOccurred())
 
-			_, ok := t.Contracts[constants.TusdContractAddress]
+			_, ok := t.Contracts[tusdAddr]
 			Expect(ok).To(Equal(false))
 		})
 	})
@@ -171,7 +173,7 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			log := test_helpers.LightTransferLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", constants.TusdContractAddress)).StructScan(&log)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", tusdAddr)).StructScan(&log)
 			Expect(err).ToNot(HaveOccurred())
 			// We don't know vulcID, so compare individual fields instead of complete structures
 			Expect(log.HeaderID).To(Equal(headerID))
@@ -186,7 +188,7 @@ var _ = Describe("Transformer", func() {
 			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
 			err = t.Init()
 			Expect(err).ToNot(HaveOccurred())
-			c, ok := t.Contracts[constants.TusdContractAddress]
+			c, ok := t.Contracts[tusdAddr]
 			Expect(ok).To(Equal(true))
 			err = t.Execute()
 			Expect(err).ToNot(HaveOccurred())
@@ -232,12 +234,12 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			res := test_helpers.BalanceOf{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", constants.TusdContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", tusdAddr)).StructScan(&res)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(res.Balance).To(Equal("55849938025000000000000"))
 			Expect(res.TokenName).To(Equal("TrueUSD"))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", constants.TusdContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", tusdAddr)).StructScan(&res)
 			Expect(err).To(HaveOccurred())
 		})
 
@@ -274,7 +276,7 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			log := test_helpers.LightNewOwnerLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", constants.EnsContractAddress)).StructScan(&log)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&log)
 			Expect(err).ToNot(HaveOccurred())
 			// We don't know vulcID, so compare individual fields instead of complete structures
 			Expect(log.HeaderID).To(Equal(headerID))
@@ -289,7 +291,7 @@ var _ = Describe("Transformer", func() {
 			t.SetMethods(constants.EnsContractAddress, []string{"owner"})
 			err = t.Init()
 			Expect(err).ToNot(HaveOccurred())
-			c, ok := t.Contracts[constants.EnsContractAddress]
+			c, ok := t.Contracts[ensAddr]
 			Expect(ok).To(Equal(true))
 			err = t.Execute()
 			Expect(err).ToNot(HaveOccurred())
@@ -319,17 +321,17 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			res := test_helpers.Owner{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&res)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(res.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
 			Expect(res.TokenName).To(Equal(""))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&res)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(res.Address).To(Equal("0x0000000000000000000000000000000000000000"))
 			Expect(res.TokenName).To(Equal(""))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ceMADEUPaaf4HASHc186badTHIS288IS625bFAKE' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ceMADEUPaaf4HASHc186badTHIS288IS625bFAKE' AND block = '6885696'", ensAddr)).StructScan(&res)
 			Expect(err).To(HaveOccurred())
 		})
 
@@ -344,7 +346,7 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			log := test_helpers.LightNewOwnerLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", constants.EnsContractAddress)).StructScan(&log)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&log)
 			Expect(err).To(HaveOccurred())
 		})
 
@@ -359,12 +361,12 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			res := test_helpers.Owner{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&res)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(res.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
 			Expect(res.TokenName).To(Equal(""))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&res)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&res)
 			Expect(err).To(HaveOccurred())
 		})
 	})
@@ -405,7 +407,7 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			newOwnerLog := test_helpers.LightNewOwnerLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", constants.EnsContractAddress)).StructScan(&newOwnerLog)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.newowner_event", ensAddr)).StructScan(&newOwnerLog)
 			Expect(err).ToNot(HaveOccurred())
 			// We don't know vulcID, so compare individual fields instead of complete structures
 			Expect(newOwnerLog.HeaderID).To(Equal(headerID2))
@@ -414,7 +416,7 @@ var _ = Describe("Transformer", func() {
 			Expect(newOwnerLog.Owner).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
 
 			transferLog := test_helpers.LightTransferLog{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", constants.TusdContractAddress)).StructScan(&transferLog)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.transfer_event", tusdAddr)).StructScan(&transferLog)
 			Expect(err).ToNot(HaveOccurred())
 			// We don't know vulcID, so compare individual fields instead of complete structures
 			Expect(transferLog.HeaderID).To(Equal(headerID))
@@ -431,9 +433,9 @@ var _ = Describe("Transformer", func() {
 			t.SetMethods(constants.TusdContractAddress, []string{"balanceOf"})
 			err = t.Init()
 			Expect(err).ToNot(HaveOccurred())
-			ens, ok := t.Contracts[constants.EnsContractAddress]
+			ens, ok := t.Contracts[ensAddr]
 			Expect(ok).To(Equal(true))
-			tusd, ok := t.Contracts[constants.TusdContractAddress]
+			tusd, ok := t.Contracts[tusdAddr]
 			Expect(ok).To(Equal(true))
 			err = t.Execute()
 			Expect(err).ToNot(HaveOccurred())
@@ -479,26 +481,26 @@ var _ = Describe("Transformer", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			owner := test_helpers.Owner{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&owner)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae' AND block = '6885696'", ensAddr)).StructScan(&owner)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(owner.Address).To(Equal("0x6090A6e47849629b7245Dfa1Ca21D94cd15878Ef"))
 			Expect(owner.TokenName).To(Equal(""))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&owner)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ce695797aaf402b1c186bad9eca28842625b5047' AND block = '6885696'", ensAddr)).StructScan(&owner)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(owner.Address).To(Equal("0x0000000000000000000000000000000000000000"))
 			Expect(owner.TokenName).To(Equal(""))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ceMADEUPaaf4HASHc186badTHIS288IS625bFAKE' AND block = '6885696'", constants.EnsContractAddress)).StructScan(&owner)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.owner_method WHERE node_ = '0x95832c7a47ff8a7840e28b78ceMADEUPaaf4HASHc186badTHIS288IS625bFAKE' AND block = '6885696'", ensAddr)).StructScan(&owner)
 			Expect(err).To(HaveOccurred())
 
 			bal := test_helpers.BalanceOf{}
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", constants.TusdContractAddress)).StructScan(&bal)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x1062a747393198f70F71ec65A582423Dba7E5Ab3' AND block = '6791669'", tusdAddr)).StructScan(&bal)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(bal.Balance).To(Equal("55849938025000000000000"))
 			Expect(bal.TokenName).To(Equal("TrueUSD"))
 
-			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", constants.TusdContractAddress)).StructScan(&bal)
+			err = db.QueryRowx(fmt.Sprintf("SELECT * FROM light_%s.balanceof_method WHERE who_ = '0x09BbBBE21a5975cAc061D82f7b843b1234567890' AND block = '6791669'", tusdAddr)).StructScan(&bal)
 			Expect(err).To(HaveOccurred())
 		})
 	})