chains

Documentation

Index

• type ChainConfig
• type ChainParameters
• type Manager
  • func New(config *ManagerConfig) Manager
• type ManagerConfig
• type Registrant

Types

type ChainConfig

type ChainConfig struct {
	Config  []byte
	Upgrade []byte
}

ChainConfig is configuration settings for the current execution. [Config] is the user-provided config blob for the chain. [Upgrade] is a chain-specific blob for coordinating upgrades.

type ChainParameters

type ChainParameters struct {
	// The ID of the chain being created.
	ID ids.ID
	// ID of the subnet that validates this chain.
	SubnetID ids.ID
	// The genesis data of this chain's ledger.
	GenesisData []byte
	// The ID of the vm this chain is running.
	VMID ids.ID
	// The IDs of the feature extensions this chain is running.
	FxIDs []ids.ID
	// Invariant: Only used when [ID] is the P-chain ID.
	CustomBeacons validators.Set
}

ChainParameters defines the chain being created

type Manager

type Manager interface {
	ids.Aliaser

	// Return the router this Manager is using to route consensus messages to chains
	Router() router.Router

	// Queues a chain to be created in the future after chain creator is unblocked.
	// This is only called from the P-chain thread to create other chains
	// Queued chains are created only after P-chain is bootstrapped.
	// This assumes only chains in tracked subnets are queued.
	QueueChainCreation(ChainParameters)

	// Add a registrant [r]. Every time a chain is
	// created, [r].RegisterChain([new chain]) is called.
	AddRegistrant(Registrant)

	// Given an alias, return the ID of the chain associated with that alias
	Lookup(string) (ids.ID, error)

	// Given an alias, return the ID of the VM associated with that alias
	LookupVM(string) (ids.ID, error)

	// Returns true iff the chain with the given ID exists and is finished bootstrapping
	IsBootstrapped(ids.ID) bool

	// Starts the chain creator with the initial platform chain parameters, must
	// be called once.
	StartChainCreator(platformChain ChainParameters) error

	Shutdown()
}

Manager manages the chains running on this node. It can:

• Create a chain
• Add a registrant. When a chain is created, each registrant calls RegisterChain with the new chain as the argument.
• Manage the aliases of chains

var TestManager Manager = testManager{}

TestManager implements Manager but does nothing. Always returns nil error. To be used only in tests

func New

func New(config *ManagerConfig) Manager

New returns a new Manager

type ManagerConfig

type ManagerConfig struct {
	SybilProtectionEnabled bool
	StakingCert            tls.Certificate // needed to sign snowman++ blocks
	StakingBLSKey          *bls.SecretKey
	TracingEnabled         bool
	// Must not be used unless [TracingEnabled] is true as this may be nil.
	Tracer                      trace.Tracer
	Log                         logging.Logger
	LogFactory                  logging.Factory
	VMManager                   vms.Manager // Manage mappings from vm ID --> vm
	BlockAcceptorGroup          snow.AcceptorGroup
	TxAcceptorGroup             snow.AcceptorGroup
	VertexAcceptorGroup         snow.AcceptorGroup
	DBManager                   dbManager.Manager
	MsgCreator                  message.OutboundMsgBuilder // message creator, shared with network
	Router                      router.Router              // Routes incoming messages to the appropriate chain
	Net                         network.Network            // Sends consensus messages to other validators
	Validators                  validators.Manager         // Validators validating on this chain
	NodeID                      ids.NodeID                 // The ID of this node
	NetworkID                   uint32                     // ID of the network this node is connected to
	Server                      server.Server              // Handles HTTP API calls
	Keystore                    keystore.Keystore
	AtomicMemory                *atomic.Memory
	AVAXAssetID                 ids.ID
	XChainID                    ids.ID          // ID of the X-Chain,
	CChainID                    ids.ID          // ID of the C-Chain,
	CriticalChains              set.Set[ids.ID] // Chains that can't exit gracefully
	TimeoutManager              timeout.Manager // Manages request timeouts when sending messages to other validators
	Health                      health.Registerer
	RetryBootstrap              bool                      // Should Bootstrap be retried
	RetryBootstrapWarnFrequency int                       // Max number of times to retry bootstrap before warning the node operator
	SubnetConfigs               map[ids.ID]subnets.Config // ID -> SubnetConfig
	ChainConfigs                map[string]ChainConfig    // alias -> ChainConfig
	// ShutdownNodeFunc allows the chain manager to issue a request to shutdown the node
	ShutdownNodeFunc func(exitCode int)
	MeterVMEnabled   bool // Should each VM be wrapped with a MeterVM
	Metrics          metrics.MultiGatherer

	AcceptedFrontierGossipFrequency time.Duration
	ConsensusAppConcurrency         int

	// Max Time to spend fetching a container and its
	// ancestors when responding to a GetAncestors
	BootstrapMaxTimeGetAncestors time.Duration
	// Max number of containers in an ancestors message sent by this node.
	BootstrapAncestorsMaxContainersSent int
	// This node will only consider the first [AncestorsMaxContainersReceived]
	// containers in an ancestors message it receives.
	BootstrapAncestorsMaxContainersReceived int

	ApricotPhase4Time            time.Time
	ApricotPhase4MinPChainHeight uint64

	// Tracks CPU/disk usage caused by each peer.
	ResourceTracker timetracker.ResourceTracker

	StateSyncBeacons []ids.NodeID

	ChainDataDir string
}

type Registrant

type Registrant interface {
	// Called when a chain is created
	// This function is called before the chain starts processing messages
	// [vm] should be a vertex.DAGVM or block.ChainVM
	RegisterChain(chainName string, ctx *snow.ConsensusContext, vm common.VM)
}

Registrant can register the existence of a chain