Minimize signature verification when bootstrapping

chains/manager.go

@@ -787,9 +787,7 @@ func (m *manager) createAvalancheChain(
 		return nil, err
 	}
 
-	// Note: vmWrappingProposerVM is the VM that the Snowman engines should be
-	// using.
-	var vmWrappingProposerVM block.ChainVM = proposervm.New(
+	proposerVM := proposervm.New(
 		vmWrappedInsideProposerVM,
 		proposervm.Config{
 			Upgrades:            m.Upgrades,
@@ -801,6 +799,10 @@ func (m *manager) createAvalancheChain(
 		},
 	)
 
+	// Note: vmWrappingProposerVM is the VM that the Snowman engines should be
+	// using.
+	var vmWrappingProposerVM block.ChainVM = proposerVM
+
 	if m.MeterVMEnabled {
 		meterchainvmReg, err := metrics.MakeAndRegister(
 			m.meterChainVMGatherer,
@@ -948,6 +950,7 @@ func (m *manager) createAvalancheChain(
 
 	// create bootstrap gear
 	bootstrapCfg := smbootstrap.Config{
+		NonVerifyingParse:              block.ParseFunc(proposerVM.ParseLocalBlock),
 		AllGetsServer:                  snowGetHandler,
 		Ctx:                            ctx,
 		Beacons:                        vdrs,
@@ -1184,7 +1187,7 @@ func (m *manager) createSnowmanChain(
 		return nil, err
 	}
 
-	vm = proposervm.New(
+	proposerVM := proposervm.New(
 		vm,
 		proposervm.Config{
 			Upgrades:            m.Upgrades,
@@ -1196,6 +1199,8 @@ func (m *manager) createSnowmanChain(
 		},
 	)
 
+	vm = proposerVM
+
 	if m.MeterVMEnabled {
 		meterchainvmReg, err := metrics.MakeAndRegister(
 			m.meterChainVMGatherer,
@@ -1345,6 +1350,7 @@ func (m *manager) createSnowmanChain(
 
 	// create bootstrap gear
 	bootstrapCfg := smbootstrap.Config{
+		NonVerifyingParse:              block.ParseFunc(proposerVM.ParseLocalBlock),
 		AllGetsServer:                  snowGetHandler,
 		Ctx:                            ctx,
 		Beacons:                        beacons,

snow/engine/snowman/block/vm.go

@@ -83,3 +83,11 @@ type Parser interface {
 	// It is expected for all historical blocks to be parseable.
 	ParseBlock(ctx context.Context, blockBytes []byte) (snowman.Block, error)
 }
+
+// ParseFunc defines a function that parses raw bytes into a block.
+type ParseFunc func(context.Context, []byte) (snowman.Block, error)
+
+// ParseBlock wraps a ParseFunc into a ParseBlock function, to be used by a Parser interface
+func (f ParseFunc) ParseBlock(ctx context.Context, blockBytes []byte) (snowman.Block, error) {
+	return f(ctx, blockBytes)
+}

snow/engine/snowman/bootstrap/bootstrapper.go

@@ -113,11 +113,14 @@ type Bootstrapper struct {
 
 	// Called when bootstrapping is done on a specific chain
 	onFinished func(ctx context.Context, lastReqID uint32) error
+
+	nonVerifyingParser block.Parser
 }
 
 func New(config Config, onFinished func(ctx context.Context, lastReqID uint32) error) (*Bootstrapper, error) {
 	metrics, err := newMetrics(config.Ctx.Registerer)
 	return &Bootstrapper{
+		nonVerifyingParser:          config.NonVerifyingParse,
 		Config:                      config,
 		metrics:                     metrics,
 		StateSummaryFrontierHandler: common.NewNoOpStateSummaryFrontierHandler(config.Ctx.Log),
@@ -178,7 +181,7 @@ func (b *Bootstrapper) Start(ctx context.Context, startReqID uint32) error {
 		return fmt.Errorf("failed to initialize interval tree: %w", err)
 	}
 
-	b.missingBlockIDs, err = getMissingBlockIDs(ctx, b.DB, b.VM, b.tree, b.startingHeight)
+	b.missingBlockIDs, err = getMissingBlockIDs(ctx, b.DB, b.nonVerifyingParser, b.tree, b.startingHeight)
 	if err != nil {
 		return fmt.Errorf("failed to initialize missing block IDs: %w", err)
 	}
@@ -650,7 +653,7 @@ func (b *Bootstrapper) tryStartExecuting(ctx context.Context) error {
 		log,
 		b.DB,
 		&parseAcceptor{
-			parser:      b.VM,
+			parser:      b.nonVerifyingParser,
 			ctx:         b.Ctx,
 			numAccepted: b.numAccepted,
 		},

snow/engine/snowman/bootstrap/bootstrapper_test.go

@@ -90,6 +90,7 @@ func newConfig(t *testing.T) (Config, ids.NodeID, *common.SenderTest, *block.Tes
 	peerTracker.Connected(peer, version.CurrentApp)
 
 	return Config{
+		NonVerifyingParse:              vm.ParseBlock,
 		AllGetsServer:                  snowGetHandler,
 		Ctx:                            ctx,
 		Beacons:                        vdrs,

snow/engine/snowman/bootstrap/config.go

@@ -38,5 +38,8 @@ type Config struct {
 
 	VM block.ChainVM
 
+	// NonVerifyingParse parses blocks without verifying them.
+	NonVerifyingParse block.ParseFunc
+
 	Bootstrapped func()
 }

snow/engine/snowman/bootstrap/storage.go

@@ -38,7 +38,7 @@ const (
 func getMissingBlockIDs(
 	ctx context.Context,
 	db database.KeyValueReader,
-	parser block.Parser,
+	nonVerifyingParser block.Parser,
 	tree *interval.Tree,
 	lastAcceptedHeight uint64,
 ) (set.Set[ids.ID], error) {
@@ -57,7 +57,7 @@ func getMissingBlockIDs(
 			return nil, err
 		}
 
-		blk, err := parser.ParseBlock(ctx, blkBytes)
+		blk, err := nonVerifyingParser.ParseBlock(ctx, blkBytes)
 		if err != nil {
 			return nil, err
 		}
@@ -130,7 +130,7 @@ func execute(
 	haltable common.Haltable,
 	log logging.Func,
 	db database.Database,
-	parser block.Parser,
+	nonVerifyingParser block.Parser,
 	tree *interval.Tree,
 	lastAcceptedHeight uint64,
 ) error {
@@ -198,7 +198,7 @@ func execute(
 
 	for !haltable.Halted() && iterator.Next() {
 		blkBytes := iterator.Value()
-		blk, err := parser.ParseBlock(ctx, blkBytes)
+		blk, err := nonVerifyingParser.ParseBlock(ctx, blkBytes)
 		if err != nil {
 			return err
 		}

vms/platformvm/vm_test.go

@@ -1513,6 +1513,7 @@ func TestBootstrapPartiallyAccepted(t *testing.T) {
 	require.NoError(err)
 
 	bootstrapConfig := bootstrap.Config{
+		NonVerifyingParse:              vm.ParseBlock,
 		AllGetsServer:                  snowGetHandler,
 		Ctx:                            consensusCtx,
 		Beacons:                        beacons,

vms/proposervm/state_syncable_vm.go

@@ -66,7 +66,7 @@ func (vm *VM) ParseStateSummary(ctx context.Context, summaryBytes []byte) (block
 	if err != nil {
 		return nil, fmt.Errorf("could not parse inner summary due to: %w", err)
 	}
-	block, err := vm.parsePostForkBlock(ctx, statelessSummary.BlockBytes())
+	block, err := vm.parsePostForkBlock(ctx, statelessSummary.BlockBytes(), true)
 	if err != nil {
 		return nil, fmt.Errorf("could not parse proposervm block bytes from summary due to: %w", err)
 	}

vms/proposervm/vm.go

@@ -286,7 +286,14 @@ func (vm *VM) BuildBlock(ctx context.Context) (snowman.Block, error) {
 }
 
 func (vm *VM) ParseBlock(ctx context.Context, b []byte) (snowman.Block, error) {
-	if blk, err := vm.parsePostForkBlock(ctx, b); err == nil {
+	if blk, err := vm.parsePostForkBlock(ctx, b, true); err == nil {
+		return blk, nil
+	}
+	return vm.parsePreForkBlock(ctx, b)
+}
+
+func (vm *VM) ParseLocalBlock(ctx context.Context, b []byte) (snowman.Block, error) {
+	if blk, err := vm.parsePostForkBlock(ctx, b, false); err == nil {
 		return blk, nil
 	}
 	return vm.parsePreForkBlock(ctx, b)
@@ -524,8 +531,17 @@ func (vm *VM) setLastAcceptedMetadata(ctx context.Context) error {
 	return nil
 }
 
-func (vm *VM) parsePostForkBlock(ctx context.Context, b []byte) (PostForkBlock, error) {
-	statelessBlock, err := statelessblock.Parse(b, vm.ctx.ChainID)
+func (vm *VM) parsePostForkBlock(ctx context.Context, b []byte, verifySignature bool) (PostForkBlock, error) {
+	var (
+		statelessBlock statelessblock.Block
+		err            error
+	)
+
+	if verifySignature {
+		statelessBlock, err = statelessblock.Parse(b, vm.ctx.ChainID)
+	} else {
+		statelessBlock, err = statelessblock.ParseWithoutVerification(b)
+	}
 	if err != nil {
 		return nil, err
 	}

vms/proposervm/vm_test.go

@@ -30,6 +30,7 @@ import (
 	"github.com/ava-labs/avalanchego/staking"
 	"github.com/ava-labs/avalanchego/upgrade"
 	"github.com/ava-labs/avalanchego/utils"
+	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/utils/timer/mockable"
 	"github.com/ava-labs/avalanchego/vms/proposervm/proposer"
 
@@ -2476,3 +2477,90 @@ func TestGetPostDurangoSlotTimeWithNoValidators(t *testing.T) {
 	require.NoError(err)
 	require.Equal(parentTimestamp.Add(proVM.MinBlkDelay), slotTime)
 }
+
+func TestLocalParse(t *testing.T) {
+	innerVM := &block.TestVM{
+		ParseBlockF: func(_ context.Context, rawBlock []byte) (snowman.Block, error) {
+			return &snowmantest.Block{BytesV: rawBlock}, nil
+		},
+	}
+
+	chainID := ids.GenerateTestID()
+
+	tlsCert, err := staking.NewTLSCert()
+	require.NoError(t, err)
+
+	cert, err := staking.ParseCertificate(tlsCert.Leaf.Raw)
+	require.NoError(t, err)
+	key := tlsCert.PrivateKey.(crypto.Signer)
+
+	signedBlock, err := statelessblock.Build(
+		ids.ID{1},
+		time.Unix(123, 0),
+		uint64(42),
+		cert,
+		[]byte{1, 2, 3},
+		chainID,
+		key,
+	)
+	require.NoError(t, err)
+
+	properlySignedBlock := signedBlock.Bytes()
+
+	improperlySignedBlock := make([]byte, len(properlySignedBlock))
+	copy(improperlySignedBlock, properlySignedBlock)
+	improperlySignedBlock[len(improperlySignedBlock)-1] = ^improperlySignedBlock[len(improperlySignedBlock)-1]
+
+	conf := Config{
+		MinBlkDelay:         DefaultMinBlockDelay,
+		NumHistoricalBlocks: DefaultNumHistoricalBlocks,
+		StakingLeafSigner:   pTestSigner,
+		StakingCertLeaf:     pTestCert,
+		Registerer:          prometheus.NewRegistry(),
+	}
+
+	vm := New(innerVM, conf)
+	defer func() {
+		require.NoError(t, vm.Shutdown(context.Background()))
+	}()
+
+	db := prefixdb.New([]byte{}, memdb.New())
+
+	_ = vm.Initialize(context.Background(), &snow.Context{
+		Log:     logging.NoLog{},
+		ChainID: chainID,
+	}, db, nil, nil, nil, nil, nil, nil)
+
+	tests := []struct {
+		name           string
+		f              block.ParseFunc
+		block          []byte
+		resultingBlock interface{}
+	}{
+		{
+			name:           "local parse as post-fork",
+			f:              vm.ParseLocalBlock,
+			block:          improperlySignedBlock,
+			resultingBlock: &postForkBlock{},
+		},
+		{
+			name:           "parse as pre-fork",
+			f:              vm.ParseBlock,
+			block:          improperlySignedBlock,
+			resultingBlock: &preForkBlock{},
+		},
+		{
+			name:           "parse as post-fork",
+			f:              vm.ParseBlock,
+			block:          properlySignedBlock,
+			resultingBlock: &postForkBlock{},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			block, err := test.f(context.Background(), test.block)
+			require.NoError(t, err)
+			require.IsType(t, test.resultingBlock, block)
+		})
+	}
+}