PIP-74: state-sync txs inclusion

.gitignore

@@ -46,6 +46,9 @@ profile.cov
 
 tests/spec-tests/
 
+# Test output
+eth/tracers/data.csv
+
 # binaries
 cmd/abidump/abidump
 cmd/abigen/abigen

consensus/beacon/consensus.go

@@ -359,10 +359,9 @@ func (beacon *Beacon) Prepare(chain consensus.ChainHeaderReader, header *types.H
 }
 
 // Finalize implements consensus.Engine and processes withdrawals on top.
-func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body) {
+func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt {
 	if !beacon.IsPoSHeader(header) {
-		beacon.ethone.Finalize(chain, header, state, body)
-		return
+		return beacon.ethone.Finalize(chain, header, state, body, receipts)
 	}
 	// Withdrawals processing.
 	for _, w := range body.Withdrawals {
@@ -372,11 +371,12 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.
 		state.AddBalance(w.Address, amount, tracing.BalanceIncreaseWithdrawal)
 	}
 	// No block reward which is issued by consensus layer instead.
+	return receipts
 }
 
 // FinalizeAndAssemble implements consensus.Engine, setting the final state and
 // assembling the block.
-func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) {
+func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, []*types.Receipt, error) {
 	if !beacon.IsPoSHeader(header) {
 		return beacon.ethone.FinalizeAndAssemble(chain, header, state, body, receipts)
 	}
@@ -389,11 +389,11 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 		}
 	} else {
 		if len(body.Withdrawals) > 0 {
-			return nil, errors.New("withdrawals set before Shanghai activation")
+			return nil, nil, errors.New("withdrawals set before Shanghai activation")
 		}
 	}
 	// Finalize and assemble the block.
-	beacon.Finalize(chain, header, state, body)
+	receipts = beacon.Finalize(chain, header, state, body, receipts)
 
 	// Assign the final state root to header.
 	header.Root = state.IntermediateRoot(true)
@@ -409,15 +409,15 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 		// Open the pre-tree to prove the pre-state against
 		parent := chain.GetHeaderByNumber(header.Number.Uint64() - 1)
 		if parent == nil {
-			return nil, fmt.Errorf("nil parent header for block %d", header.Number)
+			return nil, nil, fmt.Errorf("nil parent header for block %d", header.Number)
 		}
 		preTrie, err := state.Database().OpenTrie(parent.Root)
 		if err != nil {
-			return nil, fmt.Errorf("error opening pre-state tree root: %w", err)
+			return nil, nil, fmt.Errorf("error opening pre-state tree root: %w", err)
 		}
 		postTrie := state.GetTrie()
 		if postTrie == nil {
-			return nil, errors.New("post-state tree is not available")
+			return nil, nil, errors.New("post-state tree is not available")
 		}
 		vktPreTrie, okpre := preTrie.(*trie.VerkleTrie)
 		vktPostTrie, okpost := postTrie.(*trie.VerkleTrie)
@@ -428,7 +428,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 			if len(keys) > 0 {
 				verkleProof, stateDiff, err := vktPreTrie.Proof(vktPostTrie, keys)
 				if err != nil {
-					return nil, fmt.Errorf("error generating verkle proof for block %d: %w", header.Number, err)
+					return nil, nil, fmt.Errorf("error generating verkle proof for block %d: %w", header.Number, err)
 				}
 				block = block.WithWitness(&types.ExecutionWitness{
 					StateDiff:   stateDiff,
@@ -438,7 +438,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 		}
 	}
 
-	return block, nil
+	return block, receipts, nil
 }
 
 // Seal generates a new sealing request for the given input block and pushes

consensus/bor/bor.go

@@ -3,7 +3,6 @@ package bor
 import (
 	"bytes"
 	"context"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -1030,13 +1029,13 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e
 
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
-func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header, wrappedState vm.StateDB, body *types.Body) {
+func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header, wrappedState vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt {
 	headerNumber := header.Number.Uint64()
 	if body.Withdrawals != nil || header.WithdrawalsHash != nil {
-		return
+		return nil
 	}
 	if header.RequestsHash != nil {
-		return
+		return nil
 	}
 
 	var (
@@ -1051,7 +1050,7 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 		if !c.config.IsRio(header.Number) {
 			if err := c.checkAndCommitSpan(wrappedState, header, cx); err != nil {
 				log.Error("Error while committing span", "error", err)
-				return
+				return nil
 			}
 		}
 
@@ -1060,10 +1059,9 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 			stateSyncData, err = c.CommitStates(wrappedState, header, cx)
 			if err != nil {
 				log.Error("Error while committing states", "error", err)
-				return
+				return nil
 			}
 		}
-
 		// Get the underlying state for updating consensus time
 		state := wrappedState.Inner()
 		state.BorConsensusTime = time.Since(start)
@@ -1074,12 +1072,60 @@ func (c *Bor) Finalize(chain consensus.ChainHeaderReader, header *types.Header,
 	// in tracing if it's enabled.
 	if err = c.changeContractCodeIfNeeded(headerNumber, wrappedState); err != nil {
 		log.Error("Error changing contract code", "error", err)
-		return
+		return nil
+	}
+
+	if len(stateSyncData) > 0 && c.config != nil && c.config.IsMadhugiri(header.Number) {
+		if len(body.Transactions) > 0 {
+			lastTx := body.Transactions[len(body.Transactions)-1]
+			if lastTx.Type() == types.StateSyncTxType {
+				receipts = insertStateSyncTransactionAndCalculateReceipt(lastTx, header, body, wrappedState, receipts)
+			}
+		}
+	} else {
+		// set state sync
+		hc := chain.(*core.HeaderChain)
+		hc.SetStateSync(stateSyncData)
+	}
+	return receipts
+}
+
+func insertStateSyncTransactionAndCalculateReceipt(stateSyncTx *types.Transaction, header *types.Header, body *types.Body, state vm.StateDB, receipts []*types.Receipt) []*types.Receipt {
+	allLogs := state.Logs()
+	sort.SliceStable(allLogs, func(i, j int) bool {
+		return allLogs[i].Index < allLogs[j].Index
+	})
+	logsFromReceiptCount := countLogsFromReceipts(receipts)
+	stateSyncLogs := allLogs[logsFromReceiptCount:]
+
+	txIndex := uint(len(body.Transactions) - 1)
+	for _, l := range stateSyncLogs {
+		l.TxIndex = txIndex
+	}
+
+	var cumulativeGasUsed uint64
+	if len(receipts) > 0 {
+		cumulativeGasUsed = receipts[len(receipts)-1].CumulativeGasUsed
+	}
+
+	stateSyncReceipt := &types.Receipt{
+		// Consensus fields
+		Type:              types.StateSyncTxType,
+		Status:            types.ReceiptStatusSuccessful,
+		CumulativeGasUsed: cumulativeGasUsed,
+		Logs:              stateSyncLogs,
+		// Implementation fields
+		TxHash:  stateSyncTx.Hash(),
+		GasUsed: 0,
+		// Inclusion information
+		BlockNumber:      header.Number,
+		TransactionIndex: txIndex,
 	}
 
-	// Set state sync data to blockchain
-	hc := chain.(*core.HeaderChain)
-	hc.SetStateSync(stateSyncData)
+	stateSyncReceipt.Bloom = types.CreateBloom(stateSyncReceipt)
+	receipts = append(receipts, stateSyncReceipt)
+
+	return receipts
 }
 
 func decodeGenesisAlloc(i interface{}) (types.GenesisAlloc, error) {
@@ -1122,13 +1168,13 @@ func (c *Bor) changeContractCodeIfNeeded(headerNumber uint64, state vm.StateDB)
 
 // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set,
 // nor block rewards given, and returns the final block.
-func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) {
+func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, []*types.Receipt, error) {
 	headerNumber := header.Number.Uint64()
 	if body.Withdrawals != nil || header.WithdrawalsHash != nil {
-		return nil, consensus.ErrUnexpectedWithdrawals
+		return nil, nil, consensus.ErrUnexpectedWithdrawals
 	}
 	if header.RequestsHash != nil {
-		return nil, consensus.ErrUnexpectedRequests
+		return nil, nil, consensus.ErrUnexpectedRequests
 	}
 
 	var (
@@ -1143,7 +1189,7 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 		if !c.config.IsRio(header.Number) {
 			if err = c.checkAndCommitSpan(state, header, cx); err != nil {
 				log.Error("Error while committing span", "error", err)
-				return nil, err
+				return nil, nil, err
 			}
 		}
 
@@ -1152,14 +1198,14 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 			stateSyncData, err = c.CommitStates(state, header, cx)
 			if err != nil {
 				log.Error("Error while committing states", "error", err)
-				return nil, err
+				return nil, nil, err
 			}
 		}
 	}
 
 	if err = c.changeContractCodeIfNeeded(headerNumber, state); err != nil {
 		log.Error("Error changing contract code", "error", err)
-		return nil, err
+		return nil, nil, err
 	}
 
 	// No block rewards in PoA, so the state remains as it is
@@ -1168,15 +1214,23 @@ func (c *Bor) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *typ
 	// Uncles are dropped
 	header.UncleHash = types.CalcUncleHash(nil)
 
+	if len(stateSyncData) > 0 && c.config != nil && c.config.IsMadhugiri(big.NewInt(int64(headerNumber))) {
+		stateSyncTx := types.NewTx(&types.StateSyncTx{
+			StateSyncData: stateSyncData,
+		})
+		body.Transactions = append(body.Transactions, stateSyncTx)
+		receipts = insertStateSyncTransactionAndCalculateReceipt(stateSyncTx, header, body, state, receipts)
+	} else {
+		// set state sync
+		bc := chain.(core.BorStateSyncer)
+		bc.SetStateSync(stateSyncData)
+	}
+
 	// Assemble block
 	block := types.NewBlock(header, body, receipts, trie.NewStackTrie(nil))
 
-	// set state sync
-	bc := chain.(core.BorStateSyncer)
-	bc.SetStateSync(stateSyncData)
-
 	// return the final block for sealing
-	return block, nil
+	return block, receipts, nil
 }
 
 // Authorize injects a private key into the consensus engine to mint new blocks
@@ -1596,7 +1650,7 @@ func (c *Bor) CommitStates(
 		stateData := types.StateSyncData{
 			ID:       eventRecord.ID,
 			Contract: eventRecord.Contract,
-			Data:     hex.EncodeToString(eventRecord.Data),
+			Data:     eventRecord.Data,
 			TxHash:   eventRecord.TxHash,
 		}
 
@@ -1729,3 +1783,13 @@ func getUpdatedValidatorSet(oldValidatorSet *valset.ValidatorSet, newVals []*val
 func IsSprintStart(number, sprint uint64) bool {
 	return number%sprint == 0
 }
+
+func countLogsFromReceipts(receipts []*types.Receipt) int {
+	total := 0
+	for _, receipt := range receipts {
+		if receipt != nil {
+			total += len(receipt.Logs)
+		}
+	}
+	return total
+}

consensus/bor/bor_test.go

@@ -141,7 +141,7 @@ func TestGenesisContractChange(t *testing.T) {
 			ParentHash: root,
 			Number:     big.NewInt(num),
 		}
-		b.Finalize(chain.HeaderChain(), h, statedb, &types.Body{Withdrawals: nil, Transactions: nil, Uncles: nil})
+		b.Finalize(chain.HeaderChain(), h, statedb, &types.Body{Withdrawals: nil, Transactions: nil, Uncles: nil}, nil)
 
 		// write state to database
 		root, err := statedb.Commit(0, false, true)

consensus/clique/clique.go

@@ -621,24 +621,25 @@ func (c *Clique) Prepare(chain consensus.ChainHeaderReader, header *types.Header
 
 // Finalize implements consensus.Engine. There is no post-transaction
 // consensus rules in clique, do nothing here.
-func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body) {
+func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt {
 	// No block rewards in PoA, so the state remains as is
+	return receipts
 }
 
 // FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set,
 // nor block rewards given, and returns the final block.
-func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) {
+func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, []*types.Receipt, error) {
 	if len(body.Withdrawals) > 0 {
-		return nil, errors.New("clique does not support withdrawals")
+		return nil, nil, errors.New("clique does not support withdrawals")
 	}
 	// Finalize block
-	c.Finalize(chain, header, state, body)
+	receipts = c.Finalize(chain, header, state, body, receipts)
 
 	// Assign the final state root to header.
 	header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
 
 	// Assemble and return the final block for sealing.
-	return types.NewBlock(header, &types.Body{Transactions: body.Transactions}, receipts, trie.NewStackTrie(nil)), nil
+	return types.NewBlock(header, &types.Body{Transactions: body.Transactions}, receipts, trie.NewStackTrie(nil)), receipts, nil
 }
 
 // Authorize injects a private key into the consensus engine to mint new blocks

consensus/consensus.go

@@ -90,14 +90,14 @@ type Engine interface {
 	//
 	// Note: The state database might be updated to reflect any consensus rules
 	// that happen at finalization (e.g. block rewards).
-	Finalize(chain ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body)
+	Finalize(chain ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt
 
 	// FinalizeAndAssemble runs any post-transaction state modifications (e.g. block
 	// rewards or process withdrawals) and assembles the final block.
 	//
 	// Note: The block header and state database might be updated to reflect any
 	// consensus rules that happen at finalization (e.g. block rewards).
-	FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error)
+	FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, []*types.Receipt, error)
 
 	// Seal generates a new sealing request for the given input block and pushes
 	// the result into the given channel.

consensus/ethash/consensus.go

@@ -505,25 +505,26 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H
 }
 
 // Finalize implements consensus.Engine, accumulating the block and uncle rewards.
-func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body) {
+func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body, receipts []*types.Receipt) []*types.Receipt {
 	// Accumulate any block and uncle rewards
 	accumulateRewards(chain.Config(), state, header, body.Uncles)
+	return receipts
 }
 
 // FinalizeAndAssemble implements consensus.Engine, accumulating the block and
 // uncle rewards, setting the final state and assembling the block.
-func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) {
+func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, []*types.Receipt, error) {
 	if len(body.Withdrawals) > 0 {
-		return nil, errors.New("ethash does not support withdrawals")
+		return nil, nil, errors.New("ethash does not support withdrawals")
 	}
 	// Finalize block
-	ethash.Finalize(chain, header, state, body)
+	ethash.Finalize(chain, header, state, body, receipts)
 
 	// Assign the final state root to header.
 	header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
 
 	// Header seems complete, assemble into a block and return
-	return types.NewBlock(header, &types.Body{Transactions: body.Transactions, Uncles: body.Uncles, Withdrawals: body.Withdrawals}, receipts, trie.NewStackTrie(nil)), nil
+	return types.NewBlock(header, &types.Body{Transactions: body.Transactions, Uncles: body.Uncles, Withdrawals: body.Withdrawals}, receipts, trie.NewStackTrie(nil)), receipts, nil
 }
 
 // SealHash returns the hash of a block prior to it being sealed.