Re-order uncles if calculated uncle hash doesn't match (#188)

* Re-order uncles if calculated uncle hash doesn't match

* Add a spec to test out of order uncles

.github/workflows/on-pr-publish.yaml

@@ -29,7 +29,7 @@ jobs:
       BUILD_KEY: ${{ secrets.BUILD_KEY }}
     with:
       STACK_ORCHESTRATOR_REF: "f2fd766f5400fcb9eb47b50675d2e3b1f2753702"
-      GO_ETHEREUM_REF: "2cea7024b4db754e43f36e39eb8d06fa42293df2"
+      GO_ETHEREUM_REF: "be1757b9fd884cb20c8d7faac8fa81fc49bb7216"
       IPLD_ETH_DB_REF: "be345e0733d2c025e4082c5154e441317ae94cf7"
   build:
     name: Run docker build

.github/workflows/tests.yaml

@@ -37,7 +37,7 @@ jobs:
       BUILD_KEY: ${{ secrets.BUILD_KEY }}
     #strategy:
     #  matrix:
-    #    go-version: [1.16.x, 1.17.x]
+    #    go-version: [1.16.x, 1.17.x, 1.18.x]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -89,7 +89,7 @@ jobs:
         run: mkdir -p /tmp/go
       - uses: actions/setup-go@v3
         with:
-          go-version: ">=1.18.0"
+          go-version: "1.18.x"
           check-latest: true
       - uses: actions/checkout@v2
         with:
@@ -157,7 +157,7 @@ jobs:
         run: mkdir -p /tmp/go
       - uses: actions/setup-go@v3
         with:
-          go-version: ">=1.18.0"
+          go-version: "1.18.x"
           check-latest: true
       - uses: actions/checkout@v2
         with:

docker-compose.yml

@@ -5,7 +5,7 @@ services:
     restart: on-failure
     depends_on:
       - ipld-eth-db
-    image: vulcanize/ipld-eth-db:v4.2.0-alpha
+    image: vulcanize/ipld-eth-db:v4.2.1-alpha
     environment:
       DATABASE_USER: "vdbm"
       DATABASE_NAME: "vulcanize_testing"

go.mod

@@ -23,7 +23,7 @@ require (
 	github.com/spf13/viper v1.11.0
 	github.com/vulcanize/eth-ipfs-state-validator/v4 v4.0.6-alpha
 	github.com/vulcanize/gap-filler v0.4.0
-	github.com/vulcanize/ipfs-ethdb/v4 v4.0.5-alpha
+	github.com/vulcanize/ipfs-ethdb/v4 v4.0.6-alpha
 	gorm.io/driver/postgres v1.3.7
 	gorm.io/gorm v1.23.5
 )
@@ -274,7 +274,7 @@ require (
 	go.uber.org/multierr v1.8.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
 	go4.org v0.0.0-20200411211856-f5505b9728dd // indirect
-	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
+	golang.org/x/crypto v0.0.0-20220824171710-5757bc0c5503 // indirect
 	golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 // indirect
 	golang.org/x/net v0.0.0-20220607020251-c690dde0001d // indirect
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect

go.sum

@@ -1781,8 +1781,8 @@ github.com/vulcanize/gap-filler v0.4.0 h1:5VD9PG7UrjEub4rLxZmstWoHnBnVtXz9silIVd
 github.com/vulcanize/gap-filler v0.4.0/go.mod h1:5awUyotIoJi6AuG0JPEm7SIwFZBD7Ecg0I8x7CdxcHI=
 github.com/vulcanize/go-ethereum v1.10.21-statediff-4.1.2-alpha h1:ct+8FGuQnHA6SOGOQoAMINWdeexuSF40+IjF48J094A=
 github.com/vulcanize/go-ethereum v1.10.21-statediff-4.1.2-alpha/go.mod h1:dNJkmCSbaasX0zfQM6pm1g3rWlW3EGhLOEZMScyrRAs=
-github.com/vulcanize/ipfs-ethdb/v4 v4.0.5-alpha h1:NFRwWeMB3Q+QqLM9qdcHvfvWBxOk0lPwhOqXJpkIg30=
+github.com/vulcanize/ipfs-ethdb/v4 v4.0.6-alpha h1:iKpv+Bvc0HScak+NiGK4NeYGLWMZ1pyLmrZecHoUGYA=
-github.com/vulcanize/ipfs-ethdb/v4 v4.0.5-alpha/go.mod h1:WvYj0m0cLPAtoytTbcbE2nZ3Hg9iuuF+lY14dBVRWZQ=
+github.com/vulcanize/ipfs-ethdb/v4 v4.0.6-alpha/go.mod h1:WvYj0m0cLPAtoytTbcbE2nZ3Hg9iuuF+lY14dBVRWZQ=
 github.com/wI2L/jsondiff v0.2.0 h1:dE00WemBa1uCjrzQUUTE/17I6m5qAaN0EMFOg2Ynr/k=
 github.com/wI2L/jsondiff v0.2.0/go.mod h1:axTcwtBkY4TsKuV+RgoMhHyHKKFRI6nnjRLi8LLYQnA=
 github.com/wangjia184/sortedset v0.0.0-20160527075905-f5d03557ba30/go.mod h1:YkocrP2K2tcw938x9gCOmT5G5eCD6jsTz0SZuyAqwIE=
@@ -1953,8 +1953,8 @@ golang.org/x/crypto v0.0.0-20210813211128-0a44fdfbc16e/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220518034528-6f7dac969898/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM=
+golang.org/x/crypto v0.0.0-20220824171710-5757bc0c5503 h1:vJ2V3lFLg+bBhgroYuRfyN583UzVveQmIXjc8T/y3to=
-golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20220824171710-5757bc0c5503/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=

pkg/eth/api.go

@@ -66,6 +66,9 @@ type PublicEthAPI struct {
 
 // NewPublicEthAPI creates a new PublicEthAPI with the provided underlying Backend
 func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardEthCalls, proxyOnError bool) (*PublicEthAPI, error) {
+	if b == nil {
+		return nil, errors.New("ipld-eth-server must be configured with an ethereum backend")
+	}
 	if forwardEthCalls && client == nil {
 		return nil, errors.New("ipld-eth-server is configured to forward eth_calls to proxy node but no proxy node is configured")
 	}
@@ -174,6 +177,7 @@ func (pea *PublicEthAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockN
 // GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full
 // detail, otherwise only the transaction hash is returned.
 func (pea *PublicEthAPI) GetBlockByHash(ctx context.Context, hash common.Hash, fullTx bool) (map[string]interface{}, error) {
+	logrus.Debug("Received getBlockByHash request for hash ", hash.Hex())
 	block, err := pea.B.BlockByHash(ctx, hash)
 	if block != nil && err == nil {
 		return pea.rpcMarshalBlock(block, true, fullTx)
@@ -191,8 +195,7 @@ func (pea *PublicEthAPI) GetBlockByHash(ctx context.Context, hash common.Hash, f
 
 // ChainId is the EIP-155 replay-protection chain id for the current ethereum chain config.
 func (pea *PublicEthAPI) ChainId() *hexutil.Big {
-	block, err := pea.B.CurrentBlock()
+	if pea.B.Config.ChainConfig.ChainID == nil || pea.B.Config.ChainConfig.ChainID.Cmp(big.NewInt(0)) <= 0 {
-	if err != nil {
 		if pea.proxyOnError {
 			if id, err := pea.ethClient.ChainID(context.Background()); err == nil {
 				return (*hexutil.Big)(id)
@@ -201,10 +204,7 @@ func (pea *PublicEthAPI) ChainId() *hexutil.Big {
 		return nil
 	}
 
-	if config := pea.B.Config.ChainConfig; config.IsEIP155(block.Number()) {
+	return (*hexutil.Big)(pea.B.Config.ChainConfig.ChainID)
-		return (*hexutil.Big)(config.ChainID)
-	}
-	return nil
 }
 
 /*
@@ -1096,13 +1096,13 @@ func (pea *PublicEthAPI) writeStateDiffFor(blockHash common.Hash) {
 func (pea *PublicEthAPI) rpcMarshalBlock(b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
 	fields, err := RPCMarshalBlock(b, inclTx, fullTx)
 	if err != nil {
-		logrus.Error("error RPC marshalling block with hash", b.Hash().String(), err)
+		logrus.Errorf("error RPC marshalling block with hash %s: %s", b.Hash().String(), err)
 		return nil, err
 	}
 	if inclTx {
 		td, err := pea.B.GetTd(b.Hash())
 		if err != nil {
-			logrus.Error("error getting td for block with hash and number", b.Hash().String(), b.Number().String(), err)
+			logrus.Errorf("error getting td for block with hash and number %s, %s: %s", b.Hash().String(), b.Number().String(), err)
 			return nil, err
 		}
 		fields["totalDifficulty"] = (*hexutil.Big)(td)

pkg/eth/api_test.go

@@ -334,6 +334,18 @@ var _ = Describe("API", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(block["baseFee"].(*big.Int)).To(Equal(baseFee))
 		})
+		It("Retrieves a block by number with uncles in correct order", func() {
+			block, err := api.GetBlockByNumber(ctx, londonBlockNum, false)
+			Expect(err).ToNot(HaveOccurred())
+
+			expectedUncles := []common.Hash{
+				test_helpers.MockLondonUncles[0].Hash(),
+				test_helpers.MockLondonUncles[1].Hash(),
+			}
+			Expect(block["uncles"]).To(Equal(expectedUncles))
+			Expect(block["sha3Uncles"]).To(Equal(test_helpers.MockLondonBlock.UncleHash()))
+			Expect(block["hash"]).To(Equal(test_helpers.MockLondonBlock.Hash()))
+		})
 	})
 
 	Describe("eth_getBlockByHash", func() {
@@ -375,6 +387,18 @@ var _ = Describe("API", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(block["baseFee"].(*big.Int)).To(Equal(baseFee))
 		})
+		It("Retrieves a block by hash with uncles in correct order", func() {
+			block, err := api.GetBlockByHash(ctx, test_helpers.MockLondonBlock.Hash(), false)
+			Expect(err).ToNot(HaveOccurred())
+
+			expectedUncles := []common.Hash{
+				test_helpers.MockLondonUncles[0].Hash(),
+				test_helpers.MockLondonUncles[1].Hash(),
+			}
+			Expect(block["uncles"]).To(Equal(expectedUncles))
+			Expect(block["sha3Uncles"]).To(Equal(test_helpers.MockLondonBlock.UncleHash()))
+			Expect(block["hash"]).To(Equal(test_helpers.MockLondonBlock.Hash()))
+		})
 	})
 
 	/*

pkg/eth/backend.go

@@ -39,7 +39,6 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/statediff/indexer/models"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/jmoiron/sqlx"
 	log "github.com/sirupsen/logrus"
@@ -192,7 +191,23 @@ func (b *Backend) HeaderByNumber(ctx context.Context, blockNumber rpc.BlockNumbe
 
 // HeaderByHash gets the header for the provided block hash
 func (b *Backend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
-	_, headerRLP, err := b.IPLDRetriever.RetrieveHeaderByHash(hash)
+	// Begin tx
+	tx, err := 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()
+		}
+	}()
+
+	_, headerRLP, err := b.IPLDRetriever.RetrieveHeaderByHash(tx, hash)
 	if err != nil {
 		return nil, err
 	}
@@ -281,7 +296,7 @@ func (b *Backend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.Blo
 	return nil, errors.New("invalid arguments; neither block nor hash specified")
 }
 
-// BlockByNumber returns the requested canonical block.
+// BlockByNumber returns the requested canonical block
 func (b *Backend) BlockByNumber(ctx context.Context, blockNumber rpc.BlockNumber) (*types.Block, error) {
 	var err error
 	number := blockNumber.Int64()
@@ -303,6 +318,7 @@ func (b *Backend) BlockByNumber(ctx context.Context, blockNumber rpc.BlockNumber
 	if number < 0 {
 		return nil, errNegativeBlockNumber
 	}
+
 	// Get the canonical hash
 	canonicalHash, err := b.GetCanonicalHash(uint64(number))
 	if err != nil {
@@ -311,118 +327,12 @@ func (b *Backend) BlockByNumber(ctx context.Context, blockNumber rpc.BlockNumber
 		}
 		return nil, err
 	}
-	// Retrieve all the CIDs for the block
+
-	// TODO: optimize this by retrieving iplds directly rather than the cids first (this is remanent from when we fetched iplds through ipfs blockservice interface)
+	return b.BlockByHash(ctx, canonicalHash)
-	headerCID, uncleCIDs, txCIDs, rctCIDs, err := b.Retriever.RetrieveBlockByHash(canonicalHash)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
 }
 
-	// Begin tx
+// BlockByHash returns the requested block
-	tx, err := 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()
-		}
-	}()
-
-	// Fetch and decode the header IPLD
-	var headerIPLD models.IPLDModel
-	headerIPLD, err = b.Fetcher.FetchHeader(tx, headerCID)
-	if err != nil {
-		log.Error("error fetching header ipld", err)
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	var header types.Header
-	err = rlp.DecodeBytes(headerIPLD.Data, &header)
-	if err != nil {
-		return nil, err
-	}
-
-	// Fetch and decode the uncle IPLDs
-	var uncleIPLDs []models.IPLDModel
-	uncleIPLDs, err = b.Fetcher.FetchUncles(tx, uncleCIDs)
-	if err != nil {
-		log.Error("error fetching uncle iplds", err)
-		return nil, err
-	}
-	var uncles []*types.Header
-	for _, uncleIPLD := range uncleIPLDs {
-		var uncle types.Header
-		err = rlp.DecodeBytes(uncleIPLD.Data, &uncle)
-		if err != nil {
-			return nil, err
-		}
-		uncles = append(uncles, &uncle)
-	}
-
-	// Fetch and decode the transaction IPLDs
-	var txIPLDs []models.IPLDModel
-	txIPLDs, err = b.Fetcher.FetchTrxs(tx, txCIDs)
-	if err != nil {
-		log.Error("error fetching tx iplds", err)
-		return nil, err
-	}
-	var transactions []*types.Transaction
-	for _, txIPLD := range txIPLDs {
-		var transaction types.Transaction
-		err = transaction.UnmarshalBinary(txIPLD.Data)
-		if err != nil {
-			return nil, err
-		}
-		transactions = append(transactions, &transaction)
-	}
-	// Fetch and decode the receipt IPLDs
-	var rctIPLDs []models.IPLDModel
-	rctIPLDs, err = b.Fetcher.FetchRcts(tx, rctCIDs)
-	if err != nil {
-		log.Error("error fetching rct iplds", err)
-		return nil, err
-	}
-	var receipts []*types.Receipt
-	for _, rctIPLD := range rctIPLDs {
-		var receipt types.Receipt
-		nodeVal, err := DecodeLeafNode(rctIPLD.Data)
-		if err != nil {
-			return nil, err
-		}
-
-		err = receipt.UnmarshalBinary(nodeVal)
-		if err != nil {
-			return nil, err
-		}
-		receipts = append(receipts, &receipt)
-	}
-	// Compose everything together into a complete block
-	return types.NewBlock(&header, transactions, uncles, receipts, new(trie.Trie)), err
-}
-
-// BlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full
-// detail, otherwise only the transaction hash is returned.
 func (b *Backend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
-	// Retrieve all the CIDs for the block
-	headerCID, uncleCIDs, txCIDs, rctCIDs, err := b.Retriever.RetrieveBlockByHash(hash)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-
 	// Begin tx
 	tx, err := b.DB.Beginx()
 	if err != nil {
@@ -439,85 +349,126 @@ func (b *Backend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Blo
 		}
 	}()
 
-	// Fetch and decode the header IPLD
+	// Fetch header
-	var headerIPLD models.IPLDModel
+	header, err := b.GetHeaderByBlockHash(tx, hash)
-	headerIPLD, err = b.Fetcher.FetchHeader(tx, headerCID)
 	if err != nil {
-		log.Error("error fetching header ipld", err)
+		log.Error("error fetching header: ", err)
 		if err == sql.ErrNoRows {
 			return nil, nil
 		}
 		return nil, err
 	}
-	var header types.Header
+
-	err = rlp.DecodeBytes(headerIPLD.Data, &header)
+	// Fetch uncles
-	if err != nil {
+	uncles, err := b.GetUnclesByBlockHash(tx, hash)
+	if err != nil && err != sql.ErrNoRows {
+		log.Error("error fetching uncles: ", err)
 		return nil, err
 	}
-	// Fetch and decode the uncle IPLDs
+
-	var uncleIPLDs []models.IPLDModel
+	// When num. of uncles = 2,
-	uncleIPLDs, err = b.Fetcher.FetchUncles(tx, uncleCIDs)
+	// Check if calculated uncle hash matches the one in header
-	if err != nil {
+	// If not, re-order the two uncles
-		log.Error("error fetching uncle iplds", err)
+	// Assumption: Max num. of uncles in mainnet = 2
-		if err == sql.ErrNoRows {
+	if len(uncles) == 2 {
-			return nil, nil
+		uncleHash := types.CalcUncleHash(uncles)
+		if uncleHash != header.UncleHash {
+			uncles[0], uncles[1] = uncles[1], uncles[0]
+
+			uncleHash = types.CalcUncleHash(uncles)
+			// Check if uncle hash matches after re-ordering
+			if uncleHash != header.UncleHash {
+				log.Error("uncle hash mismatch for block hash: ", hash.Hex())
 			}
+		}
+	}
+
+	// Fetch transactions
+	transactions, err := b.GetTransactionsByBlockHash(tx, hash)
+	if err != nil && err != sql.ErrNoRows {
+		log.Error("error fetching transactions: ", err)
 		return nil, err
 	}
-	var uncles []*types.Header
+
-	for _, uncleIPLD := range uncleIPLDs {
+	// Fetch receipts
-		var uncle types.Header
+	receipts, err := b.GetReceiptsByBlockHash(tx, hash)
-		err = rlp.DecodeBytes(uncleIPLD.Data, &uncle)
+	if err != nil && err != sql.ErrNoRows {
-		if err != nil {
+		log.Error("error fetching receipts: ", err)
 		return nil, err
 	}
-		uncles = append(uncles, &uncle)
+
+	// Compose everything together into a complete block
+	return types.NewBlock(header, transactions, uncles, receipts, new(trie.Trie)), err
 }
-	// Fetch and decode the transaction IPLDs
+
-	var txIPLDs []models.IPLDModel
+// GetHeaderByBlockHash retrieves header for a provided block hash
-	txIPLDs, err = b.Fetcher.FetchTrxs(tx, txCIDs)
+func (b *Backend) GetHeaderByBlockHash(tx *sqlx.Tx, hash common.Hash) (*types.Header, error) {
-	if err != nil {
+	_, headerRLP, err := b.IPLDRetriever.RetrieveHeaderByHash(tx, hash)
-		log.Error("error fetching tx iplds", err)
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	var transactions []*types.Transaction
-	for _, txIPLD := range txIPLDs {
-		var transaction types.Transaction
-		err = transaction.UnmarshalBinary(txIPLD.Data)
-		if err != nil {
-			return nil, err
-		}
-		transactions = append(transactions, &transaction)
-	}
-	// Fetch and decode the receipt IPLDs
-	var rctIPLDs []models.IPLDModel
-	rctIPLDs, err = b.Fetcher.FetchRcts(tx, rctCIDs)
-	if err != nil {
-		log.Error("error fetching rct iplds", err)
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	var receipts []*types.Receipt
-	for _, rctIPLD := range rctIPLDs {
-		var receipt types.Receipt
-		nodeVal, err := DecodeLeafNode(rctIPLD.Data)
 	if err != nil {
 		return nil, err
 	}
 
-		err = receipt.UnmarshalBinary(nodeVal)
+	header := new(types.Header)
+	return header, rlp.DecodeBytes(headerRLP, header)
+}
+
+// GetUnclesByBlockHash retrieves uncles for a provided block hash
+func (b *Backend) GetUnclesByBlockHash(tx *sqlx.Tx, hash common.Hash) ([]*types.Header, error) {
+	_, uncleBytes, err := b.IPLDRetriever.RetrieveUnclesByBlockHash(tx, hash)
 	if err != nil {
 		return nil, err
 	}
-		receipts = append(receipts, &receipt)
+
+	uncles := make([]*types.Header, len(uncleBytes))
+	for i, bytes := range uncleBytes {
+		var uncle types.Header
+		err = rlp.DecodeBytes(bytes, &uncle)
+		if err != nil {
+			return nil, err
 		}
-	// Compose everything together into a complete block
+
-	return types.NewBlock(&header, transactions, uncles, receipts, new(trie.Trie)), err
+		uncles[i] = &uncle
+	}
+
+	return uncles, nil
+}
+
+// GetTransactionsByBlockHash retrieves transactions for a provided block hash
+func (b *Backend) GetTransactionsByBlockHash(tx *sqlx.Tx, hash common.Hash) (types.Transactions, error) {
+	_, transactionBytes, err := b.IPLDRetriever.RetrieveTransactionsByBlockHash(tx, hash)
+	if err != nil {
+		return nil, err
+	}
+
+	txs := make(types.Transactions, len(transactionBytes))
+	for i, txBytes := range transactionBytes {
+		var tx types.Transaction
+		if err := tx.UnmarshalBinary(txBytes); err != nil {
+			return nil, err
+		}
+
+		txs[i] = &tx
+	}
+
+	return txs, nil
+}
+
+// GetReceiptsByBlockHash retrieves receipts for a provided block hash
+func (b *Backend) GetReceiptsByBlockHash(tx *sqlx.Tx, hash common.Hash) (types.Receipts, error) {
+	_, receiptBytes, txs, err := b.IPLDRetriever.RetrieveReceiptsByBlockHash(tx, hash)
+	if err != nil {
+		return nil, err
+	}
+	rcts := make(types.Receipts, len(receiptBytes))
+	for i, rctBytes := range receiptBytes {
+		rct := new(types.Receipt)
+		if err := rct.UnmarshalBinary(rctBytes); err != nil {
+			return nil, err
+		}
+		rct.TxHash = txs[i]
+		rcts[i] = rct
+	}
+	return rcts, nil
 }
 
 // GetTransaction retrieves a tx by hash
@@ -551,7 +502,23 @@ func (b *Backend) GetTransaction(ctx context.Context, txHash common.Hash) (*type
 
 // GetReceipts retrieves receipts for provided block hash
 func (b *Backend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
-	_, receiptBytes, txs, err := b.IPLDRetriever.RetrieveReceiptsByBlockHash(hash)
+	// Begin tx
+	tx, err := 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()
+		}
+	}()
+
+	_, receiptBytes, txs, err := b.IPLDRetriever.RetrieveReceiptsByBlockHash(tx, hash)
 	if err != nil {
 		return nil, err
 	}
@@ -569,7 +536,23 @@ func (b *Backend) GetReceipts(ctx context.Context, hash common.Hash) (types.Rece
 
 // GetLogs returns all the logs for the given block hash
 func (b *Backend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
-	_, receiptBytes, txs, err := b.IPLDRetriever.RetrieveReceiptsByBlockHash(hash)
+	// Begin tx
+	tx, err := 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()
+		}
+	}()
+
+	_, receiptBytes, txs, err := b.IPLDRetriever.RetrieveReceiptsByBlockHash(tx, hash)
 	if err != nil {
 		return nil, err
 	}

pkg/eth/ipld_retriever.go

@@ -74,7 +74,8 @@ const (
 												uncle_cids.mh_key = blocks.key
 												AND uncle_cids.block_number = blocks.block_number
 											)
-										WHERE header_cids.block_hash = $1`
+										WHERE header_cids.block_hash = $1
+										ORDER BY uncle_cids.parent_hash`
 	RetrieveUnclesByBlockNumberPgStr = `SELECT uncle_cids.cid, data
 										FROM eth.uncle_cids
 											INNER JOIN eth.header_cids ON (
@@ -313,9 +314,9 @@ func (r *IPLDRetriever) RetrieveHeadersByBlockNumber(number uint64) ([]string, [
 }
 
 // RetrieveHeaderByHash returns the cid and rlp bytes for the header corresponding to the provided block hash
-func (r *IPLDRetriever) RetrieveHeaderByHash(hash common.Hash) (string, []byte, error) {
+func (r *IPLDRetriever) RetrieveHeaderByHash(tx *sqlx.Tx, hash common.Hash) (string, []byte, error) {
 	headerResult := new(ipldResult)
-	return headerResult.CID, headerResult.Data, r.db.Get(headerResult, RetrieveHeaderByHashPgStr, hash.Hex())
+	return headerResult.CID, headerResult.Data, tx.Get(headerResult, RetrieveHeaderByHashPgStr, hash.Hex())
 }
 
 // RetrieveUnclesByHashes returns the cids and rlp bytes for the uncles corresponding to the provided uncle hashes
@@ -338,9 +339,9 @@ func (r *IPLDRetriever) RetrieveUnclesByHashes(hashes []common.Hash) ([]string,
 }
 
 // RetrieveUnclesByBlockHash returns the cids and rlp bytes for the uncles corresponding to the provided block hash (of non-omner root block)
-func (r *IPLDRetriever) RetrieveUnclesByBlockHash(hash common.Hash) ([]string, [][]byte, error) {
+func (r *IPLDRetriever) RetrieveUnclesByBlockHash(tx *sqlx.Tx, hash common.Hash) ([]string, [][]byte, error) {
 	uncleResults := make([]ipldResult, 0)
-	if err := r.db.Select(&uncleResults, RetrieveUnclesByBlockHashPgStr, hash.Hex()); err != nil {
+	if err := tx.Select(&uncleResults, RetrieveUnclesByBlockHashPgStr, hash.Hex()); err != nil {
 		return nil, nil, err
 	}
 	cids := make([]string, len(uncleResults))
@@ -393,9 +394,9 @@ func (r *IPLDRetriever) RetrieveTransactionsByHashes(hashes []common.Hash) ([]st
 }
 
 // RetrieveTransactionsByBlockHash returns the cids and rlp bytes for the transactions corresponding to the provided block hash
-func (r *IPLDRetriever) RetrieveTransactionsByBlockHash(hash common.Hash) ([]string, [][]byte, error) {
+func (r *IPLDRetriever) RetrieveTransactionsByBlockHash(tx *sqlx.Tx, hash common.Hash) ([]string, [][]byte, error) {
 	txResults := make([]ipldResult, 0)
-	if err := r.db.Select(&txResults, RetrieveTransactionsByBlockHashPgStr, hash.Hex()); err != nil {
+	if err := tx.Select(&txResults, RetrieveTransactionsByBlockHashPgStr, hash.Hex()); err != nil {
 		return nil, nil, err
 	}
 	cids := make([]string, len(txResults))
@@ -470,9 +471,9 @@ func (r *IPLDRetriever) RetrieveReceiptsByTxHashes(hashes []common.Hash) ([]stri
 
 // RetrieveReceiptsByBlockHash returns the cids and rlp bytes for the receipts corresponding to the provided block hash.
 // cid returned corresponds to the leaf node data which contains the receipt.
-func (r *IPLDRetriever) RetrieveReceiptsByBlockHash(hash common.Hash) ([]string, [][]byte, []common.Hash, error) {
+func (r *IPLDRetriever) RetrieveReceiptsByBlockHash(tx *sqlx.Tx, hash common.Hash) ([]string, [][]byte, []common.Hash, error) {
 	rctResults := make([]rctIpldResult, 0)
-	if err := r.db.Select(&rctResults, RetrieveReceiptsByBlockHashPgStr, hash.Hex()); err != nil {
+	if err := tx.Select(&rctResults, RetrieveReceiptsByBlockHashPgStr, hash.Hex()); err != nil {
 		return nil, nil, nil, err
 	}
 	cids := make([]string, len(rctResults))

pkg/eth/test_helpers/test_data.go

@@ -594,7 +594,29 @@ var (
 	}
 
 	MockLondonTransactions, MockLondonReceipts, _ = createDynamicTransactionsAndReceipts(LondonBlockNum)
-	MockLondonBlock                               = createNewBlock(&MockLondonHeader, MockLondonTransactions, nil, MockLondonReceipts, new(trie.Trie))
+	MockLondonUncles                              = []*types.Header{
+		{
+			Time:        1,
+			Number:      new(big.Int).Add(BlockNumber, big.NewInt(1)),
+			ParentHash:  common.HexToHash("0x2"),
+			Root:        common.HexToHash("0x1"),
+			TxHash:      common.HexToHash("0x1"),
+			ReceiptHash: common.HexToHash("0x1"),
+			Difficulty:  big.NewInt(500001),
+			Extra:       []byte{},
+		},
+		{
+			Time:        2,
+			Number:      new(big.Int).Add(BlockNumber, big.NewInt(1)),
+			ParentHash:  common.HexToHash("0x1"),
+			Root:        common.HexToHash("0x2"),
+			TxHash:      common.HexToHash("0x2"),
+			ReceiptHash: common.HexToHash("0x2"),
+			Difficulty:  big.NewInt(500002),
+			Extra:       []byte{},
+		},
+	}
+	MockLondonBlock = createNewBlock(&MockLondonHeader, MockLondonTransactions, MockLondonUncles, MockLondonReceipts, new(trie.Trie))
 )
 
 func createNewBlock(header *types.Header, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, hasher types.TrieHasher) *types.Block {

test/README.md

@@ -4,16 +4,16 @@
 
 - Clone [stack-orchestrator](https://github.com/vulcanize/stack-orchestrator), [ipld-eth-db](https://github.com/vulcanize/ipld-eth-db) [go-ethereum](https://github.com/vulcanize/go-ethereum) repositories.
 
-- Checkout [v4 release](https://github.com/vulcanize/ipld-eth-db/releases/tag/v4.2.0-alpha) in ipld-eth-db repo.
+- Checkout [v4 release](https://github.com/vulcanize/ipld-eth-db/releases/tag/v4.2.1-alpha) in ipld-eth-db repo.
   ```bash
   # In ipld-eth-db repo.
-  git checkout v4.2.0-alpha
+  git checkout v4.2.1-alpha
   ```
 
-- Checkout [v4 release](https://github.com/vulcanize/go-ethereum/releases/tag/v1.10.19-statediff-4.1.0-alpha) in go-ethereum repo.
+- Checkout [v4 release](https://github.com/vulcanize/go-ethereum/releases/tag/v1.10.21-statediff-4.1.2-alpha) in go-ethereum repo.
   ```bash
   # In go-ethereum repo.
-  git checkout v1.10.19-statediff-4.1.0-alpha
+  git checkout v1.10.21-statediff-4.1.2-alpha
   ```
 
 - Checkout working commit in stack-orchestrator repo.

version/version.go

@@ -19,10 +19,10 @@ package version
 import "fmt"
 
 const (
-	Major = 2  // Major version component of the current release
+	Major = 4       // Major version component of the current release
-	Minor = 0  // Minor version component of the current release
+	Minor = 1       // Minor version component of the current release
-	Patch = 0  // Patch version component of the current release
+	Patch = 5       // Patch version component of the current release
-	Meta  = "" // Version metadata to append to the version string
+	Meta  = "alpha" // Version metadata to append to the version string
 )
 
 // Version holds the textual version string.