chains

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

type ChainParameters struct {
	// The ID of the chain being created.
	ID ids.ID
	// ID of the subnet that validates this block.
	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.Manager
}

type ChainValidationConfig struct {
	// Core chains that validators can opt into
	ValidateAChain bool // AI Chain (opt-in)
	ValidateBChain bool // Bridge Chain (Genesis NFT-gated)
	ValidateCChain bool // EVM Chain
	ValidateMChain bool // MPC Chain (Genesis NFT-gated)
	ValidatePChain bool // Platform Chain (usually required)
	ValidateQChain bool // Quantum Chain (usually required)
	ValidateXChain bool // Exchange Chain
	ValidateZChain bool // ZK Chain (opt-in)

	// Genesis NFT requirements for B/M chains
	GenesisNFTContract string   // Address of Genesis NFT contract
	GenesisNFTTokenIDs []uint64 // Required Genesis NFT token IDs

	// Optional specific NFT requirements per chain
	ChainSpecificNFTs map[ids.ID]NFTRequirement

	// Staking requirements per chain
	MinStakePerChain map[ids.ID]uint64
}

type ChainValidatorSet struct {
	ChainID        ids.ID
	Validators     []ids.NodeID
	IsGenesisGated bool
	MinValidators  int
}

type GenesisNFTInfo struct {
	ContractAddress string
	TotalSupply     uint64
	RequiredTokens  []uint64 // Specific token IDs required for validation

	// Different tiers of Genesis NFTs
	TierMapping map[string][]uint64
}

type GenesisNFTVerifier struct {
	// contains filtered or unexported fields
}

type Manager interface {
	ids.Aliaser

	// 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()
}

type ManagerConfig struct {
	SybilProtectionEnabled bool
	StakingTLSSigner       crypto.Signer
	StakingTLSCert         *staking.Certificate
	StakingBLSKey          bls.Signer
	TracingEnabled         bool
	// Must not be used unless [TracingEnabled] is true as this may be nil.
	Tracer                    trace.Tracer
	Log                       log.Logger
	LogFactory                log.Factory
	VMManager                 vms.Manager // Manage mappings from vm ID --> vm
	BlockAcceptorGroup        quasar.AcceptorGroup
	TxAcceptorGroup           quasar.AcceptorGroup
	VertexAcceptorGroup       quasar.AcceptorGroup
	DB                        db.Database
	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
	PartialSyncPrimaryNetwork bool
	Server                    server.Server // Handles HTTP API calls
	AtomicMemory              *atomic.Memory
	LUXAssetID                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
	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
	ImportMode       bool // If true, disable pruning for one-time blockchain data import

	Metrics        metrics.MultiGatherer
	MeterDBMetrics metrics.MultiGatherer

	FrontierPollFrequency   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

	Upgrades upgrade.Config

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

	StateSyncBeacons []ids.NodeID

	ChainDataDir string

	Subnets *Subnets
}

type NFTOwnership struct {
	ValidatorID  ids.NodeID
	TokenIDs     []uint64
	LastVerified time.Time
}

type NFTRequirement struct {
	ContractAddress  string
	RequiredTokenIDs []uint64
	MinimumBalance   uint64 // Minimum number of NFTs required
}

type NFTVerifier interface {
	// VerifyNFTOwnership checks if a validator owns required NFTs
	VerifyNFTOwnership(validatorID ids.NodeID, contractAddress string, requiredTokenIDs []uint64) (bool, error)
}

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 *quasar.Context, vm core.VM)
}

type StakingManager interface {
	// GetValidatorStake returns the stake amount for a validator on a specific chain
	GetValidatorStake(validatorID ids.NodeID, chainID ids.ID) (uint64, error)
}

type Subnets struct {
	// contains filtered or unexported fields
}

type ValidatorChainManager struct {
	// contains filtered or unexported fields
}