vms/platformvm: Verify txs before building a block

scripts/mocks.mockgen.txt

@@ -31,7 +31,6 @@ github.com/ava-labs/avalanchego/vms/avm/state=Chain,State,Diff=vms/avm/state/moc
 github.com/ava-labs/avalanchego/vms/avm/txs/mempool=Mempool=vms/avm/txs/mempool/mock_mempool.go
 github.com/ava-labs/avalanchego/vms/components/avax=TransferableIn=vms/components/avax/mock_transferable_in.go
 github.com/ava-labs/avalanchego/vms/components/verify=Verifiable=vms/components/verify/mock_verifiable.go
-github.com/ava-labs/avalanchego/vms/platformvm/block/executor=Manager=vms/platformvm/block/executor/mock_manager.go
 github.com/ava-labs/avalanchego/vms/platformvm/block=Block=vms/platformvm/block/mock_block.go
 github.com/ava-labs/avalanchego/vms/platformvm/state=Chain,Diff,State,Versions=vms/platformvm/state/mock_state.go
 github.com/ava-labs/avalanchego/vms/platformvm/state=StakerIterator=vms/platformvm/state/mock_staker_iterator.go

vms/platformvm/block/builder/builder.go

@@ -14,10 +14,12 @@ import (
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow/consensus/snowman"
+	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/utils/timer/mockable"
 	"github.com/ava-labs/avalanchego/utils/units"
 	"github.com/ava-labs/avalanchego/vms/platformvm/block"
 	"github.com/ava-labs/avalanchego/vms/platformvm/state"
+	"github.com/ava-labs/avalanchego/vms/platformvm/status"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/mempool"
 
@@ -192,16 +194,9 @@ func (b *builder) ShutdownBlockTimer() {
 // This method removes the transactions from the returned
 // blocks from the mempool.
 func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
-	defer func() {
-		// If we need to advance the chain's timestamp in a standard block, but
-		// we build an invalid block, then we need to re-trigger block building.
-		//
-		// TODO: Remove once we are guaranteed to build a valid block.
-		b.ResetBlockTimer()
-		// If there are still transactions in the mempool, then we need to
-		// re-trigger block building.
-		b.Mempool.RequestBuildBlock(false /*=emptyBlockPermitted*/)
-	}()
+	// If there are still transactions in the mempool, then we need to
+	// re-trigger block building.
+	defer b.Mempool.RequestBuildBlock(false /*=emptyBlockPermitted*/)
 
 	b.txExecutorBackend.Ctx.Log.Debug("starting to attempt to build a block")
 
@@ -237,6 +232,81 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 	return b.blkManager.NewBlock(statelessBlk), nil
 }
 
+func buildBlockTxs(mempool mempool.Mempool, backend *txexecutor.Backend, manager blockexecutor.Manager, timestamp time.Time) ([]*txs.Tx, error) {
+	preferredID := manager.Preferred()
+	stateDiff, err := state.NewDiff(preferredID, manager)
+	if err != nil {
+		return nil, err
+	}
+
+	changes, err := txexecutor.AdvanceTimeTo(backend, stateDiff, timestamp)
+	if err != nil {
+		return nil, err
+	}
+	changes.Apply(stateDiff)
+	stateDiff.SetTimestamp(timestamp)
+
+	var (
+		blockTxs      []*txs.Tx
+		inputs        set.Set[ids.ID]
+		remainingSize = targetBlockSize
+	)
+
+	for {
+		tx, exists := mempool.Peek()
+		if !exists || len(tx.Bytes()) > remainingSize {
+			break
+		}
+		mempool.Remove([]*txs.Tx{tx})
+
+		// Invariant: [tx] has already been syntactically verified.
+
+		txDiff, err := wrapState(stateDiff)
+		if err != nil {
+			return nil, err
+		}
+
+		executor := &txexecutor.StandardTxExecutor{
+			Backend: backend,
+			State:   txDiff,
+			Tx:      tx,
+		}
+
+		err = tx.Unsigned.Visit(executor)
+		if err != nil {
+			txID := tx.ID()
+			mempool.MarkDropped(txID, err)
+			continue
+		}
+
+		if inputs.Overlaps(executor.Inputs) {
+			txID := tx.ID()
+			mempool.MarkDropped(txID, blockexecutor.ErrConflictingBlockTxs)
+			continue
+		}
+		err = manager.VerifyUniqueInputs(preferredID, inputs)
+		if err != nil {
+			txID := tx.ID()
+			mempool.MarkDropped(txID, err)
+			continue
+		}
+		inputs.Union(executor.Inputs)
+
+		txDiff.AddTx(tx, status.Committed)
+		err = txDiff.Apply(stateDiff)
+		if err != nil {
+			txID := tx.ID()
+			mempool.MarkDropped(txID, err)
+			continue
+		}
+
+		remainingSize -= len(tx.Bytes())
+		blockTxs = append(blockTxs, tx)
+	}
+
+	return blockTxs, nil
+}
+
 // [timestamp] is min(max(now, parent timestamp), next staker change time)
 func buildBlock(
 	builder *builder,
@@ -259,38 +329,27 @@ func buildBlock(
 			return nil, fmt.Errorf("could not build tx to reward staker: %w", err)
 		}
 
+		blockTxs := []*txs.Tx{}
+		// TODO: Cleanup post-Durango
+		if builder.txExecutorBackend.Config.IsDurangoActivated(timestamp) {
+			blockTxs, err = buildBlockTxs(builder.Mempool, builder.txExecutorBackend, builder.blkManager, timestamp)
+			if err != nil {
+				return nil, fmt.Errorf("failed to build blockTxs: %w", err)
+			}
+		}
+
 		return block.NewBanffProposalBlock(
 			timestamp,
 			parentID,
 			height,
 			rewardValidatorTx,
-			[]*txs.Tx{}, // TODO: Populate with StandardBlock txs
-		)
-	}
-
-	// Clean out the mempool's transactions with invalid timestamps.
-	droppedStakerTxIDs := builder.Mempool.DropExpiredStakerTxs(timestamp.Add(txexecutor.SyncBound))
-	for _, txID := range droppedStakerTxIDs {
-		builder.txExecutorBackend.Ctx.Log.Debug("dropping tx",
-			zap.Stringer("txID", txID),
-			zap.Error(err),
+			blockTxs,
 		)
 	}
 
-	var (
-		blockTxs      []*txs.Tx
-		remainingSize = targetBlockSize
-	)
-
-	for {
-		tx, exists := builder.Mempool.Peek()
-		if !exists || len(tx.Bytes()) > remainingSize {
-			break
-		}
-		builder.Mempool.Remove([]*txs.Tx{tx})
-
-		remainingSize -= len(tx.Bytes())
-		blockTxs = append(blockTxs, tx)
+	blockTxs, err := buildBlockTxs(builder.Mempool, builder.txExecutorBackend, builder.blkManager, timestamp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build blockTxs: %w", err)
 	}
 
 	// If there is no reason to build a block, don't.
@@ -342,3 +401,17 @@ func getNextStakerToReward(
 	}
 	return ids.Empty, false, nil
 }
+
+type stateGetter struct {
+	state state.Chain
+}
+
+func (s stateGetter) GetState(ids.ID) (state.Chain, bool) {
+	return s.state, true
+}
+
+func wrapState(parentState state.Chain) (state.Diff, error) {
+	return state.NewDiff(ids.Empty, stateGetter{
+		state: parentState,
+	})
+}