ACP-77: Implement Warp message verification

database/helpers.go

@@ -54,6 +54,14 @@ func GetUInt64(db KeyValueReader, key []byte) (uint64, error) {
 	return ParseUInt64(b)
 }
 
+func GetOrDefaultUInt64(db KeyValueReader, key []byte, def uint64) (uint64, error) {
+	v, err := GetUInt64(db, key)
+	if err == ErrNotFound {
+		return def, nil
+	}
+	return v, err
+}
+
 func PackUInt64(val uint64) []byte {
 	bytes := make([]byte, Uint64Size)
 	binary.BigEndian.PutUint64(bytes, val)

ids/id.go

@@ -107,6 +107,22 @@ func (id ID) Prefix(prefixes ...uint64) ID {
 	return hashing.ComputeHash256Array(packer.Bytes)
 }
 
+// Append this id to create a more selective id.
+//
+// This is used to generate the ACP-77 validationIDs.
+func (id ID) Append(suffixes ...uint32) ID {
+	packer := wrappers.Packer{
+		Bytes: make([]byte, IDLen+len(suffixes)*wrappers.IntLen),
+	}
+
+	packer.PackFixedBytes(id[:])
+	for _, suffix := range suffixes {
+		packer.PackInt(suffix)
+	}
+
+	return hashing.ComputeHash256Array(packer.Bytes)
+}
+
 // XOR this id and the provided id and return the resulting id.
 //
 // Note: this id is not modified.

snow/engine/snowman/engine.go

@@ -176,7 +176,7 @@ func (e *Engine) Gossip(ctx context.Context) error {
 	// nodes with a large amount of stake weight.
 	vdrID, ok := e.ConnectedValidators.SampleValidator()
 	if !ok {
-		e.Ctx.Log.Warn("skipping block gossip",
+		e.Ctx.Log.Debug("skipping block gossip",
 			zap.String("reason", "no connected validators"),
 		)
 		return nil

upgrade/upgrade.go

@@ -72,7 +72,7 @@ var (
 		DurangoTime:                  InitiallyActiveTime,
 		// Etna is left unactivated by default on local networks. It can be configured to
 		// activate by overriding the activation time in the upgrade file.
-		EtnaTime: UnscheduledActivationTime,
+		EtnaTime: InitiallyActiveTime,
 	}
 
 	ErrInvalidUpgradeTimes = errors.New("invalid upgrade configuration")

vms/platformvm/block/builder/builder.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/fee"
 	"github.com/ava-labs/avalanchego/vms/platformvm/txs/mempool"
 
+	smblock "github.com/ava-labs/avalanchego/snow/engine/snowman/block"
 	blockexecutor "github.com/ava-labs/avalanchego/vms/platformvm/block/executor"
 	txexecutor "github.com/ava-labs/avalanchego/vms/platformvm/txs/executor"
 )
@@ -51,6 +52,7 @@ var (
 )
 
 type Builder interface {
+	smblock.BuildBlockWithContextChainVM
 	mempool.Mempool
 
 	// StartBlockTimer starts to issue block creation requests to advance the
@@ -182,7 +184,11 @@ func (b *builder) durationToSleep() (time.Duration, error) {
 
 	now := b.txExecutorBackend.Clk.Time()
 	maxTimeToAwake := now.Add(maxTimeToSleep)
-	nextStakerChangeTime, err := state.GetNextStakerChangeTime(preferredState, maxTimeToAwake)
+	nextStakerChangeTime, err := state.GetNextStakerChangeTime(
+		b.txExecutorBackend.Config.ValidatorFeeConfig,
+		preferredState,
+		maxTimeToAwake,
+	)
 	if err != nil {
 		return 0, fmt.Errorf("%w of %s: %w", errCalculatingNextStakerTime, preferredID, err)
 	}
@@ -204,10 +210,14 @@ func (b *builder) ShutdownBlockTimer() {
 	})
 }
 
-// BuildBlock builds a block to be added to consensus.
-// This method removes the transactions from the returned
-// blocks from the mempool.
-func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
+func (b *builder) BuildBlock(ctx context.Context) (snowman.Block, error) {
+	return b.BuildBlockWithContext(ctx, nil)
+}
+
+func (b *builder) BuildBlockWithContext(
+	ctx context.Context,
+	blockContext *smblock.Context,
+) (snowman.Block, error) {
 	// If there are still transactions in the mempool, then we need to
 	// re-trigger block building.
 	defer b.Mempool.RequestBuildBlock(false /*=emptyBlockPermitted*/)
@@ -226,18 +236,29 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 		return nil, fmt.Errorf("%w: %s", state.ErrMissingParentState, preferredID)
 	}
 
-	timestamp, timeWasCapped, err := state.NextBlockTime(preferredState, b.txExecutorBackend.Clk)
+	timestamp, timeWasCapped, err := state.NextBlockTime(
+		b.txExecutorBackend.Config.ValidatorFeeConfig,
+		preferredState,
+		b.txExecutorBackend.Clk,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("could not calculate next staker change time: %w", err)
 	}
 
+	var pChainHeight uint64
+	if blockContext != nil {
+		pChainHeight = blockContext.PChainHeight
+	}
+
 	statelessBlk, err := buildBlock(
+		ctx,
 		b,
 		preferredID,
 		nextHeight,
 		timestamp,
 		timeWasCapped,
 		preferredState,
+		pChainHeight,
 	)
 	if err != nil {
 		return nil, err
@@ -253,64 +274,83 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) {
 		return nil, fmt.Errorf("%w: %s", errMissingPreferredState, preferredID)
 	}
 
-	timestamp, _, err := state.NextBlockTime(preferredState, b.txExecutorBackend.Clk)
+	timestamp, _, err := state.NextBlockTime(
+		b.txExecutorBackend.Config.ValidatorFeeConfig,
+		preferredState,
+		b.txExecutorBackend.Clk,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("could not calculate next staker change time: %w", err)
 	}
 
+	recommendedPChainHeight, err := b.txExecutorBackend.Ctx.ValidatorState.GetMinimumHeight(context.TODO())
+	if err != nil {
+		return nil, err
+	}
+
 	if !b.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) {
 		return packDurangoBlockTxs(
+			context.TODO(),
 			preferredID,
 			preferredState,
 			b.Mempool,
 			b.txExecutorBackend,
 			b.blkManager,
 			timestamp,
+			recommendedPChainHeight,
 			math.MaxInt,
 		)
 	}
 	return packEtnaBlockTxs(
+		context.TODO(),
 		preferredID,
 		preferredState,
 		b.Mempool,
 		b.txExecutorBackend,
 		b.blkManager,
 		timestamp,
+		recommendedPChainHeight,
 		math.MaxUint64,
 	)
 }
 
 // [timestamp] is min(max(now, parent timestamp), next staker change time)
 func buildBlock(
+	ctx context.Context,
 	builder *builder,
 	parentID ids.ID,
 	height uint64,
 	timestamp time.Time,
 	forceAdvanceTime bool,
 	parentState state.Chain,
+	pChainHeight uint64,
 ) (block.Block, error) {
 	var (
 		blockTxs []*txs.Tx
 		err      error
 	)
 	if builder.txExecutorBackend.Config.UpgradeConfig.IsEtnaActivated(timestamp) {
 		blockTxs, err = packEtnaBlockTxs(
+			ctx,
 			parentID,
 			parentState,
 			builder.Mempool,
 			builder.txExecutorBackend,
 			builder.blkManager,
 			timestamp,
+			pChainHeight,
 			0, // minCapacity is 0 as we want to honor the capacity in state.
 		)
 	} else {
 		blockTxs, err = packDurangoBlockTxs(
+			ctx,
 			parentID,
 			parentState,
 			builder.Mempool,
 			builder.txExecutorBackend,
 			builder.blkManager,
 			timestamp,
+			pChainHeight,
 			targetBlockSize,
 		)
 	}
@@ -356,12 +396,14 @@ func buildBlock(
 }
 
 func packDurangoBlockTxs(
+	ctx context.Context,
 	parentID ids.ID,
 	parentState state.Chain,
 	mempool mempool.Mempool,
 	backend *txexecutor.Backend,
 	manager blockexecutor.Manager,
 	timestamp time.Time,
+	pChainHeight uint64,
 	remainingSize int,
 ) ([]*txs.Tx, error) {
 	stateDiff, err := state.NewDiffOn(parentState)
@@ -389,11 +431,13 @@ func packDurangoBlockTxs(
 		}
 
 		shouldAdd, err := executeTx(
+			ctx,
 			parentID,
 			stateDiff,
 			mempool,
 			backend,
 			manager,
+			pChainHeight,
 			&inputs,
 			feeCalculator,
 			tx,
@@ -413,12 +457,14 @@ func packDurangoBlockTxs(
 }
 
 func packEtnaBlockTxs(
+	ctx context.Context,
 	parentID ids.ID,
 	parentState state.Chain,
 	mempool mempool.Mempool,
 	backend *txexecutor.Backend,
 	manager blockexecutor.Manager,
 	timestamp time.Time,
+	pChainHeight uint64,
 	minCapacity gas.Gas,
 ) ([]*txs.Tx, error) {
 	stateDiff, err := state.NewDiffOn(parentState)
@@ -462,11 +508,13 @@ func packEtnaBlockTxs(
 		}
 
 		shouldAdd, err := executeTx(
+			ctx,
 			parentID,
 			stateDiff,
 			mempool,
 			backend,
 			manager,
+			pChainHeight,
 			&inputs,
 			feeCalculator,
 			tx,
@@ -486,11 +534,13 @@ func packEtnaBlockTxs(
 }
 
 func executeTx(
+	ctx context.Context,
 	parentID ids.ID,
 	stateDiff state.Diff,
 	mempool mempool.Mempool,
 	backend *txexecutor.Backend,
 	manager blockexecutor.Manager,
+	pChainHeight uint64,
 	inputs *set.Set[ids.ID],
 	feeCalculator fee.Calculator,
 	tx *txs.Tx,
@@ -499,6 +549,19 @@ func executeTx(
 
 	// Invariant: [tx] has already been syntactically verified.
 
+	err := txexecutor.VerifyWarpMessages(
+		ctx,
+		backend.Ctx.NetworkID,
+		backend.Ctx.ValidatorState,
+		pChainHeight,
+		tx.Unsigned,
+	)
+	if err != nil {
+		txID := tx.ID()
+		mempool.MarkDropped(txID, err)
+		return false, nil
+	}
+
 	txDiff, err := state.NewDiffOn(stateDiff)
 	if err != nil {
 		return false, err

vms/platformvm/block/executor/block.go

@@ -29,25 +29,49 @@ func (*Block) ShouldVerifyWithContext(context.Context) (bool, error) {
 	return true, nil
 }
 
-func (b *Block) VerifyWithContext(_ context.Context, ctx *smblock.Context) error {
-	pChainHeight := uint64(0)
-	if ctx != nil {
-		pChainHeight = ctx.PChainHeight
+func (b *Block) VerifyWithContext(ctx context.Context, blockContext *smblock.Context) error {
+	var pChainHeight uint64
+	if blockContext != nil {
+		pChainHeight = blockContext.PChainHeight
 	}
 
 	blkID := b.ID()
 	if blkState, ok := b.manager.blkIDToState[blkID]; ok {
 		if !blkState.verifiedHeights.Contains(pChainHeight) {
-			// PlatformVM blocks are currently valid regardless of the ProposerVM's
-			// PChainHeight. If this changes, those validity checks should be done prior
-			// to adding [pChainHeight] to [verifiedHeights].
+			// Only the validity of warp messages need to be verified because
+			// this block has already passed verification with a different
+			// height.
+			err := VerifyWarpMessages(
+				ctx,
+				b.manager.ctx.NetworkID,
+				b.manager.ctx.ValidatorState,
+				pChainHeight,
+				b,
+			)
+			if err != nil {
+				return err
+			}
+
 			blkState.verifiedHeights.Add(pChainHeight)
 		}
 
-		// This block has already been verified.
-		return nil
+		return nil // This block has already been executed.
+	}
+
+	// Verify the warp messages in the block.
+	err := VerifyWarpMessages(
+		ctx,
+		b.manager.ctx.NetworkID,
+		b.manager.ctx.ValidatorState,
+		pChainHeight,
+		b,
+	)
+	if err != nil {
+		return err
 	}
 
+	// Since the warp messages are valid, we need to execute the rest of the
+	// validity checks.
 	return b.Visit(&verifier{
 		backend:           b.manager.backend,
 		txExecutorBackend: b.manager.txExecutorBackend,