ACP-77: Implement Warp message verification

snow/snowtest/context.go

@@ -65,6 +65,9 @@ func Context(tb testing.TB, chainID ids.ID) *snow.Context {
 	require.NoError(aliaser.Alias(CChainID, CChainID.String()))
 
 	validatorState := &validatorstest.State{
+		GetMinimumHeightF: func(context.Context) (uint64, error) {
+			return 0, nil
+		},
 		GetSubnetIDF: func(_ context.Context, chainID ids.ID) (ids.ID, error) {
 			subnetID, ok := map[ids.ID]ids.ID{
 				constants.PlatformChainID: constants.PrimaryNetworkID,

tests/e2e/p/l1.go

@@ -50,6 +50,7 @@ const (
 	genesisWeight   = units.Schmeckle
 	genesisBalance  = units.Avax
 	registerWeight  = genesisWeight / 10
+	updatedWeight   = 2 * registerWeight
 	registerBalance = 0
 
 	// Validator registration attempts expire 5 minutes after they are created
@@ -300,6 +301,7 @@ var _ = e2e.DescribePChain("[L1]", func() {
 			registerWeight,
 		)
 		require.NoError(err)
+		registerValidationID := registerSubnetValidatorMessage.ValidationID()
 
 		tc.By("registering the validator", func() {
 			tc.By("creating the unsigned warp message")
@@ -365,6 +367,97 @@ var _ = e2e.DescribePChain("[L1]", func() {
 			})
 		})
 
+		var nextNonce uint64
+		setWeight := func(validationID ids.ID, weight uint64) {
+			tc.By("creating the unsigned SubnetValidatorWeightMessage")
+			unsignedSubnetValidatorWeight := must[*warp.UnsignedMessage](tc)(warp.NewUnsignedMessage(
+				networkID,
+				chainID,
+				must[*payload.AddressedCall](tc)(payload.NewAddressedCall(
+					address,
+					must[*warpmessage.SubnetValidatorWeight](tc)(warpmessage.NewSubnetValidatorWeight(
+						validationID,
+						nextNonce,
+						weight,
+					)).Bytes(),
+				)).Bytes(),
+			))
+
+			tc.By("sending the request to sign the warp message", func() {
+				setSubnetValidatorWeightRequest, err := wrapWarpSignatureRequest(
+					unsignedSubnetValidatorWeight,
+					nil,
+				)
+				require.NoError(err)
+
+				require.True(genesisPeer.Send(tc.DefaultContext(), setSubnetValidatorWeightRequest))
+			})
+
+			tc.By("getting the signature response")
+			setSubnetValidatorWeightSignature, ok, err := findMessage(genesisPeerMessages, unwrapWarpSignature)
+			require.NoError(err)
+			require.True(ok)
+
+			tc.By("creating the signed warp message to increase the weight of the validator")
+			setSubnetValidatorWeight, err := warp.NewMessage(
+				unsignedSubnetValidatorWeight,
+				&warp.BitSetSignature{
+					Signers: set.NewBits(0).Bytes(), // [signers] has weight from the genesis peer
+					Signature: ([bls.SignatureLen]byte)(
+						bls.SignatureToBytes(setSubnetValidatorWeightSignature),
+					),
+				},
+			)
+			require.NoError(err)
+
+			tc.By("issuing a SetSubnetValidatorWeightTx", func() {
+				_, err := pWallet.IssueSetSubnetValidatorWeightTx(
+					setSubnetValidatorWeight.Bytes(),
+				)
+				require.NoError(err)
+			})
+
+			nextNonce++
+		}
+
+		tc.By("increasing the weight of the validator", func() {
+			setWeight(registerValidationID, updatedWeight)
+		})
+
+		tc.By("verifying the validator weight was increased", func() {
+			tc.By("verifying the validator set was updated", func() {
+				verifyValidatorSet(map[ids.NodeID]*snowvalidators.GetValidatorOutput{
+					subnetGenesisNode.NodeID: {
+						NodeID:    subnetGenesisNode.NodeID,
+						PublicKey: genesisNodePK,
+						Weight:    genesisWeight,
+					},
+					ids.EmptyNodeID: { // The validator is not active
+						NodeID: ids.EmptyNodeID,
+						Weight: updatedWeight,
+					},
+				})
+			})
+		})
+
+		tc.By("advancing the proposervm P-chain height", advanceProposerVMPChainHeight)
+
+		tc.By("removing the registered validator", func() {
+			setWeight(registerValidationID, 0)
+		})
+
+		tc.By("verifying the validator was removed", func() {
+			tc.By("verifying the validator set was updated", func() {
+				verifyValidatorSet(map[ids.NodeID]*snowvalidators.GetValidatorOutput{
+					subnetGenesisNode.NodeID: {
+						NodeID:    subnetGenesisNode.NodeID,
+						PublicKey: genesisNodePK,
+						Weight:    genesisWeight,
+					},
+				})
+			})
+		})
+
 		genesisPeerMessages.Close()
 		genesisPeer.StartClose()
 		require.NoError(genesisPeer.AwaitClosed(tc.DefaultContext()))

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
@@ -208,10 +210,19 @@ 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,
+		&smblock.Context{
+			PChainHeight: 0,
+		},
+	)
+}
+
+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*/)
@@ -240,12 +251,14 @@ func (b *builder) BuildBlock(context.Context) (snowman.Block, error) {
 	}
 
 	statelessBlk, err := buildBlock(
+		ctx,
 		b,
 		preferredID,
 		nextHeight,
 		timestamp,
 		timeWasCapped,
 		preferredState,
+		blockContext.PChainHeight,
 	)
 	if err != nil {
 		return nil, err
@@ -270,59 +283,74 @@ func (b *builder) PackAllBlockTxs() ([]*txs.Tx, error) {
 		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,
 		)
 	}
@@ -368,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)
@@ -401,11 +431,13 @@ func packDurangoBlockTxs(
 		}
 
 		shouldAdd, err := executeTx(
+			ctx,
 			parentID,
 			stateDiff,
 			mempool,
 			backend,
 			manager,
+			pChainHeight,
 			&inputs,
 			feeCalculator,
 			tx,
@@ -425,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)
@@ -474,11 +508,13 @@ func packEtnaBlockTxs(
 		}
 
 		shouldAdd, err := executeTx(
+			ctx,
 			parentID,
 			stateDiff,
 			mempool,
 			backend,
 			manager,
+			pChainHeight,
 			&inputs,
 			feeCalculator,
 			tx,
@@ -498,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,
@@ -511,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