quasar

type Acceptor interface {
	Accept(ctx *Context, containerID ids.ID, container []byte) error
}

type AcceptorGroup interface {
	RegisterAcceptor(chainID ids.ID, name string, acceptor Acceptor, persist bool) error
	DeregisterAcceptor(chainID ids.ID, name string) error
	Accept(ctx *Context, containerID ids.ID, container []byte) error
}

type Batch interface {
	// Write adds a put operation to the batch
	Write([]byte, []byte) error

	// Delete adds a delete operation to the batch
	Delete([]byte) error
}

type Block interface {
	Decidable

	// Parent returns the ID of this block's parent
	Parent() ids.ID

	// Verify that the state transition this block would make is valid
	Verify() error

	// Bytes returns the binary representation of this block
	Bytes() []byte

	// Height returns the height of this block
	Height() uint64

	// Timestamp returns the timestamp of this block
	Timestamp() int64
}

type BlockStore interface {
	// GetBlock retrieves a block by ID
	GetBlock(id ids.ID) (interface{}, error)

	// PutBlock stores a block
	PutBlock(id ids.ID, block interface{}) error

	// DeleteBlock removes a block
	DeleteBlock(id ids.ID) error
}

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

type ChainWrapper struct {
	ChainID   ids.ID
	ChainName string
	// contains filtered or unexported fields
}

type Clock interface {
	Time() time.Time
}

type ConsensusBlock struct {
	// Block metadata
	Height    uint64    `serialize:"true"`
	Timestamp time.Time `serialize:"true"`
	ParentID  ids.ID    `serialize:"true"`

	// Chain operations - Operations from each of the 8 chains
	AChainOps []Operation `serialize:"true"` // AI operations
	BChainOps []Operation `serialize:"true"` // Bridge operations
	CChainOps []Operation `serialize:"true"` // EVM operations
	MChainOps []Operation `serialize:"true"` // MPC operations
	PChainOps []Operation `serialize:"true"` // Platform operations
	QChainOps []Operation `serialize:"true"` // Quantum operations
	XChainOps []Operation `serialize:"true"` // Exchange operations
	ZChainOps []Operation `serialize:"true"` // ZK operations

	// Finality requirements
	RequiredPChainBLS      bool `serialize:"true"`
	RequiredQChainRingtail bool `serialize:"true"`
	// contains filtered or unexported fields
}

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

type ConsensusContext struct {
	// NetworkID is the ID of the network this node is running on
	NetworkID uint32

	// ChainID is the ID of the chain this consensus engine is running on
	ChainID ids.ID

	// SubnetID is the ID of the subnet this chain belongs to
	SubnetID ids.ID

	// NodeID is the ID of this node
	NodeID ids.NodeID

	// Log is the logger for this consensus engine
	Log log.Logger

	// Metrics registry for this consensus engine
	Metrics metrics.Registry

	// Network sender for consensus messages
	Sender Sender

	// Validators manager
	Validators validators.Manager

	// Current time provider
	Clock Clock

	// Consensus parameters
	Parameters Parameters

	// Metrics registerer
	Registerer metrics.Registerer

	// Validator state
	ValidatorState validators.State

	// Ringtail secret key
	RingtailSK []byte

	// Ringtail public key
	RingtailPK []byte

	// Nested context for advanced operations
	Context *Context

	// BCLookup provides blockchain lookup functionality
	BCLookup ids.AliaserReader

	// Lock provides synchronization for the consensus engine
	Lock sync.RWMutex

	// State provides the chain state management
	State *EngineState

	// LUXAssetID is the asset ID for LUX
	LUXAssetID ids.ID

	// SharedMemory for cross-chain communication
	SharedMemory SharedMemory

	// WarpSigner for warp message signing
	WarpSigner WarpSigner

	// NetworkUpgrades configuration
	NetworkUpgrades NetworkUpgrades

	// PublicKey of this node
	PublicKey []byte

	// XChainID is the ID of the X-Chain
	XChainID ids.ID

	// CChainID is the ID of the C-Chain
	CChainID ids.ID

	// ChainDataDir is the directory for chain data
	ChainDataDir string

	// ValidatorSet provides access to the current validator set
	ValidatorSet ValidatorSet

	// Bootstrappers is the set of nodes to bootstrap from
	Bootstrappers validators.Set

	// StartTime is the time the consensus engine started
	StartTime time.Time

	// RequestID for tracking requests
	RequestID RequestID
}

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

type ConsensusRound struct {
	Height         uint64
	Block          *ConsensusBlock
	PChainFinality bool
	QChainFinality bool
	StartTime      time.Time
	EndTime        time.Time
}

type Context = ConsensusContext

type ContextInitializable interface {
	// Initialize initializes with the consensus context
	Initialize(ctx *Context) error
}

type Decidable interface {
	// ID returns the unique ID of this element
	ID() ids.ID

	// Accept marks this element as accepted
	Accept() error

	// Reject marks this element as rejected
	Reject() error

	// Status returns the current status
	Status() choices.Status
}

type DualFinalityProof struct {
	BlockID ids.ID
	Height  uint64

	// P-Chain BLS aggregate signature
	PChainSignature *bls.AggregateSignature
	PChainSigners   []ids.NodeID

	// Q-Chain Ringtail signature
	QChainSignature *ringtail.Signature
	QChainWitness   *ringtail.Witness

	// Combined proof
	ProofHash      ids.ID
	ProofTimestamp time.Time
}

type Element struct {
	Key    []byte   `serialize:"true"`
	Value  []byte   `serialize:"true"`
	Traits [][]byte `serialize:"true"`
}

type Engine struct{}

type EngineState struct {
	State State
}

type FinalizedBlock struct {
	PendingBlock

	// Dual finality proof
	FinalityProof *DualFinalityProof
	FinalizedAt   time.Time
}

type Logger func(log.Logger) log.Logger

type NetworkUpgrades interface {
	// IsActivated checks if an upgrade is activated at a given time
	IsActivated(upgradeTime time.Time) bool
}

type Operation struct {
	ChainID       ids.ID
	OperationType string
	Payload       []byte
	Signature     []byte
	Timestamp     time.Time
}

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

type Parameters struct {
	// K is the number of consecutive successful polls required for finalization
	K int

	// Alpha is the required percentage of stake to consider a poll successful
	Alpha int

	// Beta is the number of polls with no progress before declaring the block stuck
	Beta int

	// ConcurrentRepolls is the number of concurrent polls to run
	ConcurrentRepolls int

	// OptimalProcessing is the optimal number of processing items
	OptimalProcessing int

	// MaxOutstandingItems is the maximum number of outstanding items
	MaxOutstandingItems int

	// MaxItemProcessingTime is the maximum time to process an item
	MaxItemProcessingTime time.Duration
}

type PendingBlock struct {
	BlockID   ids.ID
	ChainID   ids.ID
	Height    uint64
	Timestamp time.Time

	// Operations from each chain
	Operations map[ids.ID][]Operation // Chain -> Operations

	// Finality signatures
	PChainBLS      *bls.Signature
	QChainRingtail *ringtail.Signature

	// Status
	PChainFinalized bool
	QChainFinalized bool
}

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

type QuasarBlock interface {
	Block

	// HasDualCert returns true if both BLS and RT certificates are present
	HasDualCert() bool

	// BLSSignature returns the aggregated BLS signature
	BLSSignature() []byte

	// RTCertificate returns the Ringtail certificate
	RTCertificate() []byte

	// SetQuantum marks this block as having quantum-secure finality
	SetQuantum() error
}

type QuasarVertex interface {
	Vertex

	// HasDualCert returns true if both BLS and RT certificates are present
	HasDualCert() bool

	// BLSSignature returns the aggregated BLS signature
	BLSSignature() []byte

	// RTCertificate returns the Ringtail certificate
	RTCertificate() []byte

	// SetQuantum marks this vertex as having quantum-secure finality
	SetQuantum() error
}

type Registerer func(metrics.Registry) metrics.Registry

type RequestID struct {
}

type Requests struct {
	RemoveRequests [][]byte   `serialize:"true"`
	PutRequests    []*Element `serialize:"true"`
	// contains filtered or unexported fields
}

type Sender interface {
	// SendGetAcceptedFrontier sends a GetAcceptedFrontier message
	SendGetAcceptedFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32) error

	// SendAcceptedFrontier sends an AcceptedFrontier message
	SendAcceptedFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

	// SendGetAccepted sends a GetAccepted message
	SendGetAccepted(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

	// SendAccepted sends an Accepted message
	SendAccepted(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

	// SendGet sends a Get message
	SendGet(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) error

	// SendPut sends a Put message
	SendPut(ctx context.Context, nodeID ids.NodeID, requestID uint32, container []byte) error

	// SendPushQuery sends a PushQuery message
	SendPushQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, container []byte) error

	// SendPullQuery sends a PullQuery message
	SendPullQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, containerID ids.ID) error

	// SendChits sends a Chits message
	SendChits(ctx context.Context, nodeID ids.NodeID, requestID uint32, preferredID ids.ID, acceptedID ids.ID) error
}

type SharedMemory interface {
	// Get fetches the values corresponding to [keys] that have been sent from
	// [peerChainID]
	//
	// Invariant: Get guarantees that the resulting values array is the same
	//            length as keys.
	Get(peerChainID ids.ID, keys [][]byte) (values [][]byte, err error)

	// Indexed returns a paginated result of values that possess any of the
	// given traits and were sent from [peerChainID].
	Indexed(
		peerChainID ids.ID,
		traits [][]byte,
		startTrait,
		startKey []byte,
		limit int,
	) (
		values [][]byte,
		lastTrait,
		lastKey []byte,
		err error,
	)

	// Apply performs the requested set of operations by atomically applying
	// [requests] to their respective chainID keys in the map along with the
	// atomic value batch.
	Apply(requests map[ids.ID]*Requests, batch Batch) error
}

type State uint32

type ValidatorChainManager interface {
	CanValidateChain(validatorID ids.NodeID, chainID ids.ID) bool
	GetValidatorsForChain(chainID ids.ID) []ids.NodeID
	GetChainValidatorSet(chainID ids.ID) (*ChainValidatorSet, error)
}

type ValidatorSet interface {
	// GetValidatorSet returns the validator set at a given height
	GetValidatorSet(height uint64) (validators.Set, error)
}

type Vertex interface {
	Decidable

	// Parents returns the IDs of this vertex's parents
	Parents() []ids.ID

	// Verify that the state transition this vertex would make is valid
	Verify() error

	// Bytes returns the binary representation of this vertex
	Bytes() []byte

	// Height returns the height of this vertex
	Height() uint64

	// Epoch returns the epoch of this vertex
	Epoch() uint32

	// Txs returns the transactions in this vertex
	Txs() [][]byte
}

type WarpMessage struct {
}

type WarpSignature struct {
}

type WarpSigner interface {
	// Sign signs a warp message
	Sign(msg *WarpMessage) (*WarpSignature, error)
}