support for total difficulty (needed to support some eth endpoints)

2020-01-24 15:37:52 -06:00
parent 358575335b
commit 0785507a7d
14 changed files with 118 additions and 113 deletions
@@ -44,78 +44,71 @@ func NewCIDRepository(db *postgres.DB) *Repository {

 // Index indexes a cidPayload in Postgres
 func (repo *Repository) Index(cidPayload *ipfs.CIDPayload) error {
-	tx, beginErr := repo.db.Beginx()
-	if beginErr != nil {
-		return beginErr
+	tx, err := repo.db.Beginx()
+	if err != nil {
+		return err
 	}
-	headerID, headerErr := repo.indexHeaderCID(tx, cidPayload.HeaderCID, cidPayload.BlockNumber, cidPayload.BlockHash.Hex())
-	if headerErr != nil {
-		rollbackErr := tx.Rollback()
-		if rollbackErr != nil {
-			log.Error(rollbackErr)
+	headerID, err := repo.indexHeaderCID(tx, cidPayload.HeaderCID, cidPayload.BlockNumber, cidPayload.BlockHash.Hex(), cidPayload.TotalDifficulty)
+	if err != nil {
+		if err := tx.Rollback(); err != nil {
+			log.Error(err)
 		}
-		return headerErr
+		return err
 	}
 	for uncleHash, cid := range cidPayload.UncleCIDs {
-		uncleErr := repo.indexUncleCID(tx, cid, cidPayload.BlockNumber, uncleHash.Hex())
-		if uncleErr != nil {
-			rollbackErr := tx.Rollback()
-			if rollbackErr != nil {
-				log.Error(rollbackErr)
+		err := repo.indexUncleCID(tx, cid, cidPayload.BlockNumber, uncleHash.Hex(), cidPayload.TotalDifficulty)
+		if err != nil {
+			if err := tx.Rollback(); err != nil {
+				log.Error(err)
 			}
-			return uncleErr
+			return err
 		}
 	}
-	trxAndRctErr := repo.indexTransactionAndReceiptCIDs(tx, cidPayload, headerID)
-	if trxAndRctErr != nil {
-		rollbackErr := tx.Rollback()
-		if rollbackErr != nil {
-			log.Error(rollbackErr)
+	if err := repo.indexTransactionAndReceiptCIDs(tx, cidPayload, headerID); err != nil {
+		if err := tx.Rollback(); err != nil {
+			log.Error(err)
 		}
-		return trxAndRctErr
+		return err
 	}
-	stateAndStorageErr := repo.indexStateAndStorageCIDs(tx, cidPayload, headerID)
-	if stateAndStorageErr != nil {
-		rollbackErr := tx.Rollback()
-		if rollbackErr != nil {
-			log.Error(rollbackErr)
+	if err := repo.indexStateAndStorageCIDs(tx, cidPayload, headerID); err != nil {
+		if err := tx.Rollback(); err != nil {
+			log.Error(err)
 		}
-		return stateAndStorageErr
+		return err
 	}
 	return tx.Commit()
 }

-func (repo *Repository) indexHeaderCID(tx *sqlx.Tx, cid, blockNumber, hash string) (int64, error) {
+func (repo *Repository) indexHeaderCID(tx *sqlx.Tx, cid, blockNumber, hash, td string) (int64, error) {
 	var headerID int64
-	err := tx.QueryRowx(`INSERT INTO public.header_cids (block_number, block_hash, cid, uncle) VALUES ($1, $2, $3, $4)
-								ON CONFLICT (block_number, block_hash) DO UPDATE SET (cid, uncle) = ($3, $4)
+	err := tx.QueryRowx(`INSERT INTO public.header_cids (block_number, block_hash, cid, uncle, td) VALUES ($1, $2, $3, $4, $5)
+								ON CONFLICT (block_number, block_hash) DO UPDATE SET (cid, uncle, td) = ($3, $4, $5)
 								RETURNING id`,
-		blockNumber, hash, cid, false).Scan(&headerID)
+		blockNumber, hash, cid, false, td).Scan(&headerID)
 	return headerID, err
 }

-func (repo *Repository) indexUncleCID(tx *sqlx.Tx, cid, blockNumber, hash string) error {
-	_, err := tx.Exec(`INSERT INTO public.header_cids (block_number, block_hash, cid, uncle) VALUES ($1, $2, $3, $4)
-								ON CONFLICT (block_number, block_hash) DO UPDATE SET (cid, uncle) = ($3, $4)`,
-		blockNumber, hash, cid, true)
+func (repo *Repository) indexUncleCID(tx *sqlx.Tx, cid, blockNumber, hash, td string) error {
+	_, err := tx.Exec(`INSERT INTO public.header_cids (block_number, block_hash, cid, uncle, td) VALUES ($1, $2, $3, $4, $5)
+								ON CONFLICT (block_number, block_hash) DO UPDATE SET (cid, uncle, td) = ($3, $4, $5)`,
+		blockNumber, hash, cid, true, td)
 	return err
 }

 func (repo *Repository) indexTransactionAndReceiptCIDs(tx *sqlx.Tx, payload *ipfs.CIDPayload, headerID int64) error {
 	for hash, trxCidMeta := range payload.TransactionCIDs {
 		var txID int64
-		queryErr := tx.QueryRowx(`INSERT INTO public.transaction_cids (header_id, tx_hash, cid, dst, src) VALUES ($1, $2, $3, $4, $5) 
+		err := tx.QueryRowx(`INSERT INTO public.transaction_cids (header_id, tx_hash, cid, dst, src) VALUES ($1, $2, $3, $4, $5)
 									ON CONFLICT (header_id, tx_hash) DO UPDATE SET (cid, dst, src) = ($3, $4, $5)
 									RETURNING id`,
 			headerID, hash.Hex(), trxCidMeta.CID, trxCidMeta.Dst, trxCidMeta.Src).Scan(&txID)
-		if queryErr != nil {
-			return queryErr
+		if err != nil {
+			return err
 		}
 		receiptCidMeta, ok := payload.ReceiptCIDs[hash]
 		if ok {
-			rctErr := repo.indexReceiptCID(tx, receiptCidMeta, txID)
-			if rctErr != nil {
-				return rctErr
+			if err := repo.indexReceiptCID(tx, receiptCidMeta, txID); err != nil {
+				return err
 			}
 		}
 	}
@@ -131,17 +124,16 @@ func (repo *Repository) indexReceiptCID(tx *sqlx.Tx, cidMeta *ipfs.ReceiptMetaDa
 func (repo *Repository) indexStateAndStorageCIDs(tx *sqlx.Tx, payload *ipfs.CIDPayload, headerID int64) error {
 	for accountKey, stateCID := range payload.StateNodeCIDs {
 		var stateID int64
-		queryErr := tx.QueryRowx(`INSERT INTO public.state_cids (header_id, state_key, cid, leaf) VALUES ($1, $2, $3, $4)
+		err := tx.QueryRowx(`INSERT INTO public.state_cids (header_id, state_key, cid, leaf) VALUES ($1, $2, $3, $4)
 									ON CONFLICT (header_id, state_key) DO UPDATE SET (cid, leaf) = ($3, $4)
 									RETURNING id`,
 			headerID, accountKey.Hex(), stateCID.CID, stateCID.Leaf).Scan(&stateID)
-		if queryErr != nil {
-			return queryErr
+		if err != nil {
+			return err
 		}
 		for _, storageCID := range payload.StorageNodeCIDs[accountKey] {
-			storageErr := repo.indexStorageCID(tx, storageCID, stateID)
-			if storageErr != nil {
-				return storageErr
+			if err := repo.indexStorageCID(tx, storageCID, stateID); err != nil {
+				return err
 			}
 		}
 	}
@@ -19,7 +19,6 @@ package super_node_test
 import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
 	"github.com/vulcanize/vulcanizedb/pkg/ipfs"
 	"github.com/vulcanize/vulcanizedb/pkg/ipfs/mocks"
@@ -45,14 +44,18 @@ var _ = Describe("Repository", func() {
 		It("Indexes CIDs and related metadata into vulcanizedb", func() {
 			err = repo.Index(mocks.MockCIDPayload)
 			Expect(err).ToNot(HaveOccurred())
-			pgStr := `SELECT cid FROM header_cids
+			pgStr := `SELECT cid, td FROM header_cids
 				WHERE block_number = $1 AND uncle IS FALSE`
 			// check header was properly indexed
-			headers := make([]string, 0)
-			err = db.Select(&headers, pgStr, 1)
+			type res struct {
+				CID string
+				TD  string
+			}
+			headers := new(res)
+			err = db.QueryRowx(pgStr, 1).StructScan(headers)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(len(headers)).To(Equal(1))
-			Expect(headers[0]).To(Equal("mockHeaderCID"))
+			Expect(headers.CID).To(Equal("mockHeaderCID"))
+			Expect(headers.TD).To(Equal("1337"))
 			// check trxs were properly indexed
 			trxs := make([]string, 0)
 			pgStr = `SELECT transaction_cids.cid FROM transaction_cids INNER JOIN header_cids ON (transaction_cids.header_id = header_cids.id)