quasar

type AggregatedSignature struct {
	BLSAggregated      []byte
	RingtailAggregated []byte
	ValidatorIDs       []string
	SignerCount        int
	IsThreshold        bool
}

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

type BLS struct {
	// Configuration
	K     int
	Alpha float64
	Beta  uint32
	// contains filtered or unexported fields
}

type Block struct {
	ID        [32]byte   // Unique block identifier
	ChainID   [32]byte   // Chain this block belongs to
	ChainName string     // Human-readable chain name (e.g., "P-Chain", "X-Chain", "C-Chain")
	Height    uint64     // Block height
	Hash      string     // Block hash
	Timestamp time.Time  // Block timestamp
	Data      []byte     // Block payload data
	Cert      *BlockCert // Quantum certificate (nil if not finalized)
}

type BlockCert struct {
	BLS      []byte            // BLS aggregate signature
	PQ       []byte            // Post-quantum certificate (ML-DSA/Ringtail)
	Sigs     map[string][]byte // Individual validator signatures
	Epoch    uint64            // Epoch number
	Finality time.Time         // Time of finality
}

type Bundle struct {
	Epoch   uint64
	Root    []byte
	BLSAgg  []byte
	PQBatch []byte
	Binding []byte
}

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

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

type Cert = []byte

type CertBundle struct {
	BLSAgg []byte // BLS aggregate signature
	PQCert []byte // Post-quantum certificate
}

type ChainBlock = Block

type Client interface {
	SubmitCheckpoint(epoch uint64, root []byte, attest []byte) error
	FetchBundle(epoch uint64) (Bundle, error)
	Verify(Bundle) bool
}

type CompressedWitness struct {
	CommitmentAndProof []byte // Combined commitment + proof
	Metadata           uint64 // Packed height + timestamp
	Validators         uint32 // Validator bitfield (up to 32 validators)
}

type Config struct {
	QThreshold    int
	QuasarTimeout int
}

type Core = Quasar

type Engine interface {
	// Start begins the consensus engine
	Start(ctx context.Context) error

	// Stop gracefully shuts down the consensus engine
	Stop() error

	// Submit adds a block to the consensus pipeline
	Submit(block *Block) error

	// Finalized returns a channel of finalized blocks
	Finalized() <-chan *Block

	// IsFinalized checks if a block is finalized
	IsFinalized(blockID [32]byte) bool

	// Stats returns consensus metrics
	Stats() Stats
}

type EpochCheckpoint struct {
	Epoch          uint64   // Epoch number
	StartHeight    uint64   // First block in epoch
	EndHeight      uint64   // Last block in epoch
	BlockCount     int      // Number of blocks
	MerkleRoot     [32]byte // Merkle root of block hashes
	PreviousAnchor [32]byte // Previous checkpoint hash (chain of anchors)
	Timestamp      int64    // Unix timestamp

	// Quantum-safe signature (Ringtail grouped threshold)
	Signature *GroupedSignature
}

type EpochKeys struct {
	Epoch        uint64
	CreatedAt    time.Time
	ExpiresAt    time.Time
	ValidatorSet []string
	Threshold    int
	TotalParties int
	GroupKey     *ringtailThreshold.GroupKey
	Shares       map[string]*ringtailThreshold.KeyShare
	Signers      map[string]*ringtailThreshold.Signer
}

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

type EpochStats struct {
	CurrentEpoch      uint64
	EpochAge          time.Duration
	ValidatorCount    int
	Threshold         int
	HistorySize       int
	LastKeygenTime    time.Time
	TimeUntilRotation time.Duration
}

type GroupedEpochManager struct {
	*EpochManager
	// contains filtered or unexported fields
}

type GroupedEpochStats struct {
	EpochStats
	NumGroups       int
	GroupSize       int
	GroupThreshold  int
	GroupQuorum     int
	TotalValidators int
}

type GroupedSignature struct {
	Epoch           uint64
	Message         string
	GroupSignatures map[int]*ringtailThreshold.Signature // group index -> signature
	SignedGroups    []int
}

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

type HybridConfig struct {
	Threshold    int
	TotalParties int

	// BLS threshold (via crypto/threshold interface)
	BLSKeyShares map[string]threshold.KeyShare
	BLSGroupKey  threshold.PublicKey

	// Ringtail threshold (native 2-round protocol)
	RingtailShares   map[string]*ringtailThreshold.KeyShare
	RingtailGroupKey *ringtailThreshold.GroupKey
}

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

type HybridSignature struct {
	BLS         []byte
	Ringtail    []byte
	ValidatorID string
	IsThreshold bool
	SignerIndex int
}

type PChain = BLS

type Precomp = []byte

type PublicKey = []byte

type QBlock = Block

type QuantumBlock struct {
	Height        uint64
	SourceBlocks  []*Block
	QuantumHash   string
	BLSSignature  []byte
	RingtailProof []byte // ML-DSA signature
	Timestamp     time.Time
	ValidatorSigs map[string]*HybridSignature
}

type QuantumBundle struct {
	Epoch        uint64     // Current key epoch
	Sequence     uint64     // Bundle sequence within epoch
	StartHeight  uint64     // First BLS block in this bundle
	EndHeight    uint64     // Last BLS block in this bundle
	BlockCount   int        // Number of BLS blocks bundled
	MerkleRoot   [32]byte   // Merkle root of BLS block hashes
	BlockHashes  [][32]byte // Individual block hashes (for Merkle proof)
	PreviousHash [32]byte   // Previous bundle hash (chain linkage)
	Timestamp    int64      // Unix timestamp

	// Ringtail threshold signature (post-quantum secure)
	Signature *ringtailThreshold.Signature
}

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

type QuasarCore = Quasar

type QuasarHybridConsensus = Hybrid

type RingtailEngine interface {
	// Initialize the engine with security parameters
	Initialize(level SecurityLevel) error

	// Sign a message with the secret key
	Sign(msg []byte, sk SecretKey) (Signature, error)

	// Verify a signature
	Verify(msg []byte, sig Signature, pk PublicKey) bool

	// Generate a new key pair
	GenerateKeyPair() (SecretKey, PublicKey, error)

	// KEM operations for post-quantum key exchange
	Encapsulate(pk PublicKey) ([]byte, []byte, error)
	Decapsulate(ct []byte, sk SecretKey) ([]byte, error)

	// Shared secret operations
	CombineSharedSecrets(ss1, ss2 []byte) []byte
	DeriveKey(secret []byte, length int) []byte
}

type RingtailRound1State struct {
	SessionID  int
	PRFKey     []byte
	SignerIDs  []int
	Round1Data map[int]*ringtailThreshold.Round1Data
}

type SecretKey = []byte

type SecurityLevel int

type Share = []byte

type Signature = []byte // Alias for Share or Cert depending on context

type Stats struct {
	Height          uint64        // Current finalized height
	ProcessedBlocks uint64        // Total blocks processed
	FinalizedBlocks uint64        // Total blocks finalized
	PendingBlocks   int           // Blocks awaiting finality
	Validators      int           // Active validator count
	Uptime          time.Duration // Time since start
}

type ThresholdConfig struct {
	SchemeID     threshold.SchemeID
	Threshold    int
	TotalParties int
	KeyShares    map[string]threshold.KeyShare
	GroupKey     threshold.PublicKey
}

type Validator struct {
	ID          string
	BLSPubKey   *bls.PublicKey
	RingtailPub []byte // Ringtail group public key contribution
	Weight      uint64
	Active      bool
}

type ValidatorGroup struct {
	Index      int
	Validators []string
	Threshold  int
	GroupKey   *ringtailThreshold.GroupKey
	Shares     map[string]*ringtailThreshold.KeyShare
	Signers    map[string]*ringtailThreshold.Signer
}

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

type VertexID [32]byte

type WitnessProof struct {
	// Verkle proof components
	Commitment   []byte // 32 bytes banderwagon point
	Path         []byte // Compressed path in tree
	OpeningProof []byte // IPA opening proof

	// PQ finality certificate (lightweight)
	BLSAggregate []byte // Aggregated BLS signature
	RingtailBits []byte // Bitfield of Ringtail signers
	ValidatorSet []byte // Compressed validator set hash

	// Block metadata
	BlockHeight uint64
	StateRoot   []byte
	Timestamp   uint64
}