ledgerstate

type Credential struct {
	Hash []byte
	Type uint64
}

type EpochLengthFunc func(eraId uint) (
	slotLength, epochLength uint, err error,
)

type EraBound struct {
	Slot  uint64
	Epoch uint64
}

type ImportConfig struct {
	Database   *database.Database
	State      *RawLedgerState
	Logger     *slog.Logger
	OnProgress func(ImportProgress)
	// EpochLength resolves era parameters from the node config.
	// If nil, epoch generation falls back to computing from
	// era bounds.
	EpochLength EpochLengthFunc
	// ImportKey identifies this import for resume tracking.
	// Format: "{digest}:{slot}". If empty, resume is disabled.
	ImportKey string
	// Reconcile enables Mithril v2 catch-up reconciliation: after the import
	// completes, every live database row absent from this (newer) snapshot's
	// live set is marked inactive (UTxOs tombstoned, accounts/DReps
	// deactivated, pools retired). It is false for a fresh bootstrap, where
	// there is nothing stale to reconcile. Reconcile requires resume to be
	// disabled (empty ImportKey) so the import pass always runs in full and the
	// snapshot key set is complete.
	Reconcile bool
	// contains filtered or unexported fields
}

type ImportProgress struct {
	Stage       string
	Current     int
	Total       int
	Percent     float64
	Description string
}

type MapEntry struct {
	KeyRaw   []byte
	ValueRaw []byte
}

type ParsedAccount struct {
	StakingKey  Credential // staking credential (type + hash)
	PoolKeyHash []byte     // 28-byte pool key hash (delegation target)
	DRepCred    Credential // DRep credential (vote delegation)
	Reward      uint64     // reward balance in lovelace
	Deposit     *uint64    // deposit in lovelace; nil when absent from the source
	Active      bool
}

type ParsedActivePoolStake struct {
	PoolKeyHash             []byte
	StakeNumerator          uint64
	StakeDenominator        uint64
	VrfKeyHash              []byte
	LeiosKeyPublic          []byte
	LeiosKeyPossessionProof []byte
}

type ParsedAsset struct {
	PolicyId []byte // 28 bytes
	Name     []byte
	Amount   uint64
}

type ParsedCertState struct {
	Accounts              []ParsedAccount
	Pools                 []ParsedPool
	DReps                 []ParsedDRep
	CommitteeHotKeys      []ParsedCommitteeHotKey
	CommitteeResignations []Credential
}

type ParsedCommitteeHotKey struct {
	Cold Credential
	Hot  Credential
}

type ParsedCommitteeMember struct {
	ColdCredential Credential // cold credential (type + hash)
	ExpiresEpoch   uint64
}

type ParsedConstitution struct {
	AnchorURL    string
	AnchorHash   []byte // 32 bytes
	PolicyHash   []byte // 28 bytes, nil if no guardrails script
	ParseWarning error  // non-fatal warning from decoding
}

type ParsedDRep struct {
	Credential  Credential // credential (type + hash)
	AnchorURL   string
	AnchorHash  []byte
	Deposit     uint64
	ExpiryEpoch uint64 // epoch when this DRep expires (0 = unknown)
	Active      bool
}

type ParsedGovActionId struct {
	TxHash      []byte // 32 bytes
	ActionIndex uint32
}

type ParsedGovProposal struct {
	TxHash       []byte // 32 bytes
	ActionIndex  uint32
	ActionType   uint8
	Deposit      uint64
	ReturnAddr   []byte
	AnchorURL    string
	AnchorHash   []byte
	ProposedIn   uint64
	ExpiresAfter uint64
	// ParentTxHash is the parent gov-action's tx hash for chained action
	// types (ParameterChange, HardForkInitiation, NoConfidence,
	// UpdateCommittee, NewConstitution). Nil for unchained actions
	// (TreasuryWithdrawals, InfoAction) and for chained actions with no
	// prior enacted predecessor (SNothing in cardano-ledger terms).
	ParentTxHash []byte
	// ParentActionIdx is the action index that pairs with ParentTxHash.
	// nil iff ParentTxHash is nil; otherwise points to the parent's
	// uint32 index.
	ParentActionIdx *uint32
	// GovActionCbor is the raw CBOR bytes of the gov action body (the
	// govAction element inside the ProposalProcedure). Persisted on
	// import so the enactment path (ledger/governance/enact.go) can
	// decode the action's payload (e.g. HardForkInitiation's protocol
	// version, ParameterChange's pparam delta) at the boundary tick
	// that enacts a previously-ratified proposal. Without it, ENACT
	// fails to decode and aborts the entire boundary tick, halting
	// the chain at the first enactment after a Mithril boot.
	GovActionCbor []byte
}

type ParsedGovState struct {
	Constitution         *ParsedConstitution
	Committee            []ParsedCommitteeMember
	CommitteeQuorum      *cbor.Rat
	Proposals            []ParsedGovProposal
	PrevGovActionIds     *ParsedPrevGovActionIds
	RatifiedGovActionIds []ParsedGovActionId
}

type ParsedPool struct {
	PoolKeyHash                []byte // 28 bytes
	VrfKeyHash                 []byte // 32 bytes
	Pledge                     uint64
	Cost                       uint64
	MarginNum                  uint64
	MarginDen                  uint64
	RewardAccount              []byte
	RewardAccountCredentialTag uint8
	Owners                     [][]byte // list of 28-byte key hashes
	Relays                     []ParsedRelay
	MetadataUrl                string
	MetadataHash               []byte // 32 bytes
	Deposit                    uint64
	// LeiosKeyPublic and LeiosKeyPossessionProof are the pool's registered
	// Dijkstra/Leios BLS voting key and its proof of possession, or nil when
	// the snapshot's pool params carry no leiosKey field. Proof-of-possession
	// verification does not happen here (ledgerstate must not depend on
	// ledger/leios's BLS primitives); it happens where these keys are read
	// back out for committee construction.
	LeiosKeyPublic          []byte // 96 bytes
	LeiosKeyPossessionProof []byte // 48 bytes
}

type ParsedPrevGovActionIds struct {
	PParamUpdate *ParsedGovActionId
	HardFork     *ParsedGovActionId
	Committee    *ParsedGovActionId
	Constitution *ParsedGovActionId
}

type ParsedRelay struct {
	Type     uint8  // 0=SingleHostAddr, 1=SingleHostName, 2=MultiHostName
	Port     uint16 // 0 if not specified
	IPv4     []byte // 4 bytes, nil if not specified
	IPv6     []byte // 16 bytes, nil if not specified
	Hostname string // for SingleHostName and MultiHostName
}

type ParsedSnapShot struct {
	// Stake maps credential-hex to staked lovelace.
	Stake map[string]uint64
	// StakeTags maps the same credential-hex to the credential type
	// (0 = key hash, 1 = script hash). The Stake key is the hash alone, and
	// a script credential can share a hash with a key credential, so the
	// type has to be carried separately or per-credential reward and
	// leadership stake attach to the wrong one.
	//
	// Both parsed shapes populate it, the compact UTxO-HD map included --
	// that shape does encode the type, and dropping it there was the defect
	// this field exists to prevent. An entry can still be missing, though,
	// so a credential absent from this map is treated as a key hash; that
	// default is a fallback, not a statement about any particular shape.
	StakeTags map[string]uint8
	// Delegations maps credential-hex to pool key hash.
	Delegations map[string][]byte
	// PoolParams maps pool-hex to pool parameters.
	PoolParams map[string]*ParsedPool
}

type ParsedSnapShots struct {
	Mark ParsedSnapShot
	Set  ParsedSnapShot
	Go   ParsedSnapShot
	Fee  uint64
}

type ParsedUTxO struct {
	TxHash        []byte // 32 bytes
	OutputIndex   uint32
	Address       []byte // raw address bytes
	PaymentKey    []byte // 28 bytes, extracted from address
	StakingKey    []byte // 28 bytes, extracted from address
	CredentialTag uint8  // stake credential tag: 0 key hash, 1 script hash
	PaymentScript bool   // true when payment credential is a script hash
	Amount        uint64 // lovelace
	Assets        []ParsedAsset
	DatumHash     []byte // optional
	Datum         []byte // optional inline datum CBOR
	ScriptRef     []byte // optional reference script CBOR
}

type RawLedgerState struct {
	// EraIndex identifies the current era (0=Byron … 6=Conway).
	EraIndex int
	// Epoch is the epoch number at the time of the snapshot.
	Epoch uint64
	// Tip is the chain tip recorded in the snapshot.
	Tip *SnapshotTip
	// Treasury is the treasury balance in lovelace.
	Treasury uint64
	// Reserves is the reserves balance in lovelace.
	Reserves uint64
	// Fees is the fee pot accumulated so far in the snapshot's epoch, taken
	// from UTxOState. It is an addend of the reward pot, so it is carried
	// here to let the import seed a complete RewardAdaPots row.
	Fees uint64
	// UTxOData is the deferred CBOR for the UTxO map.
	UTxOData cbor.RawMessage
	// CertStateData is the deferred CBOR for [VState, PState, DState].
	CertStateData cbor.RawMessage
	// GovStateData is the deferred CBOR for governance state.
	GovStateData cbor.RawMessage
	// PParamsData is the deferred CBOR for protocol parameters.
	PParamsData cbor.RawMessage
	// PrevPParamsData is the deferred CBOR for the protocol parameters that
	// were in force during the preceding epoch. Cardano ledger state keeps
	// this alongside the current parameters because delayed reward
	// calculation consumes it after the epoch has ended.
	PrevPParamsData cbor.RawMessage
	// SnapShotsData is the deferred CBOR for mark/set/go stake snapshots.
	SnapShotsData cbor.RawMessage
	// PoolDistrData is the deferred CBOR for the active consensus pool
	// distribution in NewEpochState.pool-distr.
	PoolDistrData cbor.RawMessage
	// BlocksPrev and BlocksCur are NewEpochState.nesBprev and
	// NewEpochState.nesBcur: the blocks each pool minted during the epoch
	// before the snapshot's epoch, and during the snapshot's epoch up to and
	// including the anchor block. Keys are 28-byte pool cold-key hashes
	// encoded as strings; a pool absent from a map minted nothing.
	//
	// The ledger keeps both because pool performance for a reward round is
	// beta/sigma_a with beta the pool's share of the blocks minted in the
	// performance epoch, and a node that reconstructs its state from a
	// snapshot has no local history for those epochs to count. nesBprev is
	// the performance epoch of the first reward round the node crosses after
	// the import, and nesBcur is the pre-anchor half of the second one.
	BlocksPrev map[string]uint64
	BlocksCur  map[string]uint64
	// EraBounds holds the start boundaries of all eras extracted
	// from the telescope. Each entry gives the (Slot, Epoch) at
	// which that era began. Used to generate the full epoch
	// history needed for SlotToTime/TimeToSlot.
	EraBounds []EraBound
	// EraBoundSlot is the slot number at which the current era
	// started, extracted from the telescope Bound.
	EraBoundSlot uint64
	// EraBoundEpoch is the epoch number at which the current era
	// started, extracted from the telescope Bound.
	EraBoundEpoch uint64
	// EpochNonce is the epoch nonce from the consensus state,
	// used for VRF leader election. It is a 32-byte Blake2b hash,
	// or nil if the nonce is neutral.
	EpochNonce []byte
	// EvolvingNonce is the rolling nonce (eta_v) from the consensus
	// state, updated with each block's VRF output. Stored as the
	// tip block nonce so that subsequent block processing computes
	// correct rolling nonces after a mithril snapshot restore.
	EvolvingNonce []byte
	// CandidateNonce is the Praos candidate nonce as of the imported
	// tip. This is required to correctly continue nonce accumulation
	// from snapshot tip to epoch boundary.
	CandidateNonce []byte
	// LastEpochBlockNonce is the Praos last applied block hash from
	// consensus state (used in epoch nonce calculation).
	LastEpochBlockNonce []byte
	// OpCertCounters is the certified per-pool operational-certificate
	// counter state from the Praos HeaderState. Keys are 28-byte pool cold-key
	// hashes encoded as strings so they remain comparable.
	OpCertCounters map[string]uint64
	// EraBoundsWarning holds a non-fatal error from era bounds
	// extraction. When set, epoch generation falls back to
	// the single-epoch path.
	EraBoundsWarning error
	// UTxOTablePath is the path to the UTxO table file (UTxO-HD
	// format). When set, UTxOs are streamed from this file instead
	// of from UTxOData.
	UTxOTablePath string
	// UTxOTableFile, when set, is an already-open handle on the UTxO table
	// that the import reads instead of resolving UTxOTablePath.
	//
	// A caller that vetted the snapshot tree needs this: resolving the
	// pathname here would read whatever occupies that name at import time,
	// which need not be the file the caller checked. UTxOTablePath stays set
	// alongside it for messages. The caller keeps ownership and must hold the
	// file open for the duration of the import.
	UTxOTableFile *os.File
	// UTxOTableDigest, when set, is the hex SHA-256 the table's contents must
	// have, checked against the mapped bytes immediately before they are
	// decoded.
	//
	// A caller holding a signature over the table needs this rather than
	// hashing UTxOTableFile itself: the table is mapped rather than read, so a
	// digest taken from the descriptor beforehand describes a read that then
	// happens again. Handing the digest down means the bytes that are checked
	// and the bytes that are decoded are one mapping.
	//
	// Empty means nothing signed this table — v1, and any tree nothing
	// vouched for — and it is decoded unchecked, as it was before.
	UTxOTableDigest string
	// UTxOHD indicates that the snapshot used the UTxO-HD ledger
	// state wrapper. These snapshots keep the real UTxO set in an
	// external table file and the inline UTxO field is only a
	// placeholder.
	UTxOHD bool
}

type SnapshotFiles struct {
	// State is the open ledger state file.
	State *os.File
	// StatePath is the slash-separated path State was found at, for messages.
	StatePath string
	// Table is the open UTxO-HD table, or nil for legacy snapshots that embed
	// their UTxO set in the state file.
	Table *os.File
	// TablePath is the slash-separated path Table was found at, for messages.
	TablePath string
}

type SnapshotTip struct {
	Slot      uint64
	BlockHash []byte
}

type UTxOCallback func(batch []ParsedUTxO) error

type UTxOParseProgress struct {
	EntriesProcessed int
	TotalEntries     int
	BytesProcessed   int
	TotalBytes       int
	Percent          float64
}