feat: Basic integration for preconfirmed block

Author: infrmtcs

builder/builder.go

@@ -49,11 +49,11 @@ func New(
 	}
 }
 
-func (b *Builder) Finalise(pending *sync.Pending, signer utils.BlockSignFunc, privateKey *ecdsa.PrivateKey) error {
-	return b.blockchain.Finalise(pending.Block, pending.StateUpdate, pending.NewClasses, signer)
+func (b *Builder) Finalise(preconfirmed *core.PreConfirmed, signer utils.BlockSignFunc, privateKey *ecdsa.PrivateKey) error {
+	return b.blockchain.Finalise(preconfirmed.Block, preconfirmed.StateUpdate, preconfirmed.NewClasses, signer)
 }
 
-func (b *Builder) InitPendingBlock(params *BuildParams) (*BuildState, error) {
+func (b *Builder) InitPreconfirmedBlock(params *BuildParams) (*BuildState, error) {
 	header, err := b.blockchain.HeadsHeader()
 	if err != nil {
 		return nil, err
@@ -64,7 +64,7 @@ func (b *Builder) InitPendingBlock(params *BuildParams) (*BuildState, error) {
 		return nil, err
 	}
 
-	pendingBlock := core.Block{
+	preconfirmedBlock := core.Block{
 		Header: &core.Header{
 			Hash:             nil, // To be set after finishing execution
 			ParentHash:       header.Hash,
@@ -97,14 +97,16 @@ func (b *Builder) InitPendingBlock(params *BuildParams) (*BuildState, error) {
 	su := core.StateUpdate{
 		StateDiff: &emptyStateDiff,
 	}
-	pending := sync.Pending{
-		Block:       &pendingBlock,
-		StateUpdate: &su,
-		NewClasses:  newClasses,
+	preconfirmed := core.PreConfirmed{
+		Block:                 &preconfirmedBlock,
+		StateUpdate:           &su,
+		NewClasses:            newClasses,
+		TransactionStateDiffs: []*core.StateDiff{},
+		CandidateTxs:          []core.Transaction{},
 	}
 
 	return &BuildState{
-		Pending:           &pending,
+		Preconfirmed:      &preconfirmed,
 		RevealedBlockHash: revealedBlockHash,
 		L2GasConsumed:     0,
 	}, nil
@@ -123,7 +125,7 @@ func (b *Builder) getRevealedBlockHash(blockHeight uint64) (*felt.Felt, error) {
 }
 
 func (b *Builder) PendingState(buildState *BuildState) (core.StateReader, func() error, error) {
-	if buildState.Pending == nil {
+	if buildState.Preconfirmed == nil {
 		return nil, nil, sync.ErrPendingBlockNotFound
 	}
 
@@ -133,7 +135,7 @@ func (b *Builder) PendingState(buildState *BuildState) (core.StateReader, func()
 	}
 
 	// TODO: remove the state closer once we refactor the state
-	return sync.NewPendingState(buildState.Pending.StateUpdate.StateDiff, buildState.Pending.NewClasses, headState), headCloser, nil
+	return sync.NewPendingState(buildState.Preconfirmed.StateUpdate.StateDiff, buildState.Preconfirmed.NewClasses, headState), headCloser, nil
 }
 
 func (b *Builder) RunTxns(state *BuildState, txns []mempool.BroadcastedTransaction) error {
@@ -160,7 +162,7 @@ func (b *Builder) Finish(state *BuildState) (BuildResult, error) {
 
 	// Todo: we ignore some values until the spec is Finalised: VersionConstantCommitment, NextL2GasPriceFRI
 	buildResult := BuildResult{
-		Pending:        state.Pending,
+		Preconfirmed:   state.Preconfirmed,
 		SimulateResult: &simulatedResult,
 		L2GasConsumed:  state.L2GasConsumed,
 	}

builder/executor.go

@@ -41,7 +41,7 @@ func NewExecutor(
 }
 
 // RunTxns executes the provided transaction and applies the state changes
-// to the pending state
+// to the preconfirmed state
 func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransaction) (err error) {
 	if len(txns) == 0 {
 		return nil
@@ -58,7 +58,7 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 	}()
 
 	// Create a state writer for the transaction execution
-	stateWriter := sync.NewPendingStateWriter(state.Pending.StateUpdate.StateDiff, state.Pending.NewClasses, headState)
+	stateWriter := sync.NewPendingStateWriter(state.Preconfirmed.StateUpdate.StateDiff, state.Preconfirmed.NewClasses, headState)
 
 	// Prepare declared classes, if any
 	var declaredClasses []core.Class
@@ -80,7 +80,7 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 		declaredClasses,
 		paidFeesOnL1,
 		&vm.BlockInfo{
-			Header:                state.Pending.Block.Header,
+			Header:                state.Preconfirmed.Block.Header,
 			BlockHashToBeRevealed: state.RevealedBlockHash,
 		},
 		stateWriter,
@@ -102,16 +102,16 @@ func (e *executor) RunTxns(state *BuildState, txns []mempool.BroadcastedTransact
 
 	// Adapt results to core type (which use reference types)
 	receipts := make([]*core.TransactionReceipt, len(txns))
-	mergedStateDiff := vm2core.AdaptStateDiff(vmResults.Traces[0].StateDiff)
+	stateDiffs := make([]*core.StateDiff, len(vmResults.Traces))
 	for i, trace := range vmResults.Traces {
 		adaptedStateDiff := vm2core.AdaptStateDiff(trace.StateDiff)
-		mergedStateDiff.Merge(&adaptedStateDiff)
 		adaptedReceipt := vm2core.Receipt(vmResults.OverallFees[i], txns[i].Transaction, &vmResults.Traces[i], &vmResults.Receipts[i])
 		receipts[i] = &adaptedReceipt
+		stateDiffs[i] = &adaptedStateDiff
 	}
 
-	// Update pending block with transaction results
-	updatePendingBlock(state.Pending, receipts, coreTxns, mergedStateDiff)
+	// Update preconfirmed block with transaction results
+	updatePreconfirmedBlock(state.Preconfirmed, receipts, coreTxns, stateDiffs)
 
 	for i := range vmResults.GasConsumed {
 		state.L2GasConsumed += vmResults.GasConsumed[i].L2Gas
@@ -138,22 +138,25 @@ func (e *executor) processClassDeclaration(txn *mempool.BroadcastedTransaction,
 	return nil
 }
 
-// updatePendingBlock updates the pending block with transaction results
-func updatePendingBlock(
-	pending *sync.Pending,
+// updatePreconfirmedBlock updates the preconfirmed block with transaction results
+func updatePreconfirmedBlock(
+	preconfirmed *core.PreConfirmed,
 	receipts []*core.TransactionReceipt,
 	transactions []core.Transaction,
-	stateDiff core.StateDiff,
+	stateDiffs []*core.StateDiff,
 ) {
-	pending.Block.Receipts = append(pending.Block.Receipts, receipts...)
-	pending.Block.Transactions = append(pending.Block.Transactions, transactions...)
-	pending.Block.TransactionCount += uint64(len(transactions))
+	preconfirmed.Block.Receipts = append(preconfirmed.Block.Receipts, receipts...)
+	preconfirmed.TransactionStateDiffs = append(preconfirmed.TransactionStateDiffs, stateDiffs...)
+	preconfirmed.Block.Transactions = append(preconfirmed.Block.Transactions, transactions...)
+	preconfirmed.Block.TransactionCount += uint64(len(transactions))
 	for _, receipt := range receipts {
-		pending.Block.EventCount += uint64(len(receipt.Events))
+		preconfirmed.Block.EventCount += uint64(len(receipt.Events))
+	}
+	for _, stateDiff := range stateDiffs {
+		preconfirmed.StateUpdate.StateDiff.Merge(stateDiff)
 	}
-	pending.StateUpdate.StateDiff.Merge(&stateDiff)
 }
 
 func (e *executor) Finish(state *BuildState) (blockchain.SimulateResult, error) {
-	return e.blockchain.Simulate(state.Pending.Block, state.Pending.StateUpdate, state.Pending.NewClasses, nil)
+	return e.blockchain.Simulate(state.Preconfirmed.Block, state.Preconfirmed.StateUpdate, state.Preconfirmed.NewClasses, nil)
 }

builder/result.go

@@ -4,38 +4,38 @@ import (
 	"github.com/Masterminds/semver/v3"
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/consensus/types"
+	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/sync"
 )
 
 type BuildResult struct {
-	Pending        *sync.Pending
+	Preconfirmed   *core.PreConfirmed
 	SimulateResult *blockchain.SimulateResult
 	L2GasConsumed  uint64
 }
 
 func (b *BuildResult) ProposalCommitment() (types.ProposalCommitment, error) {
-	version, err := semver.NewVersion(b.Pending.Block.ProtocolVersion)
+	version, err := semver.NewVersion(b.Preconfirmed.Block.ProtocolVersion)
 	if err != nil {
 		return types.ProposalCommitment{}, err
 	}
 
 	return types.ProposalCommitment{
-		BlockNumber:           b.Pending.Block.Number,
-		Builder:               *b.Pending.Block.SequencerAddress,
-		ParentCommitment:      *b.Pending.Block.ParentHash,
-		Timestamp:             b.Pending.Block.Timestamp,
+		BlockNumber:           b.Preconfirmed.Block.Number,
+		Builder:               *b.Preconfirmed.Block.SequencerAddress,
+		ParentCommitment:      *b.Preconfirmed.Block.ParentHash,
+		Timestamp:             b.Preconfirmed.Block.Timestamp,
 		ProtocolVersion:       *version,
-		OldStateRoot:          *b.Pending.StateUpdate.OldRoot,
+		OldStateRoot:          *b.Preconfirmed.StateUpdate.OldRoot,
 		StateDiffCommitment:   *b.SimulateResult.BlockCommitments.StateDiffCommitment,
 		TransactionCommitment: *b.SimulateResult.BlockCommitments.TransactionCommitment,
 		EventCommitment:       *b.SimulateResult.BlockCommitments.EventCommitment,
 		ReceiptCommitment:     *b.SimulateResult.BlockCommitments.ReceiptCommitment,
 		ConcatenatedCounts:    b.SimulateResult.ConcatCount,
-		L1GasPriceFRI:         *b.Pending.Block.L1GasPriceSTRK,
-		L1DataGasPriceFRI:     *b.Pending.Block.L1DataGasPrice.PriceInFri,
-		L2GasPriceFRI:         *b.Pending.Block.L2GasPrice.PriceInFri,
+		L1GasPriceFRI:         *b.Preconfirmed.Block.L1GasPriceSTRK,
+		L1DataGasPriceFRI:     *b.Preconfirmed.Block.L1DataGasPrice.PriceInFri,
+		L2GasPriceFRI:         *b.Preconfirmed.Block.L2GasPrice.PriceInFri,
 		L2GasUsed:             *new(felt.Felt).SetUint64(b.L2GasConsumed),
-		L1DAMode:              b.Pending.Block.L1DAMode,
+		L1DAMode:              b.Preconfirmed.Block.L1DAMode,
 	}, nil
 }

builder/state.go

@@ -6,26 +6,25 @@ import (
 
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/sync"
 	"github.com/NethermindEth/juno/utils"
 )
 
 type BuildState struct {
-	Pending           *sync.Pending
+	Preconfirmed      *core.PreConfirmed
 	L2GasConsumed     uint64
 	RevealedBlockHash *felt.Felt
 }
 
 func (b *BuildState) PendingBlock() *core.Block {
-	if b.Pending == nil {
+	if b.Preconfirmed == nil {
 		return nil
 	}
-	return b.Pending.Block
+	return b.Preconfirmed.Block
 }
 
 func (b *BuildState) ClearPending() error {
 	b.L2GasConsumed = 0
-	b.Pending = &sync.Pending{}
+	b.Preconfirmed = &core.PreConfirmed{}
 	b.RevealedBlockHash = nil
 
 	return nil
@@ -38,25 +37,27 @@ func (b *BuildState) ClearPending() error {
 // - Signatures and EventsBloom are not set before `Finish` is called
 func (b *BuildState) Clone() BuildState {
 	return BuildState{
-		Pending:           clonePending(b.Pending),
+		Preconfirmed:      clonePreconfirmed(b.Preconfirmed),
 		RevealedBlockHash: b.RevealedBlockHash, // Safe to reuse an immutable value
 		L2GasConsumed:     b.L2GasConsumed,     // Value, safe to shallow copy
 	}
 }
 
-func clonePending(pending *sync.Pending) *sync.Pending {
-	return &sync.Pending{
-		Block:       cloneBlock(pending.Block),
-		StateUpdate: cloneStateUpdate(pending.StateUpdate),
-		NewClasses:  maps.Clone(pending.NewClasses),
+func clonePreconfirmed(preconfirmed *core.PreConfirmed) *core.PreConfirmed {
+	return &core.PreConfirmed{
+		Block:                 cloneBlock(preconfirmed.Block),
+		StateUpdate:           cloneStateUpdate(preconfirmed.StateUpdate),
+		NewClasses:            maps.Clone(preconfirmed.NewClasses),
+		TransactionStateDiffs: preconfirmed.TransactionStateDiffs,
+		CandidateTxs:          preconfirmed.CandidateTxs,
 	}
 }
 
 func cloneBlock(block *core.Block) *core.Block {
 	return &core.Block{
 		Header:       utils.HeapPtr(*block.Header),
-		Transactions: slices.Clone(block.Transactions),
-		Receipts:     slices.Clone(block.Receipts),
+		Transactions: block.Transactions,
+		Receipts:     block.Receipts,
 	}
 }
 

consensus/datasource/consensus_data_source.go

@@ -70,9 +70,9 @@ func (c *consensusDataSource[V, H, A]) BlockLatest(ctx context.Context) (*core.B
 }
 
 func (c *consensusDataSource[V, H, A]) BlockPending(ctx context.Context) (sync.Pending, error) {
-	return *c.proposer.Pending(), nil
+	return sync.Pending{}, errors.New("not implemented") // TODO: Revise this
 }
 
 func (c *consensusDataSource[V, H, A]) PreConfirmedBlockByNumber(ctx context.Context, blockNumber uint64) (core.PreConfirmed, error) {
-	return core.PreConfirmed{}, errors.New("not implemented") // TODO: Implement this
+	return *c.proposer.Preconfirmed(), nil
 }

consensus/driver/commit_listener.go

@@ -52,9 +52,9 @@ func (b *commitListener[V, H, A]) Commit(ctx context.Context, height types.Heigh
 	}
 
 	committedBlock := sync.CommittedBlock{
-		Block:       buildResult.Pending.Block,
-		StateUpdate: buildResult.Pending.StateUpdate,
-		NewClasses:  buildResult.Pending.NewClasses,
+		Block:       buildResult.Preconfirmed.Block,
+		StateUpdate: buildResult.Preconfirmed.StateUpdate,
+		NewClasses:  buildResult.Preconfirmed.NewClasses,
 		Persisted:   make(chan struct{}),
 	}
 

consensus/p2p/proposer/proposer_adapter.go

@@ -36,36 +36,36 @@ func (a *starknetProposerAdapter) ProposalInit(proposal *starknet.Proposal) (typ
 // TODO: Implement this function properly
 func (a *starknetProposerAdapter) ProposalBlockInfo(buildResult *builder.BuildResult) (types.BlockInfo, error) {
 	return types.BlockInfo{
-		BlockNumber:       buildResult.Pending.Block.Number,
-		Builder:           *buildResult.Pending.Block.SequencerAddress,
-		Timestamp:         buildResult.Pending.Block.Timestamp,
-		L2GasPriceFRI:     *buildResult.Pending.Block.L2GasPrice.PriceInFri,
-		L1GasPriceWEI:     *buildResult.Pending.Block.L1GasPriceSTRK,
-		L1DataGasPriceWEI: *buildResult.Pending.Block.L1DataGasPrice.PriceInFri,
+		BlockNumber:       buildResult.Preconfirmed.Block.Number,
+		Builder:           *buildResult.Preconfirmed.Block.SequencerAddress,
+		Timestamp:         buildResult.Preconfirmed.Block.Timestamp,
+		L2GasPriceFRI:     *buildResult.Preconfirmed.Block.L2GasPrice.PriceInFri,
+		L1GasPriceWEI:     *buildResult.Preconfirmed.Block.L1GasPriceSTRK,
+		L1DataGasPriceWEI: *buildResult.Preconfirmed.Block.L1DataGasPrice.PriceInFri,
 		EthToStrkRate:     felt.One, // TODO: Double check if this is used
-		L1DAMode:          buildResult.Pending.Block.L1DAMode,
+		L1DAMode:          buildResult.Preconfirmed.Block.L1DAMode,
 	}, nil
 }
 
 // TODO: Implement this function properly
 func (a *starknetProposerAdapter) ProposalTransactions(buildResult *builder.BuildResult) ([]types.Transaction, error) {
-	transactions := make([]types.Transaction, len(buildResult.Pending.Block.Transactions))
-	for i := range buildResult.Pending.Block.Transactions {
+	transactions := make([]types.Transaction, len(buildResult.Preconfirmed.Block.Transactions))
+	for i := range buildResult.Preconfirmed.Block.Transactions {
 		var class core.Class
 		var paidFeeOnL1 *felt.Felt
 
-		switch tx := buildResult.Pending.Block.Transactions[i].(type) {
+		switch tx := buildResult.Preconfirmed.Block.Transactions[i].(type) {
 		case *core.DeclareTransaction:
 			var ok bool
-			if class, ok = buildResult.Pending.NewClasses[*tx.ClassHash]; !ok {
+			if class, ok = buildResult.Preconfirmed.NewClasses[*tx.ClassHash]; !ok {
 				return nil, errors.New("class not found")
 			}
 		case *core.L1HandlerTransaction:
 			paidFeeOnL1 = felt.One.Clone()
 		}
 
 		transactions[i] = types.Transaction{
-			Transaction: buildResult.Pending.Block.Transactions[i],
+			Transaction: buildResult.Preconfirmed.Block.Transactions[i],
 			Class:       class,
 			PaidFeeOnL1: paidFeeOnL1,
 		}

consensus/p2p/validator/empty_fixtures_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/db"
-	"github.com/NethermindEth/juno/sync"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
 	"github.com/starknet-io/starknet-p2pspecs/p2p/proto/consensus/consensus"
@@ -93,7 +92,7 @@ func NewEmptyTestFixture(
 
 func EmptyBuildResult(headBlock *core.Block, proposer, expectedHash *felt.Felt, timestamp uint64) builder.BuildResult {
 	return builder.BuildResult{
-		Pending: &sync.Pending{
+		Preconfirmed: &core.PreConfirmed{
 			Block: &core.Block{
 				Header: &core.Header{
 					Hash:             expectedHash,
@@ -126,7 +125,9 @@ func EmptyBuildResult(headBlock *core.Block, proposer, expectedHash *felt.Felt,
 				OldRoot:   headBlock.GlobalStateRoot,
 				StateDiff: utils.HeapPtr(core.EmptyStateDiff()),
 			},
-			NewClasses: make(map[felt.Felt]core.Class),
+			NewClasses:            make(map[felt.Felt]core.Class),
+			TransactionStateDiffs: []*core.StateDiff{},
+			CandidateTxs:          []core.Transaction{},
 		},
 		SimulateResult: &blockchain.SimulateResult{
 			BlockCommitments: &core.BlockCommitments{