models

type Account struct {
	StakingKey    []byte
	CredentialTag uint8
	Pool          []byte
	Drep          []byte
	ID            uint
	AddedSlot     uint64
	// CreatedSlot is the slot at which this account row was first created
	// (0 for Shelley-genesis delegated accounts). Unlike AddedSlot it is
	// immutable after creation — never bumped by later delegation/registration
	// changes. See AccountCreatedSlotUnset for the sentinel used by the
	// create/save helpers.
	CreatedSlot   uint64
	CertificateID uint
	Reward        types.Uint64
	// ImportDeposit is the stake-key deposit carried by a ledger-state
	// snapshot. It is only used when ImportAccount records the rollback
	// baseline; nil means the import source could not establish the deposit.
	ImportDeposit *types.Uint64
	// DrepType is the DRep delegation type code, an internal enum
	// matching the Cardano ledger CBOR sum-type tag:
	//   0 = key credential, 1 = script credential,
	//   2 = AlwaysAbstain, 3 = AlwaysNoConfidence.
	// A zero value (0) means either "key credential" or "no delegation set",
	// disambiguated by whether Drep is nil.
	DrepType uint64
	Active   bool
	// ExpirationEpoch is the CIP-0163 reward-account inactivity expiry: the
	// last epoch in which the account remains active unless it
	// witnesses again. 0 means unset (treated as active). Mirrors
	// Drep.ExpiryEpoch. Set/bumped by RenewAccountExpirations and the one-time
	// activation stamp; only read when the delegator-inactivity gate is on.
	ExpirationEpoch uint64
}

type AccountDelegationHistoryRow struct {
	AddedSlot   uint64
	BlockIndex  uint32
	CertIndex   uint32
	TxHash      []byte
	PoolKeyHash []byte
	// TxSlot is the slot of the transaction containing the
	// delegation certificate.
	TxSlot uint64
	// BlockHash is the hash of the block containing the
	// delegation certificate's transaction. The block height is
	// resolved from the block store, which is not part of the
	// metadata SQL schema.
	BlockHash []byte
}

type AccountImportRegistration struct {
	AddedSlot uint64
	Deposit   *uint64
}

type AccountInactivityActivation struct {
	CredentialTag uint8
	StakingKey    []byte
}

type AccountRegistrationHistoryRow struct {
	AddedSlot  uint64
	BlockIndex uint32
	CertIndex  uint32
	TxHash     []byte
	Action     string
	// Deposit is the registration deposit (or refund, for
	// deregistrations) in lovelace. Zero for certificate types
	// that do not record an explicit deposit.
	Deposit uint64
	// TxSlot is the slot of the transaction containing the
	// (de)registration certificate.
	TxSlot uint64
	// BlockHash is the hash of the block containing the
	// (de)registration certificate's transaction. The block
	// height is resolved from the block store, which is not part
	// of the metadata SQL schema.
	BlockHash []byte
}

type AccountRewardDelta struct {
	StakingKey     []byte
	CredentialTag  uint8
	TxHash         []byte
	Amount         types.Uint64
	PreviousReward types.Uint64
	ID             uint
	AddedSlot      uint64
	Withdrawal     bool
	// PostSnapshot marks a credit that cardano-ledger applies AFTER the
	// epoch-boundary stake snapshot (the SNAP rule): POOLREAP deposit refunds,
	// enacted treasury withdrawals and governance proposal-deposit refunds.
	// Two boundary credits precede SNAP and leave this false: the delayed reward
	// update (applyRUpd / applyStakeRewards) and the Shelley-era MIR rule, which
	// NEWEPOCH embeds between applyRUpd and EPOCH.
	//
	// Every boundary credit lands at the same added_slot (the boundary slot), so
	// slot alone cannot separate the pre-SNAP reward update from the post-SNAP
	// credits. The epoch-boundary stake reconstruction
	// (stakequery.historicalDelegatorStakeCTE with a nonzero boundary slot)
	// needs exactly that separation to reproduce the authoritative SNAP-point
	// capture, which observes the reward update and none of the rest.
	//
	// Not indexed: it is only ever read alongside added_slot for a single
	// boundary slot, which idx_account_reward_delta_credential/added_slot
	// already narrow.
	PostSnapshot bool
}

type AccountSums struct {
	// WithdrawalsSum is the total of all reward withdrawals
	// made by the account.
	WithdrawalsSum uint64
	// ReservesSum is the total of all MIR transfers to the
	// account sourced from the reserves pot.
	ReservesSum uint64
	// TreasurySum is the total of all MIR transfers to the
	// account sourced from the treasury pot.
	TreasurySum uint64
}

type AccountTransactionAssociationRow struct {
	PaymentKey []byte
	TxHash     []byte
	// TxSlot and TxIndex are the transaction's position, used for
	// ordering and from/to range filtering.
	TxSlot  uint64
	TxIndex uint32
	// BlockHash is the hash of the block containing the transaction. The
	// block height is resolved from the block store, which is not part
	// of the metadata SQL schema.
	BlockHash []byte
}

type AccountWithdrawalHistoryRow struct {
	TxHash []byte
	Amount uint64
	// TxSlot is the slot of the transaction containing the
	// withdrawal.
	TxSlot uint64
	// BlockIndex is the withdrawal transaction's position within
	// its containing block, used as an ordering tie-break for
	// transactions sharing a slot.
	BlockIndex uint32
	// BlockHash is the hash of the block containing the
	// withdrawal transaction. The block height is resolved from
	// the block store, which is not part of the metadata SQL
	// schema.
	BlockHash []byte
}

type AccountWithdrawalWitness struct {
	StakingKey    []byte
	CredentialTag uint8
	TxHash        []byte
	ID            uint
	AddedSlot     uint64
}

type AddressBalance struct {
	Lovelace  uint64
	UtxoCount int64
	// Assets is ordered by (policy id, name) so callers emit
	// deterministic unit ordering without re-sorting.
	Assets []AssetBalance
}

type AddressTransaction struct {
	ID uint
	// PaymentKey backs bare payment-credential lookups and provides the final
	// deterministic tie-break in the stake-position index.
	PaymentKey    []byte
	StakingKey    []byte
	CredentialTag uint8
	TransactionID uint
	// Slot retains its standalone rollback index in addition to participating
	// in the stake-position index.
	Slot uint64
	// TxIndex is queried as part of the stake-position ordering.
	TxIndex uint32
}

type AddressTransactionPosition struct {
	Slot    uint64
	TxIndex uint32
}

type Asset struct {
	Name        []byte
	NameHex     []byte
	PolicyId    []byte
	Fingerprint []byte
	ID          uint
	UtxoID      uint
	Amount      types.Uint64
}

type AssetBalance struct {
	PolicyId []byte
	Name     []byte
	Amount   uint64
}

type AssetMintBurn struct {
	ID          uint
	TxHash      []byte
	PolicyId    []byte
	Name        []byte
	Fingerprint []byte
	Slot        uint64
	Quantity    string
	TxIndex     uint32
}

type AuthCommitteeHot struct {
	ColdCredential []byte
	// Column is "host_credential" for backward compatibility with
	// existing databases; the Go field uses the canonical Cardano
	// terminology ("hot credential" for committee voting keys).
	HotCredential []byte
	ID            uint
	CertificateID uint
	AddedSlot     uint64
}

type BackfillCheckpoint struct {
	ID         uint
	Phase      string // "metadata"
	LastSlot   uint64 // Last successfully processed slot
	TotalSlots uint64 // Total slots to process (for progress)
	StartedAt  time.Time
	UpdatedAt  time.Time
	Completed  bool
}

type Block struct {
	Hash     []byte
	PrevHash []byte
	Cbor     []byte
	ID       uint64
	Slot     uint64
	Number   uint64
	Type     uint
}

type BlockNonce struct {
	Hash         []byte
	Nonce        []byte
	ID           uint
	Slot         uint64
	IsCheckpoint bool
}

type Certificate struct {
	BlockHash     []byte
	ID            uint
	TransactionID uint
	CertificateID uint // Polymorphic FK to certificate table based on CertType. Not DB-enforced.
	Slot          uint64
	CertIndex     uint
	CertType      uint
}

type CommitteeMember struct {
	ID           uint
	ColdCredHash []byte // 28-byte credential hash
	ExpiresEpoch uint64
	AddedSlot    uint64  // Slot when imported/registered
	DeletedSlot  *uint64 // For rollback support
}

type CommitteeQuorum struct {
	Quorum    *types.Rat
	ID        uint
	AddedSlot uint64
}

type Constitution struct {
	ID          uint
	AnchorURL   string
	AnchorHash  []byte
	PolicyHash  []byte
	AddedSlot   uint64
	DeletedSlot *uint64
}

type Datum struct {
	Hash      []byte
	RawDatum  []byte
	ID        uint
	AddedSlot uint64
}

type Deregistration struct {
	StakingKey    []byte
	CredentialTag uint8
	ID            uint
	CertificateID uint
	AddedSlot     uint64
	Amount        types.Uint64
}

type DeregistrationDrep struct {
	DrepCredential []byte
	CertificateID  uint
	ID             uint
	CredentialTag  uint8
	AddedSlot      uint64
	DepositAmount  types.Uint64
}

type Drep struct {
	AnchorURL     string
	Credential    []byte
	AnchorHash    []byte
	ID            uint
	AddedSlot     uint64
	CredentialTag uint8
	// Last activity epoch (vote, register, update).
	LastActivityEpoch uint64
	// Epoch when DRep expires (activity + inactivity).
	ExpiryEpoch uint64
	Active      bool
}

type DrepListRow struct {
	AnchorURL         string
	Credential        []byte
	AnchorHash        []byte
	ID                uint
	AddedSlot         uint64
	CredentialTag     uint8
	LastActivityEpoch uint64
	ExpiryEpoch       uint64
	Active            bool
	FirstSeenSlot     uint64
	// LastRegistrationSlot is the added_slot of the most recent
	// registration certificate, 0 when no cert history exists.
	LastRegistrationSlot uint64
}

type Epoch struct {
	Nonce         []byte
	EvolvingNonce []byte
	// CandidateNonce holds the frozen candidate nonce from the end
	// of the previous epoch (psCandidateNonce in Haskell). In
	// Ouroboros Praos, the candidate nonce tracks the evolving
	// nonce until the randomness stabilisation window cutoff
	// (4k/f slots before the end of the epoch), then freezes.
	// When 4k/f >= epochLength (e.g., devnets with short epochs),
	// the candidate nonce is never updated and stays at its
	// initial value (genesis hash). This field carries the
	// candidate nonce across epochs so it can seed the next
	// epoch's computation correctly.
	CandidateNonce []byte
	// LastEpochBlockNonce holds the Praos lab carried at this epoch's
	// boundary: the parent hash (PrevHash) of the previous epoch's last
	// block, or the previously carried lab when that epoch had no blocks.
	// In Ouroboros Praos, the epoch nonce formula mixes CandidateNonce with
	// this value. This field is nil for epoch 0 (equivalent to NeutralNonce /
	// identity).
	LastEpochBlockNonce []byte
	ID                  uint
	// EpochId is a ledger identifier where zero is valid, so the SQL schema
	// uses the separate surrogate ID as its primary key.
	EpochId       uint64
	StartSlot     uint64
	EraId         uint
	SlotLength    uint
	LengthInSlots uint
}

type EpochSummary struct {
	ID               uint
	Epoch            uint64
	TotalActiveStake types.Uint64
	TotalPoolCount   uint64
	TotalDelegators  uint64
	EpochNonce       []byte
	BoundarySlot     uint64
	SnapshotReady    bool
}

type GenesisDelegation struct {
	ID                  uint
	GenesisHash         []byte
	GenesisDelegateHash []byte
	VrfKeyHash          []byte
	AddedSlot           uint64
	BlockIndex          uint32
	CertIndex           uint
	CertificateID       uint
}

type GovernanceProposal struct {
	ID              uint
	TxHash          []byte
	ActionIndex     uint32
	ActionType      uint8 // GovActionType enum
	ProposedEpoch   uint64
	ExpiresEpoch    uint64
	ParentTxHash    []byte
	ParentActionIdx *uint32
	EnactedEpoch    *uint64
	EnactedSlot     *uint64 // Slot when enacted (for rollback safety)
	RatifiedEpoch   *uint64
	RatifiedSlot    *uint64 // Slot when ratified (for rollback safety)
	PolicyHash      []byte
	AnchorURL       string
	AnchorHash      []byte
	Deposit         uint64
	ReturnAddress   []byte // Reward account for deposit return (1 byte header + 28 bytes hash)
	// GovActionCbor holds the CBOR-encoded GovAction needed at enactment
	// time to extract type-specific fields (ParamUpdate, ProtocolVersion,
	// Withdrawals, Committee changes, Constitution). Populated on proposal
	// submission so enactment does not need to re-fetch the transaction.
	GovActionCbor []byte
	ExpiredEpoch  *uint64
	ExpiredSlot   *uint64 // Slot when expired (for rollback safety)
	AddedSlot     uint64
	DeletedSlot   *uint64
}

type GovernanceVote struct {
	ID                 uint
	ProposalID         uint
	VoterType          uint8 // 0=CC, 1=DRep, 2=SPO
	VoterCredentialTag uint8
	VoterCredential    []byte
	Vote               uint8 // 0=No, 1=Yes, 2=Abstain
	AnchorURL          string
	AnchorHash         []byte
	AddedSlot          uint64
	// Slot when vote was last changed (for rollback safety).
	VoteUpdatedSlot *uint64
	DeletedSlot     *uint64
}

type ImportCheckpoint struct {
	ID        uint
	ImportKey string // "{digest}:{slot}"
	Phase     string // last completed phase
}

type KeyWitness struct {
	Vkey          []byte
	Signature     []byte
	PublicKey     []byte
	ChainCode     []byte
	Attributes    []byte
	ID            uint
	TransactionID uint
	Type          uint8
}

type MIREffect struct {
	// ID is the move_instantaneous_rewards row ID. It is used as the stable
	// per-MIR reward-credit discriminator when applying epoch-boundary effects.
	ID uint
	// Pot is the source Ada pot: 0 = Reserves, 1 = Treasury.
	Pot uint
	// OtherPot is the amount for a pot-to-pot transfer (0 when distributing).
	OtherPot uint64
	// Rewards lists credential→amount pairs for a distribution MIR.
	Rewards []MIRReward
}

type MIRReward struct {
	Credential    []byte
	CredentialTag uint8
	Amount        uint64
}

type MidnightAriadneParams struct {
	ID    uint
	Epoch uint64
	Datum []byte
}

type MidnightAriadneRollback struct {
	ID             uint
	BlockNumber    uint64
	Epoch          uint64
	PreviousExists bool
	PreviousDatum  []byte
}

type MidnightAssetCreate struct {
	ID               uint
	Address          []byte
	Quantity         uint64
	TxHash           []byte
	OutputIndex      uint32
	BlockNumber      uint64
	BlockHash        []byte
	TxIndex          uint32
	BlockTimestampMs uint64
}

type MidnightAssetSpend struct {
	ID               uint
	Address          []byte
	Quantity         uint64
	SpendingTxHash   []byte
	UtxoTxHash       []byte
	UtxoIndex        uint32
	BlockNumber      uint64
	BlockHash        []byte
	TxIndex          uint32
	BlockTimestampMs uint64
}

type MidnightCommitteeCandidateRegistration struct {
	ID           uint
	TxHash       []byte
	OutputIndex  uint32
	BlockNumber  uint64
	SlotNumber   uint64
	TxIndex      uint32
	TxInputsCbor []byte
}

type MidnightDeregistration struct {
	ID               uint
	FullDatum        []byte
	TxHash           []byte
	UtxoTxHash       []byte
	UtxoIndex        uint32
	BlockNumber      uint64
	BlockHash        []byte
	TxIndex          uint32
	BlockTimestampMs uint64
}

type MidnightEpochCandidates struct {
	ID             uint
	Epoch          uint64
	BlockNumber    uint64
	CandidatesCbor []byte
}

type MidnightGovernanceDatum struct {
	ID          uint
	DatumType   string
	TxHash      []byte
	OutputIndex uint32
	Datum       []byte
	BlockNumber uint64
}

type MidnightRegistration struct {
	ID               uint
	FullDatum        []byte
	TxHash           []byte
	OutputIndex      uint32
	BlockNumber      uint64
	BlockHash        []byte
	TxIndex          uint32
	BlockTimestampMs uint64
}

type MoveInstantaneousRewards struct {
	Rewards       []MoveInstantaneousRewardsReward
	Pot           uint
	CertificateID uint
	ID            uint
	AddedSlot     uint64
	// OtherPot holds the lovelace amount for a pot-to-pot transfer (non-zero
	// only when the cert moves coins between treasury and reserves rather than
	// distributing to staking credentials).
	OtherPot types.Uint64
}

type MoveInstantaneousRewardsReward struct {
	Credential    []byte
	CredentialTag uint8
	Amount        types.Uint64
	ID            uint
	MIRID         uint
}

type NetworkState struct {
	ID       uint
	Treasury types.Uint64
	Reserves types.Uint64
	Slot     uint64
}

type OffchainMetadata struct {
	FetchedAt      *time.Time
	NextFetchAfter *time.Time
	CreatedAt      time.Time
	UpdatedAt      time.Time
	URL            string
	SourceType     string
	Status         string
	ContentType    string
	LastError      string
	Hash           []byte
	BodyHash       []byte
	Content        []byte
	ID             uint
	FetchAttempts  uint
	LastHTTPStatus uint
}

type PParamUpdate struct {
	GenesisHash []byte
	Cbor        []byte
	ID          uint
	AddedSlot   uint64
	Epoch       uint64
}

type PParams struct {
	Cbor      []byte
	ID        uint
	AddedSlot uint64
	Epoch     uint64
	EraId     uint
}

type PlutusData struct {
	Transaction   *Transaction
	Data          []byte
	ID            uint
	TransactionID uint
}

type Pool struct {
	Margin               *types.Rat
	PoolKeyHash          []byte
	VrfKeyHash           []byte
	RewardAccount        []byte
	LatestOpCertSequence uint64
	// RewardAccountCredentialTag is the stake credential type of the pool's
	// reward account: 0 = key hash, 1 = script hash. The on-chain pool cert
	// encodes the reward_account as a 29-byte reward address (header + 28-byte
	// hash). The gouroboros library stores only the first 28 bytes in
	// RewardAccount (AddrKeyHash), discarding the header. We decode the raw
	// cert CBOR to preserve the credential type here.
	RewardAccountCredentialTag uint8
	// LeiosKeyPublic and LeiosKeyPossessionProof are the pool's registered
	// Dijkstra/Leios BLS voting key (96-byte compressed G2 public key) and
	// its proof of possession (48-byte compressed G1 signature), as decoded
	// from the on-chain leios_key pool-cert field. Both are nil only when
	// the pool has no leios_key. This is raw registration data -- the proof
	// is not checked here or anywhere in this package; a key with an
	// invalid proof is still stored as-is, and only excluded when read back
	// out for committee construction in ledger/leios, matching upstream's
	// "invalid proofs are treated as absent" rule.
	LeiosKeyPublic          []byte
	LeiosKeyPossessionProof []byte
	// Owners and Relays are query-only associations (no CASCADE).
	// The actual parent-child relationship is PoolRegistration -> Owners/Relays.
	// When Pool is deleted, PoolRegistrations cascade, which then cascade to Owners/Relays.
	Owners       []PoolRegistrationOwner
	Relays       []PoolRegistrationRelay
	Registration []PoolRegistration
	Retirement   []PoolRetirement
	ID           uint
	Pledge       types.Uint64
	Cost         types.Uint64
}

type PoolOpCertSequence struct {
	PoolKeyHash []byte
	ID          uint
	Slot        uint64
	Sequence    uint64
}

type PoolRegistration struct {
	Margin                     *types.Rat
	Pool                       *Pool // Belongs-to relationship; CASCADE is defined on Pool.Registration
	MetadataUrl                string
	VrfKeyHash                 []byte
	PoolKeyHash                []byte
	RewardAccount              []byte
	RewardAccountCredentialTag uint8
	MetadataHash               []byte
	LeiosKeyPublic             []byte
	LeiosKeyPossessionProof    []byte
	Owners                     []PoolRegistrationOwner
	Relays                     []PoolRegistrationRelay
	Pledge                     types.Uint64
	Cost                       types.Uint64
	CertificateID              uint
	ID                         uint
	PoolID                     uint
	AddedSlot                  uint64
	DepositAmount              types.Uint64
}

type PoolRegistrationOwner struct {
	KeyHash            []byte
	ID                 uint
	PoolRegistrationID uint
	PoolID             uint
}

type PoolRegistrationRelay struct {
	Ipv4               *net.IP
	Ipv6               *net.IP
	Hostname           string
	ID                 uint
	PoolRegistrationID uint
	PoolID             uint
	Port               uint
}

type PoolRetirement struct {
	PoolKeyHash   []byte
	CertificateID uint
	ID            uint
	PoolID        uint
	Epoch         uint64
	AddedSlot     uint64
}

type PoolRetirementRefund struct {
	PoolKeyHash                []byte
	RewardAccount              []byte
	RewardAccountCredentialTag uint8
	DepositAmount              types.Uint64
}

type PoolRetiringRow struct {
	PoolKeyHash []byte
	Epoch       uint64
}

type PoolStakeSnapshot struct {
	ID               uint
	Epoch            uint64
	SnapshotType     string // "mark", "set", "go", "actv"
	PoolKeyHash      []byte
	TotalStake       types.Uint64
	StakeDenominator types.Uint64
	DelegatorCount   uint64
	CapturedSlot     uint64
	// LeiosKeyPublic and LeiosKeyPossessionProof freeze the pool's optional
	// Dijkstra/Leios voting key at the same boundary as its stake. Both are
	// nil for a keyless seat and for legacy snapshots captured before the key
	// was stored here. Consumers must verify the proof of possession before
	// using the key.
	LeiosKeyPublic          []byte
	LeiosKeyPossessionProof []byte
	// CalculationVersion identifies the stake-accounting algorithm used to
	// produce Mark/Set/Go rows. Zero denotes a pre-provenance snapshot.
	CalculationVersion uint
	// RewardAccountAutoVote captures the CIP-1694 SPO auto-vote
	// outcome implied by the pool's reward-account DRep delegation at
	// the snapshot epoch. Values come from PoolRewardAccountAutoVote*.
	// This field is only meaningful when RewardAccountAutoVoteResolved
	// is true; otherwise its value is undefined and must not be read
	// by the tally.
	RewardAccountAutoVote uint8
	// RewardAccountAutoVoteResolved disambiguates "resolved as none"
	// from "never resolved". The resolver sets this to true after it
	// has computed RewardAccountAutoVote against snapshot-era state.
	// Rows imported by Mithril for set/go rotations (which only have
	// live state available at import time and cannot be faithfully
	// resolved against historical boundaries) intentionally leave this
	// false; the tally treats them as PoolRewardAccountAutoVoteNone,
	// matching pre-CIP-1694 behaviour for those rows. Pre-CIP-1694
	// rows in upgraded databases also remain false until re-resolved.
	RewardAccountAutoVoteResolved bool
}

type Redeemer struct {
	Data          []byte
	ID            uint
	TransactionID uint
	ExUnitsMemory uint64
	ExUnitsCPU    uint64
	Index         uint32
	Tag           uint8
}

type Registration struct {
	StakingKey    []byte
	CredentialTag uint8
	ID            uint
	CertificateID uint
	AddedSlot     uint64
	DepositAmount types.Uint64
}

type RegistrationDrep struct {
	AnchorURL      string
	DrepCredential []byte
	AnchorHash     []byte
	CertificateID  uint
	ID             uint
	CredentialTag  uint8
	AddedSlot      uint64
	DepositAmount  types.Uint64
}

type ResignCommitteeCold struct {
	AnchorURL      string
	ColdCredential []byte
	AnchorHash     []byte
	ID             uint
	CertificateID  uint
	AddedSlot      uint64
}

type RewardAccountOutput struct {
	StakingKey    []byte
	PoolKeyHash   []byte
	RewardType    string
	ID            uint
	Epoch         uint64
	CredentialTag uint8
	Amount        types.Uint64
	Spendable     bool
	// Guarded records that CIP-0163 account expiry prevented this otherwise
	// spendable reward from being credited.
	Guarded      bool
	CapturedSlot uint64
	BoundarySlot uint64
}

type RewardAdaPots struct {
	ID           uint
	Epoch        uint64
	Treasury     types.Uint64
	Reserves     types.Uint64
	Fees         types.Uint64
	Rewards      types.Uint64
	CapturedSlot uint64
}

type RewardLiveStake struct {
	PoolKeyHash   []byte
	StakingKey    []byte
	ID            uint
	CredentialTag uint8
	UtxoStake     types.Uint64
	RewardStake   types.Uint64
	TotalStake    types.Uint64
	Registered    bool
	// PoolDelegation* records the certificate order used to derive PoolKeyHash.
	// It is rollback/rebuild bookkeeping; snapshot consumers select eligible
	// pools independently at the requested slot.
	PoolDelegationSlot       uint64
	PoolDelegationBlockIndex uint64
	PoolDelegationCertIndex  uint32
	UpdatedSlot              uint64
	// CalculationVersion is set by every rebuild and incremental update. Zero
	// denotes rows created before calculation provenance was introduced.
	CalculationVersion uint
}

type RewardPoolInput struct {
	Margin                     *types.Rat
	PoolKeyHash                []byte
	RewardAccount              []byte
	BlocksProduced             *uint64
	TotalBlocksInEpoch         *uint64
	ID                         uint
	Epoch                      uint64
	Pledge                     types.Uint64
	DelegatedStake             types.Uint64
	OwnerStake                 types.Uint64
	Cost                       types.Uint64
	DelegatorCount             uint64
	RewardAccountCredentialTag uint8
	CapturedSlot               uint64
	BoundarySlot               uint64
}

type RewardPoolOutput struct {
	ApparentPerformance *types.Rat
	PoolKeyHash         []byte
	ID                  uint
	Epoch               uint64
	OptimalReward       types.Uint64
	TotalReward         types.Uint64
	LeaderReward        types.Uint64
	MemberRewardTotal   types.Uint64
	OwnerStake          types.Uint64
	Undistributed       types.Uint64
	Unspendable         types.Uint64
	CapturedSlot        uint64
	BoundarySlot        uint64
}

type RewardSnapshot struct {
	ID               uint
	Epoch            uint64
	SnapshotType     string
	TotalActiveStake types.Uint64
	TotalPoolCount   uint64
	TotalDelegators  uint64
	CapturedSlot     uint64
	BoundarySlot     uint64
	EpochNonce       []byte
	ProtocolVersion  uint
	// Authoritative marks a snapshot captured inside the ledger epoch-rollover
	// write transaction at the SNAP point (CaptureEpochBoundarySnapshot). The
	// event-driven fallback capture (captureMarkSnapshot) never overwrites an
	// authoritative row: it either claims a fresh row or is superseded. Defaults
	// to false, so pre-existing rows and fallback captures read as provisional.
	Authoritative bool
	// CalculationVersion ties authoritative Mark metadata to the stake
	// calculation that produced its accompanying pool snapshots.
	CalculationVersion uint
}

type RewardStakeInput struct {
	PoolKeyHash   []byte
	StakingKey    []byte
	ID            uint
	Epoch         uint64
	CredentialTag uint8
	Stake         types.Uint64
	Owner         bool
	Registered    bool
	CapturedSlot  uint64
	BoundarySlot  uint64
}

type Script struct {
	Hash        []byte
	Content     []byte
	ID          uint
	CreatedSlot uint64
	Type        uint8
}

type StakeCredentialRef struct {
	Tag uint8
	Key []byte
}

type StakeDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	PoolKeyHash   []byte
	CertificateID uint
	ID            uint
	AddedSlot     uint64
}

type StakeDeregistration struct {
	StakingKey    []byte
	CredentialTag uint8
	CertificateID uint
	ID            uint
	AddedSlot     uint64
}

type StakeRegistration struct {
	StakingKey    []byte
	CredentialTag uint8
	CertificateID uint
	ID            uint
	AddedSlot     uint64
	DepositAmount types.Uint64
}

type StakeRegistrationDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	PoolKeyHash   []byte
	CertificateID uint
	ID            uint
	AddedSlot     uint64
	DepositAmount types.Uint64
}

type StakeVoteDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	PoolKeyHash   []byte
	Drep          []byte
	DrepType      uint64
	CertificateID uint
	ID            uint
	AddedSlot     uint64
}

type StakeVoteRegistrationDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	PoolKeyHash   []byte
	Drep          []byte
	DrepType      uint64
	CertificateID uint
	ID            uint
	AddedSlot     uint64
	DepositAmount types.Uint64
}

type SyncState struct {
	Key   string
	Value string
}

type Tip struct {
	Hash        []byte
	ID          uint
	Slot        uint64
	BlockNumber uint64
}

type TokenRegistryEntry struct {
	// Decimals is nil when the registry declares no decimals for the
	// subject. Zero is a meaningful declared value distinct from absent, so
	// this cannot collapse to a bare int.
	Decimals    *int
	CreatedAt   time.Time
	UpdatedAt   time.Time
	Subject     string
	Name        string
	Ticker      string
	Description string
	URL         string
	// Logo is the base64 payload as published by the registry. Logos are
	// roughly 90% of registry bytes, so the syncer drops them unless the
	// operator opts in; an empty Logo means "not stored", never "the
	// registry published an empty logo".
	Logo string
	ID   uint
}

type Transaction struct {
	// CollateralReturn uses a separate FK (CollateralReturnForTxID) to
	// distinguish it from regular Outputs, which use TransactionID.
	CollateralReturn *Utxo
	PlutusData       []PlutusData
	Certificates     []Certificate
	Outputs          []Utxo
	Hash             []byte
	Collateral       []Utxo
	BlockHash        []byte
	KeyWitnesses     []KeyWitness
	WitnessScripts   []WitnessScripts
	Inputs           []Utxo
	Redeemers        []Redeemer
	ReferenceInputs  []Utxo
	Metadata         []byte
	Slot             uint64
	Type             int
	ID               uint
	Fee              types.Uint64
	// CollateralFee is the lovelace consumed into the fee pot by a
	// phase-2-invalid transaction (collateral inputs minus collateral
	// return, per the Alonzo/Babbage UTXOS rule). Zero for valid
	// transactions; Fee keeps the declared body fee in both cases.
	CollateralFee types.Uint64
	TTL           types.Uint64
	BlockIndex    uint32
	Valid         bool
}

type UpdateDrep struct {
	AnchorURL     string
	Credential    []byte
	AnchorHash    []byte
	CertificateID uint
	ID            uint
	CredentialTag uint8
	AddedSlot     uint64
}

type Utxo struct {
	TransactionID           *uint
	CollateralReturnForTxID *uint // Unique: a transaction has at most one collateral return output
	TxId                    []byte
	PaymentKey              []byte
	StakingKey              []byte
	CredentialTag           uint8
	Assets                  []Asset
	Cbor                    []byte // This is here for convenience but not represented in the metadata DB
	DatumHash               []byte // Optional datum hash (32 bytes)
	Datum                   []byte // Inline datum CBOR, not stored in metadata DB
	ScriptRef               []byte // Reference script bytes, not stored in metadata DB
	// SpentAtTxId, ReferencedByTxId, and CollateralByTxId are nullable FKs to
	// transaction(hash); they are unset until a UTxO is spent/referenced.
	// They use types.NullableHash so an empty value serializes to SQL NULL
	// (not an empty blob), which is required for the FK to be skipped — see
	// the type docs for the FOREIGN KEY constraint failed (787) issue.
	SpentAtTxId      types.NullableHash
	ReferencedByTxId types.NullableHash
	CollateralByTxId types.NullableHash
	ID               uint
	AddedSlot        uint64
	DeletedSlot      uint64
	Amount           types.Uint64
	OutputIdx        uint32
	// PaymentScript is true when the output's payment credential is a
	// script hash (as opposed to a key hash). It is derived from the
	// address type at index time and used to compute the network's
	// script-locked supply (see GetScriptLockedSupply). The composite
	// index (deleted_slot, payment_script, amount) lets the supply sum
	// scan only live script UTxOs.
	PaymentScript bool
}

type UtxoAddressMatchMode int

type UtxoAddressPattern struct {
	ExactAddress   []byte
	PaymentPart    []byte
	DelegationPart []byte
}

type UtxoId struct {
	Hash []byte
	Idx  uint32
}

type UtxoOrderingCursor struct {
	Slot       uint64
	BlockIndex uint32
	OutputIdx  uint32
	TxId       []byte
}

type UtxoSlot struct {
	Utxo ledger.Utxo
	Slot uint64
}

type UtxoWithOrdering struct {
	Utxo
	TxSlot       uint64
	TxBlockIndex uint32
}

type UtxoWithOrderingQuery struct {
	MatchAllAddresses bool
	AddressPatterns   []UtxoAddressPattern
	After             *UtxoOrderingCursor
	Limit             int
	Offset            int
	Descending        bool
	SkipAssets        bool
	FilterByAsset     bool
	AssetPolicyID     []byte
	AssetName         []byte
}

type VoteDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	Drep          []byte
	DrepType      uint64
	CertificateID uint
	ID            uint
	AddedSlot     uint64
}

type VoteRegistrationDelegation struct {
	StakingKey    []byte
	CredentialTag uint8
	Drep          []byte
	DrepType      uint64
	CertificateID uint
	ID            uint
	AddedSlot     uint64
	DepositAmount types.Uint64
}

type WitnessScripts struct {
	ScriptHash    []byte
	ID            uint
	TransactionID uint
	Type          uint8
}