consensus

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

type BuildHeaderInput struct {
	// Slot is the slot number for this block
	Slot uint64
	// BlockNumber is the block height
	BlockNumber uint64
	// PrevHash is the hash of the previous block header
	PrevHash []byte
	// EpochNonce is the epoch nonce for VRF input
	EpochNonce []byte
	// PoolStake is the pool's delegated stake
	PoolStake uint64
	// TotalStake is the total active stake
	TotalStake uint64
	// BlockBodyHash is the hash of the block body
	BlockBodyHash []byte
	// BlockBodySize is the size of the block body in bytes
	BlockBodySize uint64
	// ProtoMajor is the protocol major version
	ProtoMajor uint64
	// ProtoMinor is the protocol minor version
	ProtoMinor uint64
}

type ChainSelector interface {
	// Compare returns positive if a is preferred over b, negative if b preferred, 0 if equal
	Compare(a, b ChainTip) int
	// Preferred returns the preferred chain from a set of candidates
	Preferred(candidates []ChainTip) ChainTip
}

type ChainTip interface {
	// Slot returns tip slot
	Slot() uint64
	// BlockNumber returns tip block height
	BlockNumber() uint64
	// VRFOutput returns the VRF output of the tip block
	VRFOutput() []byte
	// Density returns block density for the chain (blocks / slots) - for deep fork comparison
	Density(fromSlot uint64) float64
}

type ConsensusHeader interface {
	// Slot returns the slot number
	Slot() uint64
	// BlockNumber returns the block height
	BlockNumber() uint64
	// PrevHash returns the previous block hash
	PrevHash() []byte
	// IssuerVKey returns the block issuer's verification key (cold key)
	IssuerVKey() []byte
	// VRFVKey returns the VRF verification key
	VRFVKey() []byte
	// VRFProof returns the VRF proof (for leader eligibility)
	VRFProof() []byte
	// VRFOutput returns the VRF output (certified random value)
	VRFOutput() []byte
	// KESSignature returns the KES signature over the header
	KESSignature() []byte
	// KESPeriod returns the KES period used for signing
	KESPeriod() uint64
	// Era returns the era identifier
	Era() uint8
}

type ConsensusMode int

type ConsensusState interface {
	// PoolStake returns (pool stake, total stake) for leader eligibility
	PoolStake(poolId []byte) (uint64, uint64, error)
	// PoolVRFKeyHash returns the registered VRF key hash for a pool
	PoolVRFKeyHash(poolId []byte) ([]byte, error)
	// EpochNonce returns the nonce for the given epoch
	EpochNonce(epoch uint64) ([]byte, error)
	// ProtocolParameters returns consensus-relevant protocol params
	ProtocolParameters() ProtocolParameters
}

type Header struct {
	Body      HeaderBody
	Signature []byte // KES signature (448 bytes)
}

type HeaderBody struct {
	BlockNumber          uint64
	Slot                 uint64
	PrevHash             []byte // 32 bytes
	IssuerVkey           []byte // 32 bytes
	VrfKey               []byte // 32 bytes
	VrfOutput            []byte // 64 bytes
	VrfProof             []byte // 80 bytes
	BlockBodySize        uint64
	BlockBodyHash        []byte // 32 bytes
	OpCertHotVkey        []byte // 32 bytes
	OpCertSequenceNumber uint32
	OpCertKesPeriod      uint32
	OpCertSignature      []byte // 64 bytes
	ProtoMajor           uint64
	ProtoMinor           uint64
}

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

type KESSigner interface {
	// Sign produces a KES signature for the given message at current period
	Sign(message []byte) (signature []byte, err error)
	// PublicKey returns the current KES verification key
	PublicKey() []byte
	// Period returns the current KES period
	Period() uint64
}

type LeaderElectionResult struct {
	// Eligible is true if the pool is eligible to produce a block
	Eligible bool
	// Proof is the VRF proof for the slot (nil only on early-return cases like zero stake)
	Proof []byte
	// Output is the VRF output (nil only on early-return cases like zero stake)
	Output []byte
	// Threshold is the leadership threshold that was used
	Threshold *big.Int
}

type NetworkConfig struct {
	Name              string            `json:"-"` // Not in genesis, set by caller
	SecurityParam     uint64            `json:"securityParam"`
	ActiveSlotCoeff   common.GenesisRat `json:"activeSlotsCoeff"`
	SlotLength        common.GenesisRat `json:"slotLength"`
	EpochLength       uint64            `json:"epochLength"`
	SlotsPerKESPeriod uint64            `json:"slotsPerKESPeriod"`
	MaxKESEvolutions  uint64            `json:"maxKESEvolutions"`
}

type OperationalCert struct {
	HotVkey        []byte // KES verification key (32 bytes)
	SequenceNumber uint32 // Monotonically increasing counter
	KesPeriod      uint32 // Starting KES period for this cert
	Signature      []byte // Cold key signature (64 bytes)
}

type PraosChainSelector struct {
	// SecurityParam is the security parameter k (max rollback depth)
	SecurityParam uint64
}

type ProtocolParameters struct {
	SecurityParam     uint64   // k - max rollback depth
	ActiveSlotCoeff   *big.Rat // f - active slot coefficient
	SlotLength        uint64   // milliseconds per slot
	EpochLength       uint64   // slots per epoch
	SlotsPerKESPeriod uint64   // slots per KES period
	MaxKESEvolutions  uint64   // maximum KES key evolutions
}

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

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

type VRFSigner interface {
	// Prove generates a VRF proof for the given input
	Prove(input []byte) (proof []byte, output []byte, err error)
	// PublicKey returns the VRF verification key
	PublicKey() []byte
}

type ValidateHeaderInput struct {
	// Header fields
	Slot           uint64
	BlockNumber    uint64
	PrevHash       []byte
	IssuerVkey     []byte
	VrfKey         []byte
	VrfProof       []byte
	VrfOutput      []byte
	KesSignature   []byte
	HeaderBodyCbor []byte

	// KesPeriod is reserved for future validation. Currently unused because
	// KES period is computed from Slot / SlotsPerKESPeriod in validation.
	// If headers expose a KesPeriod() method, this could be used to verify
	// the header's claimed period matches the computed value.
	KesPeriod uint64

	// OpCert fields
	OpCertHotVkey        []byte
	OpCertSequenceNumber uint32
	OpCertKesPeriod      uint32
	OpCertSignature      []byte

	// Previous header for chain validation
	PrevSlot        uint64
	PrevBlockNumber uint64
	PrevHeaderHash  []byte

	// Epoch nonce for VRF verification
	EpochNonce []byte

	// Stake information for leadership check
	PoolStake  uint64
	TotalStake uint64

	// Optional: registered VRF key hash for verification against pool registration
	// If provided, validates that VrfKey hashes to this value
	RegisteredVrfKeyHash []byte
}

type ValidateResult struct {
	Valid     bool
	VrfOutput []byte
	Errors    []error
}