fix(consensus): fix error invalid merkle root on pre-tip-signing replay

Symptom: nodes that resumed syncing from local state could fail checkpoint validation with an invalid merkle root while replaying pre-TIPSigning blocks after restart.

Cause: the non-TIP signing transaction replay path rebuilt signer data from raw receipts, but raw receipts may not carry TxHash metadata. As a result, signing transactions could be dropped and checkpoint rewards recalculated with totalSigner=0.

Fix: match non-TIP signing transactions to receipts by transaction index when receipt metadata is unavailable, keep the failed-receipt filter intact, and add regression tests covering raw-receipt replay.

Author: gzliudan

consensus/XDPoS/XDPoS.go

@@ -234,7 +234,6 @@ func (x *XDPoS) VerifyHeaders(chain consensus.ChainReader, headers []*types.Head
 		}
 	}
 
-
 	if v1headers != nil {
 		x.EngineV1.VerifyHeaders(chain, v1headers, v1fullVerifies, abort, results)
 	}
@@ -514,21 +513,18 @@ Caching
 // Cache signing transaction data into BlockSingers cache object
 func (x *XDPoS) CacheNoneTIPSigningTxs(header *types.Header, txs []*types.Transaction, receipts []*types.Receipt) []*types.Transaction {
 	signTxs := []*types.Transaction{}
-	for _, tx := range txs {
+	for txIndex, tx := range txs {
 		if tx.IsSigningTransaction() {
-			var b uint64
-			for _, r := range receipts {
-				if r.TxHash == tx.Hash() {
-					if len(r.PostState) > 0 {
-						b = types.ReceiptStatusSuccessful
-					} else {
-						b = r.Status
-					}
-					break
-				}
+			receipt := findTransactionReceipt(txIndex, tx.Hash(), receipts)
+			if receipt == nil {
+				continue
 			}
 
-			if b == types.ReceiptStatusFailed {
+			status := receipt.Status
+			if len(receipt.PostState) > 0 {
+				status = types.ReceiptStatusSuccessful
+			}
+			if status == types.ReceiptStatusFailed {
 				continue
 			}
 
@@ -542,6 +538,21 @@ func (x *XDPoS) CacheNoneTIPSigningTxs(header *types.Header, txs []*types.Transa
 	return signTxs
 }
 
+func findTransactionReceipt(txIndex int, txHash common.Hash, receipts []*types.Receipt) *types.Receipt {
+	if txIndex < len(receipts) {
+		receipt := receipts[txIndex]
+		if receipt != nil && (receipt.TxHash == (common.Hash{}) || receipt.TxHash == txHash) {
+			return receipt
+		}
+	}
+	for _, receipt := range receipts {
+		if receipt != nil && receipt.TxHash == txHash {
+			return receipt
+		}
+	}
+	return nil
+}
+
 // Cache
 func (x *XDPoS) CacheSigningTxs(hash common.Hash, txs []*types.Transaction) []*types.Transaction {
 	signTxs := []*types.Transaction{}

consensus/XDPoS/XDPoS_test.go

@@ -1,9 +1,12 @@
 package XDPoS
 
 import (
+	"math/big"
 	"testing"
 
+	"github.com/XinFinOrg/XDPoSChain/common"
 	"github.com/XinFinOrg/XDPoSChain/core/rawdb"
+	"github.com/XinFinOrg/XDPoSChain/core/types"
 	"github.com/XinFinOrg/XDPoSChain/params"
 	"github.com/stretchr/testify/assert"
 )
@@ -16,3 +19,88 @@ func TestAdaptorShouldShareDbWithV1Engine(t *testing.T) {
 	assert := assert.New(t)
 	assert.Equal(engine.EngineV1.GetDb(), engine.GetDb())
 }
+
+func TestCacheNoneTIPSigningTxsSupportsRawReceiptsWithoutTxHash(t *testing.T) {
+	database := rawdb.NewMemoryDatabase()
+	config := params.TestXDPoSMockChainConfig
+	engine := New(config, database)
+
+	signingTx := types.NewTransaction(
+		0,
+		common.BlockSignersBinary,
+		big.NewInt(0),
+		200000,
+		big.NewInt(0),
+		append(common.Hex2Bytes(common.HexSignMethod), make([]byte, 64)...),
+	)
+	normalTx := types.NewTransaction(
+		1,
+		common.Address{0x1},
+		big.NewInt(0),
+		21000,
+		big.NewInt(0),
+		nil,
+	)
+	receipts := []*types.Receipt{
+		{Status: types.ReceiptStatusSuccessful},
+		{Status: types.ReceiptStatusSuccessful},
+	}
+
+	cached := engine.CacheNoneTIPSigningTxs(&types.Header{Number: big.NewInt(1)}, []*types.Transaction{signingTx, normalTx}, receipts)
+
+	assert.Len(t, cached, 1)
+	assert.Equal(t, signingTx.Hash(), cached[0].Hash())
+}
+
+func TestCacheNoneTIPSigningTxsSkipsFailedSigningReceiptByIndex(t *testing.T) {
+	database := rawdb.NewMemoryDatabase()
+	config := params.TestXDPoSMockChainConfig
+	engine := New(config, database)
+
+	signingTx := types.NewTransaction(
+		0,
+		common.BlockSignersBinary,
+		big.NewInt(0),
+		200000,
+		big.NewInt(0),
+		append(common.Hex2Bytes(common.HexSignMethod), make([]byte, 64)...),
+	)
+	receipts := []*types.Receipt{{Status: types.ReceiptStatusFailed}}
+
+	cached := engine.CacheNoneTIPSigningTxs(&types.Header{Number: big.NewInt(1)}, []*types.Transaction{signingTx}, receipts)
+
+	assert.Empty(t, cached)
+}
+
+func TestCacheNoneTIPSigningTxsWithRawReceiptRoundTrip(t *testing.T) {
+	database := rawdb.NewMemoryDatabase()
+	config := params.TestXDPoSMockChainConfig
+	engine := New(config, database)
+	blockHash := common.HexToHash("0x1234")
+	blockNumber := uint64(1)
+
+	signingTx := types.NewTransaction(
+		0,
+		common.BlockSignersBinary,
+		big.NewInt(0),
+		200000,
+		big.NewInt(0),
+		append(common.Hex2Bytes(common.HexSignMethod), make([]byte, 64)...),
+	)
+	receipts := []*types.Receipt{{
+		Status:            types.ReceiptStatusSuccessful,
+		CumulativeGasUsed: 200000,
+		TxHash:            signingTx.Hash(),
+	}}
+
+	rawdb.WriteReceipts(database, blockHash, blockNumber, receipts)
+	rawReceipts := rawdb.ReadRawReceipts(database, blockHash, blockNumber)
+
+	assert.Len(t, rawReceipts, 1)
+	assert.Equal(t, common.Hash{}, rawReceipts[0].TxHash)
+
+	cached := engine.CacheNoneTIPSigningTxs(&types.Header{Number: big.NewInt(int64(blockNumber))}, []*types.Transaction{signingTx}, rawReceipts)
+
+	assert.Len(t, cached, 1)
+	assert.Equal(t, signingTx.Hash(), cached[0].Hash())
+}