add bls package and tests

Author: samliok

chains/manager.go

@@ -27,7 +27,6 @@ import (
 	"github.com/ava-labs/avalanchego/message"
 	"github.com/ava-labs/avalanchego/network"
 	"github.com/ava-labs/avalanchego/network/p2p"
-	"github.com/ava-labs/avalanchego/simplex"
 	"github.com/ava-labs/avalanchego/snow"
 	"github.com/ava-labs/avalanchego/snow/consensus/snowball"
 	"github.com/ava-labs/avalanchego/snow/engine/avalanche/bootstrap/queue"
@@ -152,14 +151,6 @@ type Manager interface {
 	Shutdown()
 }
 
-var (
-	SimplexID = ids.ID{'s', 'i', 'm', 'p', 'l', 'e', 'x'}
-)
-
-type ConsensusConfig struct {
-	ProtocolID ids.ID
-}
-
 // ChainParameters defines the chain being created
 type ChainParameters struct {
 	// The ID of the chain being created.
@@ -174,8 +165,6 @@ type ChainParameters struct {
 	FxIDs []ids.ID
 	// Invariant: Only used when [ID] is the P-chain ID.
 	CustomBeacons validators.Manager
-	// The consensus parameters of this chain.
-	ConsensusConfig ConsensusConfig
 }
 
 type chain struct {
@@ -577,34 +566,15 @@ func (m *manager) buildChain(chainParams ChainParameters, sb subnets.Subnet) (*c
 			beacons = chainParams.CustomBeacons
 		}
 
-		var err error
-
-		// TODO: replace this hack with an additional field in ChainParameters
-		// something like a ConsensusContext with an id for a consensus type
-		isPrimaryNetwork := chainParams.SubnetID == constants.PrimaryNetworkID
-		isPlugin := chainParams.VMID == constants.SubnetEVMID || chainParams.VMID == constants.XSVMID
-
-		if isPlugin && !isPrimaryNetwork {
-			chain, err = m.createSimplexChain(
-				ctx,
-				chainParams.GenesisData,
-				m.Validators,
-				beacons,
-				vm,
-				chainFxs,
-				sb)
-		} else {
-			chain, err = m.createSnowmanChain(
-				ctx,
-				chainParams.GenesisData,
-				m.Validators,
-				beacons,
-				vm,
-				chainFxs,
-				sb,
-			)
-		}
-
+		chain, err = m.createSnowmanChain(
+			ctx,
+			chainParams.GenesisData,
+			m.Validators,
+			beacons,
+			vm,
+			chainFxs,
+			sb,
+		)
 		if err != nil {
 			return nil, fmt.Errorf("error while creating new snowman vm %w", err)
 		}
@@ -1088,6 +1058,9 @@ func (m *manager) createSnowmanChain(
 	fxs []*common.Fx,
 	sb subnets.Subnet,
 ) (*chain, error) {
+	ctx.Lock.Lock()
+	defer ctx.Lock.Unlock()
+
 	ctx.State.Set(snow.EngineState{
 		Type:  p2ppb.EngineType_ENGINE_TYPE_SNOWMAN,
 		State: snow.Initializing,
@@ -1112,11 +1085,24 @@ func (m *manager) createSnowmanChain(
 	bootstrappingDB := prefixdb.New(ChainBootstrappingDBPrefix, prefixDB)
 
 	// Passes messages from the consensus engine to the network
-	messageSender, err := m.createChainSender(ctx, p2ppb.EngineType_ENGINE_TYPE_SNOWMAN, sb)
+	messageSender, err := sender.New(
+		ctx,
+		m.MsgCreator,
+		m.Net,
+		m.ManagerConfig.Router,
+		m.TimeoutManager,
+		p2ppb.EngineType_ENGINE_TYPE_SNOWMAN,
+		sb,
+		ctx.Registerer,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("couldn't initialize sender: %w", err)
 	}
 
+	if m.TracingEnabled {
+		messageSender = sender.Trace(messageSender, m.Tracer)
+	}
+
 	var bootstrapFunc func()
 	// If [m.validatorState] is nil then we are creating the P-Chain. Since the
 	// P-Chain is the first chain to be created, we can use it to initialize
@@ -1580,277 +1566,3 @@ func (m *manager) getOrMakeVMGatherer(vmID ids.ID) (metrics.MultiGatherer, error
 	m.vmGatherer[vmID] = vmGatherer
 	return vmGatherer, nil
 }
-
-func (m *manager) createSimplexChain(
-	ctx *snow.ConsensusContext,
-	genesisData []byte,
-	vdrs validators.Manager,
-	beacons validators.Manager,
-	vm block.ChainVM,
-	fxs []*common.Fx,
-	sb subnets.Subnet,
-) (*chain, error) {
-	ctx.State.Set(snow.EngineState{
-		Type:  p2ppb.EngineType_ENGINE_TYPE_SIMPLEX,
-		State: snow.Initializing,
-	})
-
-	primaryAlias := m.PrimaryAliasOrDefault(ctx.ChainID)
-	vm, msgChan, err := m.createChainVM(ctx, vm, genesisData, primaryAlias, sb, fxs)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't initialize chain vm: %w", err)
-	}
-
-	connectedBeacons := tracker.NewPeers()
-	bootstrapWeight, err := beacons.TotalWeight(ctx.SubnetID)
-	if err != nil {
-		return nil, fmt.Errorf("error while fetching weight for subnet %s: %w", ctx.SubnetID, err)
-	}
-	startupTracker := tracker.NewStartup(connectedBeacons, (3*bootstrapWeight+3)/4)
-	beacons.RegisterSetCallbackListener(ctx.SubnetID, startupTracker)
-
-	h, err := m.createChainHandler(
-		ctx,
-		vdrs,
-		msgChan,
-		sb,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't initialize message handler: %w", err)
-	}
-
-	return &chain{
-		Name:    primaryAlias,
-		Context: ctx,
-		VM:      vm,
-		Handler: h,
-	}, nil
-}
-
-func (m *manager) createChainSender(
-	ctx *snow.ConsensusContext,
-	chainType p2ppb.EngineType,
-	sb subnets.Subnet,
-) (common.Sender, error) {
-	s, err := sender.New(
-		ctx,
-		m.MsgCreator,
-		m.Net,
-		m.ManagerConfig.Router,
-		m.TimeoutManager,
-		chainType,
-		sb,
-		ctx.Registerer,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't initialize sender: %w", err)
-	}
-	if m.TracingEnabled {
-		s = sender.Trace(s, m.Tracer)
-	}
-
-	return s, nil
-}
-
-func (m *manager) createSimplexEngine() (common.Engine, error) {
-	simplexEngine := simplex.NewEngine(nil, m.Log)
-
-	var engine common.Engine
-	engine = simplexEngine
-
-	if m.TracingEnabled {
-		engine = common.TraceEngine(engine, m.Tracer)
-	}
-	m.Log.Warn("Simplex engine is not fully implemented yet, it will not be able to process any messages",
-		zap.String("engine", "simplex"),
-		zap.String("status", "not fully implemented"))
-	return engine, nil
-}
-
-func (m *manager) createProposeVM(ctx *snow.ConsensusContext, primaryAlias string, vm block.ChainVM) (block.ChainVM, error) {
-	var (
-		// A default subnet configuration will be present if explicit configuration is not provided
-		subnetCfg           = m.SubnetConfigs[ctx.SubnetID]
-		minBlockDelay       = subnetCfg.ProposerMinBlockDelay
-		numHistoricalBlocks = subnetCfg.ProposerNumHistoricalBlocks
-	)
-	m.Log.Info("creating proposervm wrapper",
-		zap.Time("activationTime", m.Upgrades.ApricotPhase4Time),
-		zap.Uint64("minPChainHeight", m.Upgrades.ApricotPhase4MinPChainHeight),
-		zap.Duration("minBlockDelay", minBlockDelay),
-		zap.Uint64("numHistoricalBlocks", numHistoricalBlocks),
-	)
-
-	proposervmReg, err := metrics.MakeAndRegister(
-		m.proposervmGatherer,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	proposerVM := proposervm.New(
-		vm,
-		proposervm.Config{
-			Upgrades:            m.Upgrades,
-			MinBlkDelay:         minBlockDelay,
-			NumHistoricalBlocks: numHistoricalBlocks,
-			StakingLeafSigner:   m.StakingTLSSigner,
-			StakingCertLeaf:     m.StakingTLSCert,
-			Registerer:          proposervmReg,
-		},
-	)
-
-	return proposerVM, nil
-}
-
-func (m *manager) createChainHandler(ctx *snow.ConsensusContext, vdrs validators.Manager, msgChan chan common.Message, sb subnets.Subnet, primaryAlias string) (handler.Handler, error) {
-	stakeReg, err := metrics.MakeAndRegister(
-		m.stakeGatherer,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	connectedValidators, err := tracker.NewMeteredPeers(stakeReg)
-	if err != nil {
-		return nil, fmt.Errorf("error creating peer tracker: %w", err)
-	}
-	vdrs.RegisterSetCallbackListener(ctx.SubnetID, connectedValidators)
-
-	var halter common.Halter
-
-	p2pReg, err := metrics.MakeAndRegister(
-		m.p2pGatherer,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	peerTracker, err := p2p.NewPeerTracker(
-		ctx.Log,
-		"peer_tracker",
-		p2pReg,
-		set.Of(ctx.NodeID),
-		nil,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("error creating peer tracker: %w", err)
-	}
-
-	handlerReg, err := metrics.MakeAndRegister(
-		m.handlerGatherer,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = m.createSimplexEngine()
-	if err != nil {
-		return nil, fmt.Errorf("couldn't create simplex instance: %w", err)
-	}
-
-	// Asynchronously passes messages from the network to the consensus engine
-	h, err := handler.New(
-		ctx,
-		vdrs,
-		msgChan,
-		m.FrontierPollFrequency,
-		m.ConsensusAppConcurrency,
-		m.ResourceTracker,
-		sb,
-		connectedValidators,
-		peerTracker,
-		handlerReg,
-		halter.Halt,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't initialize message handler: %w", err)
-	}
-
-	h.SetEngineManager(&handler.EngineManager{
-		Avalanche: nil,
-		Snowman:   nil,
-	})
-
-	return h, nil
-}
-
-func (m *manager) createChainVM(ctx *snow.ConsensusContext, vm block.ChainVM, genesisData []byte, primaryAlias string, sb subnets.Subnet, fxs []*common.Fx) (block.ChainVM, chan common.Message, error) {
-	meterDBReg, err := metrics.MakeAndRegister(
-		m.MeterDBMetrics,
-		primaryAlias,
-	)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	meterDB, err := meterdb.New(meterDBReg, m.DB)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	prefixDB := prefixdb.New(ctx.ChainID[:], meterDB)
-	vmDB := prefixdb.New(VMDBPrefix, prefixDB)
-
-	// Passes messages from the consensus engine to the network
-	messageSender, err := m.createChainSender(
-		ctx,
-		p2ppb.EngineType_ENGINE_TYPE_SIMPLEX,
-		sb,
-	)
-	if err != nil {
-		return nil, nil, fmt.Errorf("couldn't initialize sender: %w", err)
-	}
-
-	if m.TracingEnabled {
-		vm = tracedvm.NewBlockVM(vm, primaryAlias, m.Tracer)
-	}
-
-	proposerVM, err := m.createProposeVM(ctx, primaryAlias, vm)
-	if err != nil {
-		return nil, nil, fmt.Errorf("couldn't create proposer vm: %w", err)
-	}
-	vm = proposerVM
-
-	if m.MeterVMEnabled {
-		meterchainvmReg, err := metrics.MakeAndRegister(
-			m.meterChainVMGatherer,
-			primaryAlias,
-		)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		vm = metervm.NewBlockVM(vm, meterchainvmReg)
-	}
-	if m.TracingEnabled {
-		vm = tracedvm.NewBlockVM(vm, "proposervm", m.Tracer)
-	}
-
-	// The channel through which a VM may send messages to the consensus engine
-	// VM uses this channel to notify engine that a block is ready to be made
-	msgChan := make(chan common.Message, defaultChannelSize)
-	// Initialize the ProposerVM and the vm wrapped inside it
-	chainConfig, err := m.getChainConfig(ctx.ChainID)
-	if err != nil {
-		return nil, nil, fmt.Errorf("error while fetching chain config: %w", err)
-	}
-	err = vm.Initialize(
-		context.TODO(),
-		ctx.Context,
-		vmDB,
-		genesisData,
-		chainConfig.Upgrade,
-		chainConfig.Config,
-		msgChan,
-		fxs,
-		messageSender,
-	)
-
-	return vm, msgChan, err
-}