block

type Assurance struct {
	Anchor         crypto.Hash              // Parent block hash (a ∈ H)
	Bitfield       [AvailBitfieldBytes]byte // Bitstring of assurances, one bit per core (f ∈ B_C)
	ValidatorIndex uint16                   // Index of the attesting validator (v ∈ N_V)
	Signature      crypto.Ed25519Signature  // Ed25519 signature (s ∈ E)
}

type AssurancesExtrinsic []Assurance

type Block struct {
	Header    Header
	Extrinsic Extrinsic
}

type CredentialSignature struct {
	ValidatorIndex uint16                  // Index of the validator providing this signature
	Signature      crypto.Ed25519Signature // The Ed25519 signature
}

type Culprit struct {
	ReportHash                crypto.Hash             // H, hash of the work report
	ValidatorEd25519PublicKey ed25519.PublicKey       // He
	Signature                 crypto.Ed25519Signature // E
}

type DisputeExtrinsic struct {
	Verdicts []Verdict
	Culprits []Culprit
	Faults   []Fault
}

type EpochMarker struct {
	Entropy        crypto.Hash
	TicketsEntropy crypto.Hash
	Keys           [common.NumberOfValidators]ValidatorKeys
}

type Extrinsic struct {
	ET TicketExtrinsic
	EP PreimageExtrinsic
	EG GuaranteesExtrinsic
	EA AssurancesExtrinsic
	ED DisputeExtrinsic
}

type Fault struct {
	ReportHash                crypto.Hash             // H, hash of the work report
	IsValid                   bool                    // {⊺,⊥}
	ValidatorEd25519PublicKey ed25519.PublicKey       // He
	Signature                 crypto.Ed25519Signature // E
}

type Guarantee struct {
	WorkReport  WorkReport            // The work report being guaranteed
	Timeslot    jamtime.Timeslot      // The timeslot when this guarantee was made
	Credentials []CredentialSignature // The credentials proving the guarantee's validity
}

type GuaranteesExtrinsic struct {
	Guarantees []Guarantee
}

type Header struct {
	ParentHash           crypto.Hash                  // Hp
	PriorStateRoot       crypto.Hash                  // Hr
	ExtrinsicHash        crypto.Hash                  // Hx
	TimeSlotIndex        jamtime.Timeslot             // Ht
	EpochMarker          *EpochMarker                 // He
	WinningTicketsMarker *WinningTicketMarker         // Hw
	OffendersMarkers     []ed25519.PublicKey          // Ho, the culprit's and fault's public keys
	BlockAuthorIndex     uint16                       // Hi
	VRFSignature         crypto.BandersnatchSignature // Hv
	BlockSealSignature   crypto.BandersnatchSignature // Hs
}

type Judgement struct {
	IsValid        bool                    // v: {⊺,⊥}
	ValidatorIndex uint16                  // i: NV
	Signature      crypto.Ed25519Signature // s: E
}

type Preimage struct {
	ServiceIndex uint32 // s
	Data         []byte // p
}

type PreimageExtrinsic []Preimage

type RefinementContext struct {
	Anchor                  RefinementContextAnchor       // Historical block anchor
	LookupAnchor            RefinementContextLookupAnchor // Historical block anchor
	PrerequisiteWorkPackage []crypto.Hash                 // Prerequisite work package (p)
}

type RefinementContextAnchor struct {
	HeaderHash         crypto.Hash // HeaderHash of the anchor (a)
	PosteriorStateRoot crypto.Hash // Posterior state root (s)
	PosteriorBeefyRoot crypto.Hash // Posterior beefy root (b)
}

type RefinementContextLookupAnchor struct {
	HeaderHash crypto.Hash      // HeaderHash of the anchor (l)
	Timeslot   jamtime.Timeslot // Timeslot (t)
}

type ServiceId uint32

type Ticket struct {
	Identifier crypto.BandersnatchOutputHash // y ∈ H 32bytes hash
	EntryIndex uint8                         // r ∈ Nn (0, 1)
}

type TicketExtrinsic struct {
	TicketProofs []TicketProof
}

type TicketProof struct {
	EntryIndex uint8                 // r ∈ Nn (0, 1)
	Proof      [TicketProofSize]byte // RingVRF proof
}

type ValidatorKeys struct {
	Bandersnatch crypto.BandersnatchPublicKey
	Ed25519      ed25519.PublicKey
}

type Verdict struct {
	ReportHash crypto.Hash                               // H, hash of the work report
	EpochIndex uint32                                    // ⌊τ/E⌋ - N2, epoch index
	Judgements [common.ValidatorsSuperMajority]Judgement // ⟦{⊺,⊥},NV,E⟧⌊2/3V⌋+1
}

type WinningTicketMarker [jamtime.TimeslotsPerEpoch]Ticket

type WorkPackageSpecification struct {
	WorkPackageHash           crypto.Hash // Hash of the work-package (h)
	AuditableWorkBundleLength uint32      // Length of the auditable work bundle (l)
	ErasureRoot               crypto.Hash // Erasure root (u) - is the root of a binary Merkle tree which functions as a commitment to all data required for the auditing of the report and for use by later workpackages should they need to retrieve any data yielded. It is thus used by assurers to verify the correctness of data they have been sent by guarantors, and it is later verified as correct by auditors.
	SegmentRoot               crypto.Hash // Segment root (e) - root of a constant-depth, left-biased and zero-hash-padded binary Merkle tree committing to the hashes of each of the exported segments of each work-item. These are used by guarantors to verify the correctness of any reconstructed segments they are called upon to import for evaluation of some later work-package.
	SegmentCount              uint16      // Segment count (n)
}

type WorkReport struct {
	WorkPackageSpecification WorkPackageSpecification    // Work-package specification (s)
	RefinementContext        RefinementContext           // Refinement context (x)
	CoreIndex                uint16                      `jam:"encoding=compact"` // Core index (c) - Max value: TotalNumberOfCores
	AuthorizerHash           crypto.Hash                 // HeaderHash of the authorizer (a)
	Output                   []byte                      // Output of the work report (o)
	SegmentRootLookup        map[crypto.Hash]crypto.Hash // A segment-root lookup dictionary (l ∈ D⟨H → H⟩)
	WorkResults              []WorkResult                // Results of the evaluation of each of the items in the work-package (r) - Min value: MinWorkPackageResultsSize. Max value: MaxWorkPackageResultsSize.
	AuthGasUsed              uint64                      `jam:"encoding=compact"` // The amount of gas used during authorization (g)
}

type WorkResult struct {
	ServiceId              ServiceId               // Service ID (s) - The index of the service whose state is to be altered and thus whose refine code was already executed.
	ServiceHashCode        crypto.Hash             // Hash of the service code (c) - The hash of the code of the service at the time of being reported.
	PayloadHash            crypto.Hash             // Hash of the payload (y) - The hash of the payload within the work item which was executed in the refine stage to give this result. Provided to the accumulation logic of the service later on.
	GasPrioritizationRatio uint64                  // Gas prioritization ratio (g) - used when determining how much gas should be allocated to execute of this item’s accumulate.
	Output                 WorkResultOutputOrError // Output of the work result (d) ∈ Y ∪ J: Output or error (Y is the set of octet strings, J is the set of work execution errors)
	GasUsed                uint64                  `jam:"encoding=compact"` // (u) the actual amount of gas used during refinement
	ImportsCount           uint16                  `jam:"encoding=compact"` // (i) the number of segments imported from
	ExtrinsicCount         uint16                  `jam:"encoding=compact"` // (x) the number of the extrinsics used in computing the workload
	ExtrinsicSize          uint32                  `jam:"encoding=compact"` // (z) total size in octets of the extrinsics used in computing the workload
	ExportsCount           uint16                  `jam:"encoding=compact"` // (e) the number of segments exported into
}

type WorkResultError uint8

type WorkResultOutputOrError struct {
	Inner any
}