state

type AccumulationHistory [jamtime.TimeslotsPerEpoch]map[crypto.Hash]struct{} // (equation 162 v0.4.5)

type AccumulationOperand struct {
	WorkPackageHash   crypto.Hash                   // Work-package hash (h ∈ H)
	SegmentRoot       crypto.Hash                   // Segment root (e ∈ H)
	AuthorizationHash crypto.Hash                   // Authorization hash (a ∈ H)
	Output            []byte                        // Output of the work report (o ∈ Y)
	PayloadHash       crypto.Hash                   // Payload hash (y ∈ H)
	GasLimit          uint64                        `jam:"encoding=compact"` // Gas limit (g ∈ NG)
	OutputOrError     block.WorkResultOutputOrError // Output or error (d ∈ Y ∪ J)
}

type AccumulationOutputLog []ServiceHashPair

type AccumulationQueue [jamtime.TimeslotsPerEpoch][]WorkReportWithUnAccumulatedDependencies

type AccumulationResult struct {
	ServiceState      *service.ServiceAccount    // s - Optional updated service account state
	ValidatorUpdates  safrole.ValidatorsData     // v - Single validator data set, not a slice
	DeferredTransfers []service.DeferredTransfer // t - Deferred transfers sequence
	AccumulationRoot  *crypto.Hash               // r - Optional accumulation result hash
	CoreAssignments   PendingAuthorizersQueues   // c - Core authorizations queue
	NewServices       service.ServiceState       // n - Newly created services mapping
	PrivilegedUpdates struct {
		ManagerServiceId   block.ServiceId            // m - Manager service
		AssignServiceId    block.ServiceId            // a - Assign service
		DesignateServiceId block.ServiceId            // v - Designate service
		GasAssignments     map[block.ServiceId]uint64 // g - Gas assignments
	}
}

type AccumulationState struct {
	ServiceState             service.ServiceState                               // Service accounts δ (d ∈ D⟨NS → A⟩)
	ValidatorKeys            safrole.ValidatorsData                             // Validator keys ι (i ∈ ⟦K⟧V)
	PendingAuthorizersQueues [common.TotalNumberOfCores]PendingAuthorizersQueue // Queue of authorizers (q ∈ C⟦H⟧QHC)
	PrivilegedServices       service.PrivilegedServices                         // Privileges state (x ∈ (NS, NS, NS, D⟨NS → NG⟩))
}

type Assignment struct {
	WorkReport *block.WorkReport // Work-Report (w)
	Time       jamtime.Timeslot  // time at which work-report was reported but not yet accumulated (t)
}

type BlockState struct {
	HeaderHash            crypto.Hash                 // Hash of the block header (h)
	AccumulationResultMMR []*crypto.Hash              // Accumulation-result MMR (s)
	StateRoot             crypto.Hash                 // State root (b)
	WorkReportHashes      map[crypto.Hash]crypto.Hash // Hashes of work-reports (p)
}

type CoreAssignments [common.TotalNumberOfCores]*Assignment

type CoreAuthorizersPool [common.TotalNumberOfCores][]crypto.Hash // TODO: Maximum length per core: MaxAuthorizersPerCore

type EntropyPool [EntropyPoolSize]crypto.Hash

type Judgements struct {
	GoodWorkReports     []crypto.Hash       //  Good work-reports (ψg) - Work-reports judged to be correct.
	BadWorkReports      []crypto.Hash       //  Bad work-reports (ψb) - Work-reports judged to be incorrect.
	WonkyWorkReports    []crypto.Hash       //  Wonky work-reports (ψw) - Work-reports whose validity is judged to be unknowable.
	OffendingValidators []ed25519.PublicKey //  Offending validators (ψp) - CurrentValidators who made a judgement found to be incorrect.
}

type PendingAuthorizersQueue [PendingAuthorizersQueueSize]crypto.Hash

type PendingAuthorizersQueues [common.TotalNumberOfCores]PendingAuthorizersQueue

type ServiceHashPair struct {
	ServiceId block.ServiceId
	Hash      crypto.Hash
}

type State struct {
	Services                 service.ServiceState              // Service accounts mapping (δ)
	PrivilegedServices       service.PrivilegedServices        // Privileged services (𝝌): services which hold some privileged status.
	ValidatorState           validator.ValidatorState          // Validator related state (κ, λ, ι, γ)
	EntropyPool              EntropyPool                       // On-chain Entropy pool (η): pool of entropy accumulators (also called randomness accumulators).
	CoreAuthorizersPool      CoreAuthorizersPool               // Core authorizers pool (α): authorization requirement which work done on that core must satisfy at the time of being reported on-chain.
	PendingAuthorizersQueues PendingAuthorizersQueues          // Pending Core authorizers queue (φ): the queue which fills core authorizations.
	CoreAssignments          CoreAssignments                   // Core assignments (ρ): each of the cores’ currently assigned report, the availability of whose work-package must yet be assured by a super-majority of validators. This is what each core is up to right now, tracks the work-reports which have been reported but not yet accumulated, the identities of the guarantors who reported them and the time at which it was reported.
	RecentBlocks             []BlockState                      // Block-related state (β): details of the most recent blocks. TODO: Maximum length: MaxRecentBlocks
	TimeslotIndex            jamtime.Timeslot                  // Time-related state (τ): the most recent block’s slot index.
	PastJudgements           Judgements                        // PastJudgements (ψ) - past judgements on work-reports and validators.
	ActivityStatistics       validator.ActivityStatisticsState // Validator statistics (π) - The activity statistics for the validators.
	AccumulationQueue        AccumulationQueue                 // Accumulation Queue (ϑ) - ready (i.e. available and/or audited) but not-yet-accumulated work-reports. Each of these were made available at most one epoch ago but have or had unfulfilled dependencies.
	AccumulationHistory      AccumulationHistory               // Accumulation history (ξ) - history of what has been accumulated for an epoch worth of work-reports. Mapping of work-package hash to segment-root.
	AccumulationOutputLog    AccumulationOutputLog             // Accumulation Output Log (θ)
}

type TicketOrKey interface {
	TicketOrKeyType()
}

type WorkReportWithUnAccumulatedDependencies struct {
	WorkReport   block.WorkReport
	Dependencies map[crypto.Hash]struct{} // Set of Dependencies (Work-Package Hashes related to work report)
}