replay

type AccountSharedData struct {
	// Lamports in the account
	Lamports uint64
	// Data held in this account
	Data []byte
	// The program that owns this account
	Owner solana.PublicKey
	// This account's data contains a loaded program (and is now read-only)
	Executable bool
	// The epoch at which this account will next owe rent
	RentEpoch uint64
}

type AccountUpdate struct {
	Pubkey  solana.PublicKey
	Account accounts.Account
}

type BlockFetchOpts struct {
	MaxRPS          int    // Rate limit (requests per second), 0 = use default
	MaxInflight     int    // Max concurrent workers, 0 = use default
	TipPollMs       int    // Tip poll interval ms, 0 = use default
	TipSafetyMargin uint64 // Don't fetch within N slots of tip, 0 = use default

	// Mode thresholds (hysteresis)
	NearTipThreshold        int // Enter near-tip when gap <= this, 0 = use default
	CatchupThreshold        int // Exit near-tip when gap >= this, 0 = use default
	CatchupTipGateThreshold int // Only apply safety margin when gap > this, 0 = use default

	// Near-tip tuning
	NearTipPollMs    int // Faster poll interval in near-tip, 0 = use default
	NearTipLookahead int // Slots ahead to schedule in near-tip, 0 = use default
}

type BoundaryStakeScanResult struct {
	// For stake history update
	StakeHistoryEffective    uint64
	StakeHistoryActivating   uint64
	StakeHistoryDeactivating uint64
	// For epoch stakes + vote cache
	VoteAcctStakes      map[solana.PublicKey]uint64
	EffectiveStakes     map[solana.PublicKey]uint64
	TotalEffectiveStake uint64
}

type CloneStats struct {
	AcctsLoaded       uint64 // Accounts loaded into tx contexts
	AcctsLoadedBytes  uint64 // Bytes referenced by tx contexts
	AcctsCloned       uint64 // Accounts loaded (cloned)
	AcctsClonedBytes  uint64 // Bytes cloned
	AcctsTouched      uint64 // Accounts modified
	AcctsTouchedBytes uint64 // Bytes of modified accounts
	TxCount           uint64 // Number of transactions
}

type CompiledInstruction struct {
	// ProgramIdIndex is the index into the transaction's account keys of the program
	ProgramIdIndex uint8
	// Accounts contains the indices into the transaction's account keys
	Accounts []uint8
	// Data is the instruction data
	Data []byte
	// StackHeight is the depth at which this instruction executed.
	// 1 = top-level; >=2 = CPI invoked from within another instruction.
	StackHeight uint8
}

type ConsensusOpts struct {
	SkipPathMaxDepth int    // Max slots for skip-path solver (default: 64)
	UnresolvedPolicy string // "halt" or "warn" (default: "halt")
	EnforceOnSource  string // "lightbringer" or "all" (default: "lightbringer")
}

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

type ExecutedTransaction struct {
	LoadedTransaction LoadedTransaction
	ExecutionDetails  TransactionExecutionDetails
	ProgramsModified  map[solana.PublicKey]bool // Programs that were modified by this transaction
}

type FeesOnlyTransaction struct {
	LoadedTransaction LoadedTransaction
	ExecutionError    error // The error that prevented execution
}

type InnerInstructionsList struct {
	// Index is the index of the top-level instruction that produced these inner instructions
	Index uint8
	// Instructions contains the inner instructions
	Instructions []CompiledInstruction
}

type KeyedAccountSharedData struct {
	Pubkey      solana.PublicKey
	AccountData AccountSharedData
}

type LoadAndExecuteTransactionInput struct {
	// SlotCtx provides access to accounts and slot state (used read-only)
	SlotCtx *sealevel.SlotCtx
	// Transaction is the transaction to process
	Transaction *solana.Transaction
	// Arena for borrowed accounts (optional)
	Arena *arena.Arena[sealevel.BorrowedAccount]
	// TxMeta is the on-chain transaction metadata (optional, used for fee calculation)
	TxMeta *rpc.TransactionMeta
	// IsSimulation indicates this is a simulation (no side effects on shared state)
	IsSimulation bool
	// RecordInnerInstructions enables CPI recording. The simulate handler
	// sets this when the RPC request asks for innerInstructions.
	RecordInnerInstructions bool
}

type LoadAndExecuteTransactionOutput struct {
	// Result of processing the transaction. Contains either ProcessedTransaction or TransactionError
	ProcessingResult TransactionProcessingResult
	// ExecutionResult contains all the state changes from executing the transaction
	// This is only populated if ProcessingResult contains a ProcessedTransaction
	ExecutionResult *TransactionExecutionResult

	// ExecCtx is the execution context after processing. Available when accounts were
	// loaded successfully. Used by ProcessTransaction for divergence checks and state application.
	ExecCtx *sealevel.ExecutionCtx
	// PreBalances contains lamport balances for each account BEFORE fee deduction.
	// Used by ProcessTransaction for pre-balance divergence checks.
	PreBalances []uint64
	// PreAccountSnapshots holds clones of every transaction account
	// captured before fee deduction and execution. The simulate handler
	// uses these to decode pre-execution token balances; block-replay
	// callers leave it nil.
	PreAccountSnapshots []*accounts.Account
	// FeeInfo contains the calculated fee info. Set whenever fees were calculated.
	FeeInfo *fees.TxFeeInfo
	// Instrs contains the parsed instructions from the transaction.
	Instrs []sealevel.Instruction
	// ComputeBudgetLimits contains the compute budget limits computed from instructions.
	ComputeBudgetLimits *sealevel.ComputeBudgetLimits
}

type LoadedTransaction struct {
	// Accounts contains all the accounts loaded for this transaction with their public keys
	Accounts []KeyedAccountSharedData
	// ProgramIndices contains the indices of program accounts in the Accounts array
	ProgramIndices []uint16
	// FeeDetails contains the fee calculation for this transaction
	FeeDetails fees.TxFeeInfo
	// RollbackAccounts contains the accounts that need to be rolled back if the transaction fails
	RollbackAccounts RollbackAccounts
	// ComputeBudget contains the compute unit limits and heap size for this transaction
	ComputeBudget SVMTransactionExecutionBudget
	// LoadedAccountsDataSize is the total size of all loaded account data in bytes
	LoadedAccountsDataSize uint32
}

type OnCancelWriteState func(result *ReplayResult) error

type ProcessedTransaction struct {
	// TransactionType indicates whether this is an Executed or FeesOnly transaction
	TransactionType ProcessedTransactionType
	// Executed contains the execution result if TransactionType is Executed
	Executed *ExecutedTransaction
	// FeesOnly contains the fees-only result if TransactionType is FeesOnly
	FeesOnly *FeesOnlyTransaction
}

type ProcessedTransactionType int

type ReplayCtx struct {
	CurrentFeatures   *features.Features
	Capitalization    uint64
	Inflation         rewards.Inflation
	SlotsPerYear      float64
	EpochAcctsHash    []byte
	HasEpochAcctsHash bool
}

type ReplayResult struct {
	// LastPersistedSlot is the last slot whose state was successfully persisted to AccountsDB
	LastPersistedSlot uint64
	// LastPersistedBankhash is the bankhash of the last persisted slot
	LastPersistedBankhash []byte
	// LastBlockHeight is the block height of the last persisted slot.
	LastBlockHeight uint64
	// WasCancelled indicates whether replay was interrupted by context cancellation
	WasCancelled bool
	// Error contains any error that occurred during replay
	Error error

	// Resume context - populated on graceful shutdown (Ctrl+C) for proper resume
	LastAcctsLtHash          *lthash.LtHash // LtHash at end of last persisted slot
	LastLamportsPerSignature uint64         // FeeRateGovernor.LamportsPerSignature
	LastPrevLamportsPerSig   uint64         // FeeRateGovernor.PrevLamportsPerSignature
	LastNumSignatures        uint64         // SlotCtx.NumSignatures

	// Blockhash context - required because appendvec writes are not fsynced
	LastRecentBlockhashes *sealevel.SysvarRecentBlockhashes // 150 entries, newest first
	LastEvictedBlockhash  [32]byte                          // 151st blockhash
	LastBlockhash         [32]byte                          // blockhash of last replayed slot

	// SlotHashes context - same issue, vote program needs accurate slot→hash mappings
	LastSlotHashes *sealevel.SysvarSlotHashes

	// ReplayCtx fields - for resume independence from stale manifest
	LastCapitalization uint64
	LastSlotsPerYear   float64
	LastInflation      rewards.Inflation

	// ComputedEpochStakes contains epoch stakes computed at boundaries during this run.
	// Key: epoch number (the leader schedule epoch), Value: serialized JSON
	// This must be persisted to state file for correct resume across epoch boundaries.
	ComputedEpochStakes map[uint64][]byte

	// StateWrittenOnCancel indicates that the state file was already written during
	// cancellation handling, so the caller should skip the final write
	StateWrittenOnCancel bool
}

type ResumeState struct {
	// ParentSlot is the slot of the last successfully replayed block (= state.LastSlot)
	ParentSlot uint64
	// ParentBlockHeight is the block height of the last successfully replayed block.
	ParentBlockHeight uint64
	// ParentBankhash is the bankhash of the parent slot
	ParentBankhash []byte
	// AcctsLtHash is the cumulative LtHash at the end of the parent slot
	AcctsLtHash *lthash.LtHash
	// LamportsPerSignature for reconstructing FeeRateGovernor
	LamportsPerSignature uint64
	// PrevLamportsPerSignature for reconstructing FeeRateGovernor
	PrevLamportsPerSignature uint64
	// NumSignatures is the total signature count at end of parent slot
	NumSignatures uint64

	// Blockhash context - required because appendvec writes are not fsynced
	RecentBlockhashes *sealevel.SysvarRecentBlockhashes // 150 entries, newest first
	EvictedBlockhash  [32]byte                          // 151st blockhash
	LastBlockhash     [32]byte                          // blockhash of last slot (parent for next)

	// SlotHashes context - vote program needs accurate slot→hash mappings
	SlotHashes *sealevel.SysvarSlotHashes

	// ReplayCtx fields - so resume uses fresh values instead of stale manifest
	Capitalization          uint64
	SlotsPerYear            float64
	InflationInitial        float64
	InflationTerminal       float64
	InflationTaper          float64
	InflationFoundation     float64
	InflationFoundationTerm float64

	// ComputedEpochStakes contains epoch stakes computed at boundaries.
	// Key: epoch number (the leader schedule epoch), Value: serialized JSON
	// Required for correct leader schedule computation on resume.
	ComputedEpochStakes map[uint64][]byte
}

type RollbackAccounts struct {
	RollbackType RollbackAccountsType
	// FeePayer is set for FeePayerOnly and SeparateNonceAndFeePayer types
	FeePayer *KeyedAccountSharedData
	// Nonce is set for SameNonceAndFeePayer and SeparateNonceAndFeePayer types
	Nonce *KeyedAccountSharedData
}

type RollbackAccountsType int

type SVMTransactionExecutionBudget struct {
	// ComputeUnitLimit is the number of compute units that a transaction is allowed to consume
	ComputeUnitLimit uint64
	// MaxInstructionStackDepth is the maximum program instruction invocation stack depth
	MaxInstructionStackDepth uint64
	// MaxInstructionTraceLength is the maximum cross-program invocation and instructions per transaction
	MaxInstructionTraceLength uint64
	// Sha256MaxSlices is the maximum number of slices hashed per syscall
	Sha256MaxSlices uint64
	// MaxCallDepth is the maximum SBF to BPF call depth
	MaxCallDepth uint64
	// StackFrameSize is the size of a stack frame in bytes
	StackFrameSize uint64
	// HeapSize is the program heap region size
	HeapSize uint32
}

type ScheduleSummary struct {
	// Epoch info
	BlockEpoch    uint64
	ScheduleEpoch uint64
	FirstSlot     uint64
	SlotsInEpoch  uint64
	Repeat        uint64

	// Stake info
	TotalInputStake     uint64 // Total stake from EpochStakes (before filtering)
	FilteredStake       uint64 // Stake used in schedule (after filtering)
	MissingStake        uint64 // Stake skipped due to missing data
	MissingStakePercent float64

	// Validator counts
	ValidatorsInput    int // Total vote accounts in EpochStakes
	ValidatorsUsed     int // Validators included in schedule
	ValidatorsSkipped  int // Validators skipped (zero stake + missing + zero nodepk)
	SkippedZeroStake   int
	SkippedMissingData int // missing_vote_acct or missing_vote_cache
	SkippedZeroNodePk  int

	// Hashes
	LocalHash string
	RPCHash   string // Empty if RPC validation not enabled

	// Run info
	RunID     string
	Source    string // "snapshot" or "vote_cache"
	Timestamp time.Time
}

type SlotCtxSetter interface {
	SetSlotCtx(slotCtx *sealevel.SlotCtx)
}

type StakeEntry struct {
	VoteAcct   solana.PublicKey
	NodePubkey solana.PublicKey
	Stake      uint64
	Reason     string // For skipped entries: "zero_stake", "missing_vote_acct", "zero_nodepk"
}

type TransactionError struct {
	ErrorType TransactionErrorType
	// InstructionIndex is set for InstructionError type
	InstructionIndex *uint8
	// InstructionError is set for InstructionError type
	InstructionError error
	// AccountIndex is set for errors that reference a specific account
	AccountIndex *uint8
}

type TransactionErrorType int

type TransactionExecutionDetails struct {
	// Status is the execution result (nil for success, error for failure)
	Status error
	// LogMessages contains the log messages produced during execution (if logging is enabled)
	LogMessages []string
	// InnerInstructions contains the inner instructions executed via CPI
	InnerInstructions []InnerInstructionsList
	// ReturnData contains the return data from the last instruction
	ReturnData *TransactionReturnData
	// ExecutedUnits is the number of compute units consumed
	ExecutedUnits uint64
	// AccountsDataLenDelta is the change in accounts data len for this transaction (only valid if Status is nil)
	AccountsDataLenDelta int64
}

type TransactionExecutionResult struct {
	// AccountUpdates contains all account updates (modified accounts)
	AccountUpdates []AccountUpdate
	// WritableAccounts contains the pubkeys of all writable accounts (slice for ordered iteration)
	WritableAccounts []solana.PublicKey
	// WritableAccountSet is the same as WritableAccounts but as a set for O(1) lookups
	WritableAccountSet map[solana.PublicKey]struct{}
	// ModifiedStakeAccounts contains stake accounts that were modified
	ModifiedStakeAccounts []solana.PublicKey
	// ModifiedVoteAccounts contains vote accounts that were modified
	ModifiedVoteAccounts map[solana.PublicKey]*sealevel.VoteStateVersions
}

type TransactionProcessingResult struct {
	// ProcessedTransaction contains the execution result if successful
	ProcessedTransaction *ProcessedTransaction
	// TransactionError contains the error if processing failed
	TransactionError *TransactionError
}

type TransactionReturnData struct {
	ProgramId solana.PublicKey
	Data      []byte
}

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

type ValidationStats struct {
	SkippedZeroStake            int
	SkippedMissingNodePk        int
	SkippedMissingNodePkStake   uint64 // Stake dropped due to zero NodePubkey
	SkippedMissingVoteAcct      int
	SkippedMissingVoteAcctStake uint64 // Stake dropped due to missing VoteCache entries
	TotalVoteAccts              int
	TotalStake                  uint64
	MinStake                    uint64
	MaxStake                    uint64
	ValidatorCount              int // Validators with non-zero stake and valid NodePubkey
	MismatchCount               int
	Capped                      bool
	TopStakes                   []StakeEntry // Top 10 by stake
	BottomStakes                []StakeEntry // Bottom 10 by stake
	MissingVoteAccts            []StakeEntry // First few missing vote accounts (for debugging)
	ZeroNodePkAccts             []StakeEntry // First few zero NodePubkey accounts
}

type VoteCacheRebuildError struct {
	VoteAcct solana.PublicKey
	Stake    uint64
	Reason   string
	Err      error
}