Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.Protocol.PBFT.State

Contents

Construction
Queries
Conversion
Serialization

Description

PBFT chain state

Intended for qualified import.

Synopsis

data PBftState c = PBftState {
- inWindow :: !(StrictSeq (PBftSigner c))
- counts :: !(Map (PBftVerKeyHash c) Word64)
}
data family Ticked st :: Type
newtype WindowSize = WindowSize {
- getWindowSize :: Word64
}
data PBftSigner c = PBftSigner {
- pbftSignerSlotNo :: !SlotNo
- pbftSignerGenesisKey :: !(PBftVerKeyHash c)
}
empty :: PBftState c
append :: forall c. PBftCrypto c => WindowSize -> PBftSigner c -> PBftState c -> PBftState c
countSignatures :: PBftState c -> Word64
countSignedBy :: PBftCrypto c => PBftState c -> PBftVerKeyHash c -> Word64
lastSignedSlot :: PBftState c -> WithOrigin SlotNo
toList :: PBftState c -> [PBftSigner c]
fromList :: PBftCrypto c => [PBftSigner c] -> PBftState c
encodePBftState :: (PBftCrypto c, Serialise (PBftVerKeyHash c)) => PBftState c -> Encoding
decodePBftState :: forall c. (PBftCrypto c, Serialise (PBftVerKeyHash c)) => forall s. Decoder s (PBftState c)

Documentation

data PBftState c Source #

PBFT state

For a window size of n, the PBFT chain state is a sequence of signatures over the last n slots

+-------------------------------------------+
|                signatures                 |
+-------------------------------------------+

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                 window of n

We need the last n signatures to verify that no single key has signed more than a certain threshold percentage of the slots.

When near genesis, we will have less than n signatures in the history.

The window size itself is pretty much arbitrary and will be fixed by a particular blockchain specification (e.g., Byron).

Constructors

PBftState
Fields inWindow :: !(StrictSeq (PBftSigner c)) Signatures in the window We should have precisely `n` signatures in the window, unless we are near genesis. INVARIANT Empty if and only if we are exactly at genesis. counts :: !(Map (PBftVerKeyHash c) Word64) Cached counts of the signatures in the window

Instances

Instances details

PBftCrypto c => Eq (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods (==) :: PBftState c -> PBftState c -> Bool # (/=) :: PBftState c -> PBftState c -> Bool #
PBftCrypto c => Show (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods showsPrec :: Int -> PBftState c -> ShowS # show :: PBftState c -> String # showList :: [PBftState c] -> ShowS #
Generic (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Associated Types type Rep (PBftState c) :: Type -> Type # Methods from :: PBftState c -> Rep (PBftState c) x # to :: Rep (PBftState c) x -> PBftState c #
PBftCrypto c => NoThunks (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods noThunks :: Context -> PBftState c -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> PBftState c -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy (PBftState c) -> String Source #
type Rep (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State type Rep (PBftState c) = D1 ('MetaData "PBftState" "Ouroboros.Consensus.Protocol.PBFT.State" "ouroboros-consensus-0.1.0.0-GfJNvFcM6lj2s5utKAUPEp" 'False) (C1 ('MetaCons "PBftState" 'PrefixI 'True) (S1 ('MetaSel ('Just "inWindow") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (StrictSeq (PBftSigner c))) :*: S1 ('MetaSel ('Just "counts") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map (PBftVerKeyHash c) Word64))))
data Ticked (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT data Ticked (PBftState c) = TickedPBftState { tickedPBftLedgerView :: Ticked (LedgerView (PBft c)) getTickedPBftState :: PBftState c }

data family Ticked st :: Type Source #

" Ticked " piece of state (LedgerState, LedgerView, ChainIndepState)

Ticking refers to the passage of time (the ticking of the clock). When a piece of state is marked as ticked, it means that time-related changes have been applied to the state (or forecast).

Some examples of time related changes:

Scheduled delegations might have been applied in Byron
New leader schedule computed for Shelley
Transition from Byron to Shelley activated in the hard fork combinator.
Nonces switched out at the start of a new epoch.

Instances

Instances details

Show (Ticked ()) Source #
Instance details Defined in Ouroboros.Consensus.Ticked Methods showsPrec :: Int -> Ticked () -> ShowS # show :: Ticked () -> String # showList :: [Ticked ()] -> ShowS #
Show (Ticked a) => Show (Ticked (K a x)) Source #
Instance details Defined in Ouroboros.Consensus.Ticked Methods showsPrec :: Int -> Ticked (K a x) -> ShowS # show :: Ticked (K a x) -> String # showList :: [Ticked (K a x)] -> ShowS #
(SListI xs, Show (Ticked a)) => Show (Ticked (HardForkLedgerView_ (K a :: Type -> Type) xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.LedgerView Methods showsPrec :: Int -> Ticked (HardForkLedgerView_ (K a) xs) -> ShowS # show :: Ticked (HardForkLedgerView_ (K a) xs) -> String # showList :: [Ticked (HardForkLedgerView_ (K a) xs)] -> ShowS #
Generic (Ticked (LedgerState (HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type Rep (Ticked (LedgerState (HardForkBlock xs))) :: Type -> Type # Methods from :: Ticked (LedgerState (HardForkBlock xs)) -> Rep (Ticked (LedgerState (HardForkBlock xs))) x # to :: Rep (Ticked (LedgerState (HardForkBlock xs))) x -> Ticked (LedgerState (HardForkBlock xs)) #
NoThunks (Ticked (LedgerState (DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> Ticked (LedgerState (DualBlock m a)) -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> Ticked (LedgerState (DualBlock m a)) -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy (Ticked (LedgerState (DualBlock m a))) -> String Source #
CanHardFork xs => NoThunks (Ticked (LedgerState (HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods noThunks :: Context -> Ticked (LedgerState (HardForkBlock xs)) -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> Ticked (LedgerState (HardForkBlock xs)) -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy (Ticked (LedgerState (HardForkBlock xs))) -> String Source #
Bridge m a => GetTip (Ticked (LedgerState (DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods getTip :: Ticked (LedgerState (DualBlock m a)) -> Point (Ticked (LedgerState (DualBlock m a))) Source #
CanHardFork xs => GetTip (Ticked (LedgerState (HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods getTip :: Ticked (LedgerState (HardForkBlock xs)) -> Point (Ticked (LedgerState (HardForkBlock xs))) Source #
IsLedger l => GetTip (Ticked (LedgerDB l r)) Source #
Instance details Defined in Ouroboros.Consensus.Storage.LedgerDB.InMemory Methods getTip :: Ticked (LedgerDB l r) -> Point (Ticked (LedgerDB l r)) Source #
IsLedger (LedgerState blk) => GetTip (Ticked (ExtLedgerState blk)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Extended Methods getTip :: Ticked (ExtLedgerState blk) -> Point (Ticked (ExtLedgerState blk)) Source #
Isomorphic (Ticked :.: LedgerState) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Unary Methods project :: NoHardForks blk => (Ticked :.: LedgerState) (HardForkBlock '[blk]) -> (Ticked :.: LedgerState) blk Source # inject :: NoHardForks blk => (Ticked :.: LedgerState) blk -> (Ticked :.: LedgerState) (HardForkBlock '[blk]) Source #
Show (Ticked (f a)) => Show ((Ticked :.: f) a) Source #
Instance details Defined in Ouroboros.Consensus.Ticked Methods showsPrec :: Int -> (Ticked :.: f) a -> ShowS # show :: (Ticked :.: f) a -> String # showList :: [(Ticked :.: f) a] -> ShowS #
NoThunks (Ticked (f a)) => NoThunks ((Ticked :.: f) a) Source #
Instance details Defined in Ouroboros.Consensus.Ticked Methods noThunks :: Context -> (Ticked :.: f) a -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> (Ticked :.: f) a -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy ((Ticked :.: f) a) -> String Source #
data Ticked () Source #
Instance details Defined in Ouroboros.Consensus.Ticked data Ticked () = TickedTrivial
type Rep (Ticked (LedgerState (HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type Rep (Ticked (LedgerState (HardForkBlock xs))) = D1 ('MetaData "Ticked" "Ouroboros.Consensus.HardFork.Combinator.Ledger" "ouroboros-consensus-0.1.0.0-GfJNvFcM6lj2s5utKAUPEp" 'False) (C1 ('MetaCons "TickedHardForkLedgerState" 'PrefixI 'True) (S1 ('MetaSel ('Just "tickedHardForkLedgerStateTransition") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 TransitionInfo) :*: S1 ('MetaSel ('Just "tickedHardForkLedgerStatePerEra") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HardForkState (Ticked :.: LedgerState) xs))))
type HeaderHash (Ticked l) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Basics type HeaderHash (Ticked l) = HeaderHash l
data Ticked (LedgerState (DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data Ticked (LedgerState (DualBlock m a)) = TickedDualLedgerState { tickedDualLedgerStateMain :: Ticked (LedgerState m) tickedDualLedgerStateAux :: Ticked (LedgerState a) tickedDualLedgerStateBridge :: BridgeLedger m a tickedDualLedgerStateAuxOrig :: LedgerState a }
data Ticked (LedgerState (HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger data Ticked (LedgerState (HardForkBlock xs)) = TickedHardForkLedgerState { tickedHardForkLedgerStateTransition :: !TransitionInfo tickedHardForkLedgerStatePerEra :: !(HardForkState (Ticked :.: LedgerState) xs) }
data Ticked (HeaderState blk) Source #
Instance details Defined in Ouroboros.Consensus.HeaderValidation data Ticked (HeaderState blk) = TickedHeaderState { untickedHeaderStateTip :: WithOrigin (AnnTip blk) tickedHeaderStateChainDep :: Ticked (ChainDepState (BlockProtocol blk)) }
data Ticked (ExtLedgerState blk) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Extended data Ticked (ExtLedgerState blk) = TickedExtLedgerState { tickedLedgerState :: Ticked (LedgerState blk) tickedLedgerView :: Ticked (LedgerView (BlockProtocol blk)) tickedHeaderState :: Ticked (HeaderState blk) }
newtype Ticked (WrapLedgerView blk) Source #
Instance details Defined in Ouroboros.Consensus.TypeFamilyWrappers newtype Ticked (WrapLedgerView blk) = WrapTickedLedgerView { unwrapTickedLedgerView :: Ticked (LedgerView (BlockProtocol blk)) }
newtype Ticked (WrapChainDepState blk) Source #
Instance details Defined in Ouroboros.Consensus.TypeFamilyWrappers newtype Ticked (WrapChainDepState blk) = WrapTickedChainDepState { unwrapTickedChainDepState :: Ticked (ChainDepState (BlockProtocol blk)) }
data Ticked (HardForkChainDepState xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol data Ticked (HardForkChainDepState xs) = TickedHardForkChainDepState { tickedHardForkChainDepStatePerEra :: HardForkState (Ticked :.: WrapChainDepState) xs tickedHardForkChainDepStateEpochInfo :: EpochInfo Identity }
data Ticked (PBftState c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT data Ticked (PBftState c) = TickedPBftState { tickedPBftLedgerView :: Ticked (LedgerView (PBft c)) getTickedPBftState :: PBftState c }
data Ticked (PBftLedgerView c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT data Ticked (PBftLedgerView c) = TickedPBftLedgerView { tickedPBftDelegates :: Bimap (PBftVerKeyHash c) (PBftVerKeyHash c) }
data Ticked (LedgerDB l r) Source #	Ticking the ledger DB just ticks the current state We don't push the new state into the DB until we apply a block.
Instance details Defined in Ouroboros.Consensus.Storage.LedgerDB.InMemory data Ticked (LedgerDB l r) = TickedLedgerDB { tickedLedgerDbTicked :: Ticked l tickedLedgerDbOrig :: LedgerDB l r }
data Ticked (HardForkLedgerView_ f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.LedgerView data Ticked (HardForkLedgerView_ f xs) = TickedHardForkLedgerView { tickedHardForkLedgerViewTransition :: TransitionInfo tickedHardForkLedgerViewPerEra :: HardForkState (Ticked :.: f) xs }
newtype Ticked (K a x) Source #
Instance details Defined in Ouroboros.Consensus.Ticked newtype Ticked (K a x) = TickedK { getTickedK :: Ticked a }

newtype WindowSize Source #

Window size

See PBftState itself for a detailed discussion on the window size versus the number of signatures.

Constructors

WindowSize
Fields getWindowSize :: Word64

Instances

Instances details

Enum WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods succ :: WindowSize -> WindowSize # pred :: WindowSize -> WindowSize # toEnum :: Int -> WindowSize # fromEnum :: WindowSize -> Int # enumFrom :: WindowSize -> [WindowSize] # enumFromThen :: WindowSize -> WindowSize -> [WindowSize] # enumFromTo :: WindowSize -> WindowSize -> [WindowSize] # enumFromThenTo :: WindowSize -> WindowSize -> WindowSize -> [WindowSize] #
Eq WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods (==) :: WindowSize -> WindowSize -> Bool # (/=) :: WindowSize -> WindowSize -> Bool #
Integral WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods quot :: WindowSize -> WindowSize -> WindowSize # rem :: WindowSize -> WindowSize -> WindowSize # div :: WindowSize -> WindowSize -> WindowSize # mod :: WindowSize -> WindowSize -> WindowSize # quotRem :: WindowSize -> WindowSize -> (WindowSize, WindowSize) # divMod :: WindowSize -> WindowSize -> (WindowSize, WindowSize) # toInteger :: WindowSize -> Integer #
Num WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods (+) :: WindowSize -> WindowSize -> WindowSize # (-) :: WindowSize -> WindowSize -> WindowSize # (*) :: WindowSize -> WindowSize -> WindowSize # negate :: WindowSize -> WindowSize # abs :: WindowSize -> WindowSize # signum :: WindowSize -> WindowSize # fromInteger :: Integer -> WindowSize #
Ord WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods compare :: WindowSize -> WindowSize -> Ordering # (<) :: WindowSize -> WindowSize -> Bool # (<=) :: WindowSize -> WindowSize -> Bool # (>) :: WindowSize -> WindowSize -> Bool # (>=) :: WindowSize -> WindowSize -> Bool # max :: WindowSize -> WindowSize -> WindowSize # min :: WindowSize -> WindowSize -> WindowSize #
Real WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods toRational :: WindowSize -> Rational #
Show WindowSize Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods showsPrec :: Int -> WindowSize -> ShowS # show :: WindowSize -> String # showList :: [WindowSize] -> ShowS #

data PBftSigner c Source #

Slot and corresponding genesis key

Constructors

PBftSigner
Fields pbftSignerSlotNo :: !SlotNo pbftSignerGenesisKey :: !(PBftVerKeyHash c)

Instances

Instances details

PBftCrypto c => Eq (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods (==) :: PBftSigner c -> PBftSigner c -> Bool # (/=) :: PBftSigner c -> PBftSigner c -> Bool #
PBftCrypto c => Show (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods showsPrec :: Int -> PBftSigner c -> ShowS # show :: PBftSigner c -> String # showList :: [PBftSigner c] -> ShowS #
Generic (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Associated Types type Rep (PBftSigner c) :: Type -> Type # Methods from :: PBftSigner c -> Rep (PBftSigner c) x # to :: Rep (PBftSigner c) x -> PBftSigner c #
PBftCrypto c => NoThunks (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods noThunks :: Context -> PBftSigner c -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> PBftSigner c -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy (PBftSigner c) -> String Source #
Serialise (PBftVerKeyHash c) => Serialise (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State Methods encode :: PBftSigner c -> Encoding Source # decode :: Decoder s (PBftSigner c) Source # encodeList :: [PBftSigner c] -> Encoding Source # decodeList :: Decoder s [PBftSigner c] Source #
type Rep (PBftSigner c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT.State type Rep (PBftSigner c) = D1 ('MetaData "PBftSigner" "Ouroboros.Consensus.Protocol.PBFT.State" "ouroboros-consensus-0.1.0.0-GfJNvFcM6lj2s5utKAUPEp" 'False) (C1 ('MetaCons "PBftSigner" 'PrefixI 'True) (S1 ('MetaSel ('Just "pbftSignerSlotNo") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SlotNo) :*: S1 ('MetaSel ('Just "pbftSignerGenesisKey") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (PBftVerKeyHash c))))

Construction

empty :: PBftState c Source #

Empty PBFT chain state

In other words, the PBFT chain state corresponding to genesis.

append :: forall c. PBftCrypto c => WindowSize -> PBftSigner c -> PBftState c -> PBftState c Source #

Append new signature

Drops the oldest signature, provided we have reached the required number.

Queries

countSignatures :: PBftState c -> Word64 Source #

Number of signatures in the window

This will be equal to the specified window size, unless near genesis

countSignedBy :: PBftCrypto c => PBftState c -> PBftVerKeyHash c -> Word64 Source #

The number of blocks signed by the specified genesis key

This only considers the signatures within the window, not in the pre-window; see PBftState for detailed discussion.

lastSignedSlot :: PBftState c -> WithOrigin SlotNo Source #

The last (most recent) signed slot in the window

Returns Origin if there are no signatures in the window (this will happen exactly at genesis only).

Unaffected by EBBs, since they're not signed.

Conversion

toList :: PBftState c -> [PBftSigner c] Source #

fromList :: PBftCrypto c => [PBftSigner c] -> PBftState c Source #

Note: we are not checking the invariants because we don't want to require the WindowSize to be in the context, see #2383. When assertions are enabled, we would notice the invariant violation as soon as we append.

PRECONDITION: the slots of the signers are in ascending order.

Serialization

encodePBftState :: (PBftCrypto c, Serialise (PBftVerKeyHash c)) => PBftState c -> Encoding Source #

decodePBftState :: forall c. (PBftCrypto c, Serialise (PBftVerKeyHash c)) => forall s. Decoder s (PBftState c) Source #