minor refactor; fix error shadowing

pkg/eth/api.go

@@ -39,6 +39,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"github.com/vulcanize/ipld-eth-indexer/pkg/eth"
+	"github.com/vulcanize/ipld-eth-indexer/pkg/ipfs"
 	"github.com/vulcanize/ipld-eth-server/pkg/shared"
 )
 
@@ -540,36 +541,13 @@ func (pea *PublicEthAPI) localGetLogs(crit filters.FilterCriteria) ([]*types.Log
 		Topics:       topicStrSets,
 	}
 
-	// Begin tx
-	tx, err := pea.B.DB.Beginx()
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if p := recover(); p != nil {
-			shared.Rollback(tx)
-			panic(p)
-		} else if err != nil {
-			shared.Rollback(tx)
-		} else {
-			err = tx.Commit()
-		}
-	}()
-
 	// If we have a blockhash to filter on, fire off single retrieval query
 	if crit.BlockHash != nil {
-		rctCIDs, err := pea.B.Retriever.RetrieveRctCIDs(tx, filter, 0, crit.BlockHash, nil)
+		blocks, topics, err := pea.getLogsForBlockHash(filter, crit.BlockHash)
 		if err != nil {
 			return nil, err
 		}
-		rctIPLDs, err := pea.B.Fetcher.FetchRcts(tx, rctCIDs)
+		return extractLogsOfInterest(blocks, topics)
-		if err != nil {
-			return nil, err
-		}
-		if err := tx.Commit(); err != nil {
-			return nil, err
-		}
-		return extractLogsOfInterest(rctIPLDs, filter.Topics)
 	}
 	// Otherwise, create block range from criteria
 	// nil values are filled in; to request a single block have both ToBlock and FromBlock equal that number
@@ -587,23 +565,69 @@ func (pea *PublicEthAPI) localGetLogs(crit filters.FilterCriteria) ([]*types.Log
 	}
 	start := startingBlock.Int64()
 	end := endingBlock.Int64()
-	allRctCIDs := make([]eth.ReceiptModel, 0)
+	blocks, topics, err := pea.getLogsForBlockRange(filter, start, end)
-	for i := start; i <= end; i++ {
-		rctCIDs, err := pea.B.Retriever.RetrieveRctCIDs(tx, filter, i, nil, nil)
-		if err != nil {
-			return nil, err
-		}
-		allRctCIDs = append(allRctCIDs, rctCIDs...)
-	}
-	rctIPLDs, err := pea.B.Fetcher.FetchRcts(tx, allRctCIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := tx.Commit(); err != nil {
+	return extractLogsOfInterest(blocks, topics)
-		return nil, err
+}
+
+func (pea *PublicEthAPI) getLogsForBlockRange(filter ReceiptFilter, start, end int64) ([]ipfs.BlockModel, [][]string, error) {
+	tx, err := pea.B.DB.Beginx()
+	if err != nil {
+		return nil, nil, err
 	}
-	logs, err := extractLogsOfInterest(rctIPLDs, filter.Topics)
+	defer func() {
-	return logs, err // need to return err variable so that we return the err = tx.Commit() assignment in the defer
+		if p := recover(); p != nil {
+			shared.Rollback(tx)
+			panic(p)
+		} else if err != nil {
+			shared.Rollback(tx)
+		} else {
+			err = tx.Commit()
+		}
+	}()
+
+	allRctCIDs := make([]eth.ReceiptModel, 0)
+	for i := start; i <= end; i++ {
+		var rctCIDs []eth.ReceiptModel
+		rctCIDs, err = pea.B.Retriever.RetrieveRctCIDs(tx, filter, i, nil, nil)
+		if err != nil {
+			return nil, nil, err
+		}
+		allRctCIDs = append(allRctCIDs, rctCIDs...)
+	}
+	var rctIPLDs []ipfs.BlockModel
+	rctIPLDs, err = pea.B.Fetcher.FetchRcts(tx, allRctCIDs)
+
+	return rctIPLDs, filter.Topics, err
+}
+
+func (pea *PublicEthAPI) getLogsForBlockHash(filter ReceiptFilter, blockHash *common.Hash) ([]ipfs.BlockModel, [][]string, error) {
+	tx, err := pea.B.DB.Beginx()
+	if err != nil {
+		return nil, nil, err
+	}
+	defer func() {
+		if p := recover(); p != nil {
+			shared.Rollback(tx)
+			panic(p)
+		} else if err != nil {
+			shared.Rollback(tx)
+		} else {
+			err = tx.Commit()
+		}
+	}()
+
+	var rctCIDs []eth.ReceiptModel
+	rctCIDs, err = pea.B.Retriever.RetrieveRctCIDs(tx, filter, 0, blockHash, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	var rctIPLDs []ipfs.BlockModel
+	rctIPLDs, err = pea.B.Fetcher.FetchRcts(tx, rctCIDs)
+
+	return rctIPLDs, filter.Topics, err
 }
 
 /*

pkg/eth/backend.go

@@ -41,6 +41,7 @@ import (
 	"github.com/ethereum/go-ethereum/trie"
 
 	"github.com/vulcanize/ipfs-ethdb"
+	"github.com/vulcanize/ipld-eth-indexer/pkg/ipfs"
 	"github.com/vulcanize/ipld-eth-indexer/pkg/postgres"
 	shared2 "github.com/vulcanize/ipld-eth-indexer/pkg/shared"
 
@@ -281,49 +282,57 @@ func (b *Backend) BlockByNumber(ctx context.Context, blockNumber rpc.BlockNumber
 	}()
 
 	// Fetch and decode the header IPLD
-	headerIPLD, err := b.Fetcher.FetchHeader(tx, headerCID)
+	var headerIPLD ipfs.BlockModel
+	headerIPLD, err = b.Fetcher.FetchHeader(tx, headerCID)
 	if err != nil {
 		return nil, err
 	}
 	var header types.Header
-	if err := rlp.DecodeBytes(headerIPLD.Data, &header); err != nil {
+	err = rlp.DecodeBytes(headerIPLD.Data, &header)
+	if err != nil {
 		return nil, err
 	}
 	// Fetch and decode the uncle IPLDs
-	uncleIPLDs, err := b.Fetcher.FetchUncles(tx, uncleCIDs)
+	var uncleIPLDs []ipfs.BlockModel
+	uncleIPLDs, err = b.Fetcher.FetchUncles(tx, uncleCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var uncles []*types.Header
 	for _, uncleIPLD := range uncleIPLDs {
 		var uncle types.Header
-		if err := rlp.DecodeBytes(uncleIPLD.Data, &uncle); err != nil {
+		err = rlp.DecodeBytes(uncleIPLD.Data, &uncle)
+		if err != nil {
 			return nil, err
 		}
 		uncles = append(uncles, &uncle)
 	}
 	// Fetch and decode the transaction IPLDs
-	txIPLDs, err := b.Fetcher.FetchTrxs(tx, txCIDs)
+	var txIPLDs []ipfs.BlockModel
+	txIPLDs, err = b.Fetcher.FetchTrxs(tx, txCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var transactions []*types.Transaction
 	for _, txIPLD := range txIPLDs {
 		var transaction types.Transaction
-		if err := rlp.DecodeBytes(txIPLD.Data, &transaction); err != nil {
+		err = rlp.DecodeBytes(txIPLD.Data, &transaction)
+		if err != nil {
 			return nil, err
 		}
 		transactions = append(transactions, &transaction)
 	}
 	// Fetch and decode the receipt IPLDs
-	rctIPLDs, err := b.Fetcher.FetchRcts(tx, rctCIDs)
+	var rctIPLDs []ipfs.BlockModel
+	rctIPLDs, err = b.Fetcher.FetchRcts(tx, rctCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var receipts []*types.Receipt
 	for _, rctIPLD := range rctIPLDs {
 		var receipt types.Receipt
-		if err := rlp.DecodeBytes(rctIPLD.Data, &receipt); err != nil {
+		err = rlp.DecodeBytes(rctIPLD.Data, &receipt)
+		if err != nil {
 			return nil, err
 		}
 		receipts = append(receipts, &receipt)
@@ -358,49 +367,57 @@ func (b *Backend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Blo
 	}()
 
 	// Fetch and decode the header IPLD
-	headerIPLD, err := b.Fetcher.FetchHeader(tx, headerCID)
+	var headerIPLD ipfs.BlockModel
+	headerIPLD, err = b.Fetcher.FetchHeader(tx, headerCID)
 	if err != nil {
 		return nil, err
 	}
 	var header types.Header
-	if err := rlp.DecodeBytes(headerIPLD.Data, &header); err != nil {
+	err = rlp.DecodeBytes(headerIPLD.Data, &header)
+	if err != nil {
 		return nil, err
 	}
 	// Fetch and decode the uncle IPLDs
-	uncleIPLDs, err := b.Fetcher.FetchUncles(tx, uncleCIDs)
+	var uncleIPLDs []ipfs.BlockModel
+	uncleIPLDs, err = b.Fetcher.FetchUncles(tx, uncleCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var uncles []*types.Header
 	for _, uncleIPLD := range uncleIPLDs {
 		var uncle types.Header
-		if err := rlp.DecodeBytes(uncleIPLD.Data, &uncle); err != nil {
+		err = rlp.DecodeBytes(uncleIPLD.Data, &uncle)
+		if err != nil {
 			return nil, err
 		}
 		uncles = append(uncles, &uncle)
 	}
 	// Fetch and decode the transaction IPLDs
-	txIPLDs, err := b.Fetcher.FetchTrxs(tx, txCIDs)
+	var txIPLDs []ipfs.BlockModel
+	txIPLDs, err = b.Fetcher.FetchTrxs(tx, txCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var transactions []*types.Transaction
 	for _, txIPLD := range txIPLDs {
 		var transaction types.Transaction
-		if err := rlp.DecodeBytes(txIPLD.Data, &transaction); err != nil {
+		err = rlp.DecodeBytes(txIPLD.Data, &transaction)
+		if err != nil {
 			return nil, err
 		}
 		transactions = append(transactions, &transaction)
 	}
 	// Fetch and decode the receipt IPLDs
-	rctIPLDs, err := b.Fetcher.FetchRcts(tx, rctCIDs)
+	var rctIPLDs []ipfs.BlockModel
+	rctIPLDs, err = b.Fetcher.FetchRcts(tx, rctCIDs)
 	if err != nil {
 		return nil, err
 	}
 	var receipts []*types.Receipt
 	for _, rctIPLD := range rctIPLDs {
 		var receipt types.Receipt
-		if err := rlp.DecodeBytes(rctIPLD.Data, &receipt); err != nil {
+		err = rlp.DecodeBytes(rctIPLD.Data, &receipt)
+		if err != nil {
 			return nil, err
 		}
 		receipts = append(receipts, &receipt)
@@ -599,10 +616,12 @@ func (b *Backend) GetCodeByHash(ctx context.Context, address common.Address, has
 			err = tx.Commit()
 		}
 	}()
-	if err := tx.Get(&codeHash, RetrieveCodeHashByLeafKeyAndBlockHash, leafKey.Hex(), hash.Hex()); err != nil {
+	err = tx.Get(&codeHash, RetrieveCodeHashByLeafKeyAndBlockHash, leafKey.Hex(), hash.Hex())
+	if err != nil {
 		return nil, err
 	}
-	mhKey, err := shared2.MultihashKeyFromKeccak256(common.BytesToHash(codeHash))
+	var mhKey string
+	mhKey, err = shared2.MultihashKeyFromKeccak256(common.BytesToHash(codeHash))
 	if err != nil {
 		return nil, err
 	}

pkg/eth/cid_retriever.go

@@ -86,7 +86,8 @@ func (ecr *CIDRetriever) Retrieve(filter SubscriptionSettings, blockNumber int64
 	}()
 
 	// Retrieve cached header CIDs at this block height
-	headers, err := ecr.RetrieveHeaderCIDs(tx, blockNumber)
+	var headers []eth.HeaderModel
+	headers, err = ecr.RetrieveHeaderCIDs(tx, blockNumber)
 	if err != nil {
 		log.Error("header cid retrieval error")
 		return nil, true, err
@@ -101,7 +102,8 @@ func (ecr *CIDRetriever) Retrieve(filter SubscriptionSettings, blockNumber int64
 			empty = false
 			if filter.HeaderFilter.Uncles {
 				// Retrieve uncle cids for this header id
-				uncleCIDs, err := ecr.RetrieveUncleCIDsByHeaderID(tx, header.ID)
+				var uncleCIDs []eth.UncleModel
+				uncleCIDs, err = ecr.RetrieveUncleCIDsByHeaderID(tx, header.ID)
 				if err != nil {
 					log.Error("uncle cid retrieval error")
 					return nil, true, err
@@ -463,17 +465,20 @@ func (ecr *CIDRetriever) RetrieveBlockByHash(blockHash common.Hash) (eth.HeaderM
 		}
 	}()
 
-	headerCID, err := ecr.RetrieveHeaderCIDByHash(tx, blockHash)
+	var headerCID eth.HeaderModel
+	headerCID, err = ecr.RetrieveHeaderCIDByHash(tx, blockHash)
 	if err != nil {
 		log.Error("header cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
 	}
-	uncleCIDs, err := ecr.RetrieveUncleCIDsByHeaderID(tx, headerCID.ID)
+	var uncleCIDs []eth.UncleModel
+	uncleCIDs, err = ecr.RetrieveUncleCIDsByHeaderID(tx, headerCID.ID)
 	if err != nil {
 		log.Error("uncle cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
 	}
-	txCIDs, err := ecr.RetrieveTxCIDsByHeaderID(tx, headerCID.ID)
+	var txCIDs []eth.TxModel
+	txCIDs, err = ecr.RetrieveTxCIDsByHeaderID(tx, headerCID.ID)
 	if err != nil {
 		log.Error("tx cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
@@ -482,7 +487,8 @@ func (ecr *CIDRetriever) RetrieveBlockByHash(blockHash common.Hash) (eth.HeaderM
 	for i, txCID := range txCIDs {
 		txIDs[i] = txCID.ID
 	}
-	rctCIDs, err := ecr.RetrieveReceiptCIDsByTxIDs(tx, txIDs)
+	var rctCIDs []eth.ReceiptModel
+	rctCIDs, err = ecr.RetrieveReceiptCIDsByTxIDs(tx, txIDs)
 	if err != nil {
 		log.Error("rct cid retrieval error")
 	}
@@ -509,7 +515,8 @@ func (ecr *CIDRetriever) RetrieveBlockByNumber(blockNumber int64) (eth.HeaderMod
 		}
 	}()
 
-	headerCID, err := ecr.RetrieveHeaderCIDs(tx, blockNumber)
+	var headerCID []eth.HeaderModel
+	headerCID, err = ecr.RetrieveHeaderCIDs(tx, blockNumber)
 	if err != nil {
 		log.Error("header cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
@@ -517,12 +524,14 @@ func (ecr *CIDRetriever) RetrieveBlockByNumber(blockNumber int64) (eth.HeaderMod
 	if len(headerCID) < 1 {
 		return eth.HeaderModel{}, nil, nil, nil, fmt.Errorf("header cid retrieval error, no header CIDs found at block %d", blockNumber)
 	}
-	uncleCIDs, err := ecr.RetrieveUncleCIDsByHeaderID(tx, headerCID[0].ID)
+	var uncleCIDs []eth.UncleModel
+	uncleCIDs, err = ecr.RetrieveUncleCIDsByHeaderID(tx, headerCID[0].ID)
 	if err != nil {
 		log.Error("uncle cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
 	}
-	txCIDs, err := ecr.RetrieveTxCIDsByHeaderID(tx, headerCID[0].ID)
+	var txCIDs []eth.TxModel
+	txCIDs, err = ecr.RetrieveTxCIDsByHeaderID(tx, headerCID[0].ID)
 	if err != nil {
 		log.Error("tx cid retrieval error")
 		return eth.HeaderModel{}, nil, nil, nil, err
@@ -531,7 +540,8 @@ func (ecr *CIDRetriever) RetrieveBlockByNumber(blockNumber int64) (eth.HeaderMod
 	for i, txCID := range txCIDs {
 		txIDs[i] = txCID.ID
 	}
-	rctCIDs, err := ecr.RetrieveReceiptCIDsByTxIDs(tx, txIDs)
+	var rctCIDs []eth.ReceiptModel
+	rctCIDs, err = ecr.RetrieveReceiptCIDsByTxIDs(tx, txIDs)
 	if err != nil {
 		log.Error("rct cid retrieval error")
 	}