Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.HardFork.Combinator

Description

The hard fork combinator

Intended for unqualified import

Synopsis

type Except e = ExceptT e Identity
data EpochInfo (m :: Type -> Type ) = EpochInfo {
- epochInfoSize_ :: HasCallStack => EpochNo -> m EpochSize
- epochInfoFirst_ :: HasCallStack => EpochNo -> m SlotNo
- epochInfoEpoch_ :: HasCallStack => SlotNo -> m EpochNo
- epochInfoSlotToRelativeTime_ :: HasCallStack => SlotNo -> m RelativeTime
- epochInfoSlotLength_ :: HasCallStack => SlotNo -> m SlotLength
}
newtype LedgerEraInfo blk = LedgerEraInfo {
- getLedgerEraInfo :: SingleEraInfo blk
}
data SingleEraInfo blk = SingleEraInfo {
- singleEraName :: ! Text
}
data Product2 f g x y = Pair2 (f x y) (g x y)
data family Ticked st :: Type
data family NestedCtxt_ blk :: ( Type -> Type ) -> Type -> Type
data family Header blk :: Type
data family StorageConfig blk :: Type
data family CodecConfig blk :: Type
data family BlockConfig blk :: Type
data family ConsensusConfig p :: Type
data family LedgerState blk :: Type
data family Validated x :: Type
data family TxId tx :: Type
data family GenTx blk :: Type
class IsNonEmpty xs where
- isNonEmpty :: proxy xs -> ProofNonEmpty xs
data ProofNonEmpty :: [a] -> Type where
- ProofNonEmpty :: Proxy x -> Proxy xs -> ProofNonEmpty (x ': xs)
data PastHorizonException
newtype WrapPartialConsensusConfig blk = WrapPartialConsensusConfig {
- unwrapPartialConsensusConfig :: PartialConsensusConfig ( BlockProtocol blk)
}
newtype WrapPartialLedgerConfig blk = WrapPartialLedgerConfig {
- unwrapPartialLedgerConfig :: PartialLedgerConfig blk
}
class ( UpdateLedger blk, NoThunks ( PartialLedgerConfig blk)) => HasPartialLedgerConfig blk where
- type PartialLedgerConfig blk :: Type
- completeLedgerConfig :: proxy blk -> EpochInfo ( Except PastHorizonException ) -> PartialLedgerConfig blk -> LedgerConfig blk
class ( ConsensusProtocol p, NoThunks ( PartialConsensusConfig p)) => HasPartialConsensusConfig p where
- type PartialConsensusConfig p :: Type
- completeConsensusConfig :: proxy p -> EpochInfo ( Except PastHorizonException ) -> PartialConsensusConfig p -> ConsensusConfig p
- toPartialConsensusConfig :: proxy p -> ConsensusConfig p -> PartialConsensusConfig p
data InPairs (f :: k -> k -> Type ) (xs :: [k]) where
- PNil :: InPairs f '[x]
- PCons :: f x y -> InPairs f (y ': zs) -> InPairs f (x ': (y ': zs))
data Telescope (g :: k -> Type ) (f :: k -> Type ) (xs :: [k]) where
- TZ :: !(f x) -> Telescope g f (x ': xs)
- TS :: !(g x) -> !( Telescope g f xs) -> Telescope g f (x ': xs)
data Mismatch :: (k -> Type ) -> (k -> Type ) -> [k] -> Type where
- ML :: f x -> NS g xs -> Mismatch f g (x ': xs)
- MR :: NS f xs -> g x -> Mismatch f g (x ': xs)
- MS :: Mismatch f g xs -> Mismatch f g (x ': xs)
newtype HardForkState f xs = HardForkState {
- getHardForkState :: Telescope ( K Past ) ( Current f) xs
}
data EraTranslation xs = EraTranslation {
- translateLedgerState :: InPairs ( RequiringBoth WrapLedgerConfig ( Translate LedgerState )) xs
- translateChainDepState :: InPairs ( RequiringBoth WrapConsensusConfig ( Translate WrapChainDepState )) xs
- translateLedgerView :: InPairs ( RequiringBoth WrapLedgerConfig ( TranslateForecast LedgerState WrapLedgerView )) xs
}
trivialEraTranslation :: EraTranslation '[blk]
type InjectValidatedTx = InjectPolyTx WrapValidatedGenTx
type InjectTx = InjectPolyTx GenTx
pattern InjectValidatedTx :: ( WrapValidatedGenTx blk -> Maybe ( WrapValidatedGenTx blk')) -> InjectValidatedTx blk blk'
pattern InjectTx :: ( GenTx blk -> Maybe ( GenTx blk')) -> InjectTx blk blk'
cannotInjectTx :: InjectTx blk blk'
cannotInjectValidatedTx :: InjectValidatedTx blk blk'
data family BlockQuery blk :: Type -> Type
newtype EraIndex xs = EraIndex {
- getEraIndex :: NS ( K ()) xs
}
class ( LedgerSupportsProtocol blk, InspectLedger blk, LedgerSupportsMempool blk, HasTxId ( GenTx blk), QueryLedger blk, HasPartialConsensusConfig ( BlockProtocol blk), HasPartialLedgerConfig blk, ConvertRawHash blk, ReconstructNestedCtxt Header blk, CommonProtocolParams blk, LedgerSupportsPeerSelection blk, ConfigSupportsNode blk, NodeInitStorage blk, BlockSupportsMetrics blk, Eq ( GenTx blk), Eq ( Validated ( GenTx blk)), Eq ( ApplyTxErr blk), Show blk, Show ( Header blk), Show ( CannotForge blk), Show ( ForgeStateInfo blk), Show ( ForgeStateUpdateError blk)) => SingleEraBlock blk where
- singleEraTransition :: PartialLedgerConfig blk -> EraParams -> Bound -> LedgerState blk -> Maybe EpochNo
- singleEraInfo :: proxy blk -> SingleEraInfo blk
proxySingle :: Proxy SingleEraBlock
singleEraTransition' :: SingleEraBlock blk => WrapPartialLedgerConfig blk -> EraParams -> Bound -> LedgerState blk -> Maybe EpochNo
eraIndexEmpty :: EraIndex '[] -> Void
eraIndexFromNS :: SListI xs => NS f xs -> EraIndex xs
eraIndexFromIndex :: Index xs blk -> EraIndex xs
eraIndexZero :: EraIndex (x ': xs)
eraIndexSucc :: EraIndex xs -> EraIndex (x ': xs)
eraIndexToInt :: EraIndex xs -> Int
initHardForkState :: f x -> HardForkState f (x ': xs)
data WithBlockNo (f :: k -> Type ) (a :: k) = WithBlockNo {
- getBlockNo :: BlockNo
- dropBlockNo :: f a
}
data AcrossEraSelection :: Type -> Type -> Type where
- CompareBlockNo :: AcrossEraSelection x y
- SelectSameProtocol :: BlockProtocol x ~ BlockProtocol y => AcrossEraSelection x y
- CustomChainSel :: ( SelectView ( BlockProtocol x) -> SelectView ( BlockProtocol y) -> Ordering ) -> AcrossEraSelection x y
acrossEraSelection :: All SingleEraBlock xs => Tails AcrossEraSelection xs -> WithBlockNo ( NS WrapSelectView ) xs -> WithBlockNo ( NS WrapSelectView ) xs -> Ordering
mapWithBlockNo :: (f x -> g y) -> WithBlockNo f x -> WithBlockNo g y
class SingleEraBlock blk => NoHardForks blk where
- getEraParams :: TopLevelConfig blk -> EraParams
- toPartialLedgerConfig :: proxy blk -> LedgerConfig blk -> PartialLedgerConfig blk
noHardForksEpochInfo :: ( Monad m, NoHardForks blk) => TopLevelConfig blk -> EpochInfo m
class ( All SingleEraBlock xs, Typeable xs, IsNonEmpty xs) => CanHardFork xs where
- hardForkEraTranslation :: EraTranslation xs
- hardForkChainSel :: Tails AcrossEraSelection xs
- hardForkInjectTxs :: InPairs ( RequiringBoth WrapLedgerConfig ( Product2 InjectTx InjectValidatedTx )) xs
type HardForkLedgerView = HardForkLedgerView_ WrapLedgerView
data HardForkLedgerView_ f xs = HardForkLedgerView {
- hardForkLedgerViewTransition :: ! TransitionInfo
- hardForkLedgerViewPerEra :: !( HardForkState f xs)
}
newtype MismatchEraInfo xs = MismatchEraInfo {
- getMismatchEraInfo :: Mismatch SingleEraInfo LedgerEraInfo xs
}
newtype OneEraHash (xs :: [k]) = OneEraHash {
- getOneEraHash :: ShortByteString
}
newtype OneEraTipInfo xs = OneEraTipInfo {
- getOneEraTipInfo :: NS WrapTipInfo xs
}
newtype OneEraHeader xs = OneEraHeader {
- getOneEraHeader :: NS Header xs
}
newtype OneEraGenTxId xs = OneEraGenTxId {
- getOneEraGenTxId :: NS WrapGenTxId xs
}
newtype OneEraGenTx xs = OneEraGenTx {
- getOneEraGenTx :: NS GenTx xs
}
newtype OneEraBlock xs = OneEraBlock {
- getOneEraBlock :: NS I xs
}
newtype OneEraApplyTxErr xs = OneEraApplyTxErr {
- getOneEraApplyTxErr :: NS WrapApplyTxErr xs
}
newtype PerEraStorageConfig xs = PerEraStorageConfig {
- getPerEraStorageConfig :: NP StorageConfig xs
}
newtype PerEraLedgerConfig xs = PerEraLedgerConfig {
- getPerEraLedgerConfig :: NP WrapPartialLedgerConfig xs
}
newtype PerEraConsensusConfig xs = PerEraConsensusConfig {
- getPerEraConsensusConfig :: NP WrapPartialConsensusConfig xs
}
newtype PerEraCodecConfig xs = PerEraCodecConfig {
- getPerEraCodecConfig :: NP CodecConfig xs
}
newtype PerEraBlockConfig xs = PerEraBlockConfig {
- getPerEraBlockConfig :: NP BlockConfig xs
}
data HardForkLedgerConfig xs = HardForkLedgerConfig {
- hardForkLedgerConfigShape :: !( Shape xs)
- hardForkLedgerConfigPerEra :: !( PerEraLedgerConfig xs)
}
newtype HardForkBlock xs = HardForkBlock {
- getHardForkBlock :: OneEraBlock xs
}
data HardForkProtocol (xs :: [ Type ])
completeLedgerConfig' :: forall blk. HasPartialLedgerConfig blk => EpochInfo ( Except PastHorizonException ) -> WrapPartialLedgerConfig blk -> LedgerConfig blk
completeLedgerConfig'' :: forall blk. HasPartialLedgerConfig blk => EpochInfo ( Except PastHorizonException ) -> WrapPartialLedgerConfig blk -> WrapLedgerConfig blk
completeConsensusConfig' :: forall blk. HasPartialConsensusConfig ( BlockProtocol blk) => EpochInfo ( Except PastHorizonException ) -> WrapPartialConsensusConfig blk -> ConsensusConfig ( BlockProtocol blk)
completeConsensusConfig'' :: forall blk. HasPartialConsensusConfig ( BlockProtocol blk) => EpochInfo ( Except PastHorizonException ) -> WrapPartialConsensusConfig blk -> WrapConsensusConfig blk
distribLedgerConfig :: CanHardFork xs => EpochInfo ( Except PastHorizonException ) -> LedgerConfig ( HardForkBlock xs) -> NP WrapLedgerConfig xs
distribTopLevelConfig :: All SingleEraBlock xs => EpochInfo ( Except PastHorizonException ) -> TopLevelConfig ( HardForkBlock xs) -> NP TopLevelConfig xs
distribAnnTip :: SListI xs => AnnTip ( HardForkBlock xs) -> NS AnnTip xs
undistribAnnTip :: SListI xs => NS AnnTip xs -> AnnTip ( HardForkBlock xs)
data HardForkValidationErr xs
- = HardForkValidationErrFromEra ( OneEraValidationErr xs)
- | HardForkValidationErrWrongEra ( MismatchEraInfo xs)
type HardForkCanBeLeader xs = SomeErasCanBeLeader xs
type HardForkIsLeader xs = OneEraIsLeader xs
type HardForkChainDepState xs = HardForkState WrapChainDepState xs
data HardForkLedgerUpdate xs
- = HardForkUpdateInEra ( OneEraLedgerUpdate xs)
- | HardForkUpdateTransitionConfirmed ( EraIndex xs) ( EraIndex xs) EpochNo
- | HardForkUpdateTransitionDone ( EraIndex xs) ( EraIndex xs) EpochNo
- | HardForkUpdateTransitionRolledBack ( EraIndex xs) ( EraIndex xs)
data HardForkLedgerWarning xs
- = HardForkWarningInEra ( OneEraLedgerWarning xs)
- | HardForkWarningTransitionMismatch ( EraIndex xs) EraParams EpochNo
- | HardForkWarningTransitionInFinalEra ( EraIndex xs) EpochNo
- | HardForkWarningTransitionUnconfirmed ( EraIndex xs)
- | HardForkWarningTransitionReconfirmed ( EraIndex xs) ( EraIndex xs) EpochNo EpochNo
data AnnForecast state view blk = AnnForecast {
- annForecast :: Forecast (view blk)
- annForecastState :: state blk
- annForecastTip :: WithOrigin SlotNo
- annForecastEnd :: Maybe Bound
}
data HardForkEnvelopeErr xs
- = HardForkEnvelopeErrFromEra ( OneEraEnvelopeErr xs)
- | HardForkEnvelopeErrWrongEra ( MismatchEraInfo xs)
data HardForkLedgerError xs
- = HardForkLedgerErrorFromEra ( OneEraLedgerError xs)
- | HardForkLedgerErrorWrongEra ( MismatchEraInfo xs)
mkHardForkForecast :: forall state view xs. SListI xs => InPairs ( TranslateForecast state view) xs -> HardForkState ( AnnForecast state view) xs -> Forecast ( HardForkLedgerView_ view xs)
data HardForkApplyTxErr xs
- = HardForkApplyTxErrFromEra !( OneEraApplyTxErr xs)
- | HardForkApplyTxErrWrongEra !( MismatchEraInfo xs)
hardForkApplyTxErrToEither :: HardForkApplyTxErr xs -> Either ( MismatchEraInfo xs) ( OneEraApplyTxErr xs)
hardForkApplyTxErrFromEither :: Either ( MismatchEraInfo xs) ( OneEraApplyTxErr xs) -> HardForkApplyTxErr xs
data QueryHardFork xs result where
- GetInterpreter :: QueryHardFork xs ( Interpreter xs)
- GetCurrentEra :: QueryHardFork xs ( EraIndex xs)
data QueryAnytime result where
- GetEraStart :: QueryAnytime ( Maybe Bound )
data QueryIfCurrent :: [ Type ] -> Type -> Type where
- QZ :: BlockQuery x result -> QueryIfCurrent (x ': xs) result
- QS :: QueryIfCurrent xs result -> QueryIfCurrent (x ': xs) result
type HardForkQueryResult xs = Either ( MismatchEraInfo xs)
getHardForkQuery :: BlockQuery ( HardForkBlock xs) result -> ( forall result'. (result :~: HardForkQueryResult xs result') -> QueryIfCurrent xs result' -> r) -> ( forall x' xs'. (xs :~: (x' ': xs')) -> ProofNonEmpty xs' -> QueryAnytime result -> EraIndex xs -> r) -> ( forall x' xs'. (xs :~: (x' ': xs')) -> ProofNonEmpty xs' -> QueryHardFork xs result -> r) -> r
encodeQueryAnytimeResult :: QueryAnytime result -> result -> Encoding
decodeQueryAnytimeResult :: QueryAnytime result -> forall s. Decoder s result
encodeQueryHardForkResult :: SListI xs => QueryHardFork xs result -> result -> Encoding
decodeQueryHardForkResult :: SListI xs => QueryHardFork xs result -> forall s. Decoder s result
hardForkQueryInfo :: All SingleEraBlock xs => QueryIfCurrent xs result -> NS SingleEraInfo xs
data HardForkForgeStateInfo xs where
- CurrentEraLacksBlockForging :: EraIndex (x ': (y ': xs)) -> HardForkForgeStateInfo (x ': (y ': xs))
- CurrentEraForgeStateUpdated :: OneEraForgeStateInfo xs -> HardForkForgeStateInfo xs
hardForkBlockForging :: forall m xs. ( CanHardFork xs, Monad m) => Text -> NonEmptyOptNP ( BlockForging m) xs -> BlockForging m ( HardForkBlock xs)

Documentation

type Except e = ExceptT e Identity Source #

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors .

data EpochInfo (m :: Type -> Type ) Source #

Information about epochs

Different epochs may have different sizes and different slot lengths. This information is encapsulated by EpochInfo . It is parameterized over a monad m because the information about how long each epoch is may depend on information derived from the blockchain itself. It ultimately requires acess to state, and so either uses the monad for that or uses the monad to reify failure due to cached state information being too stale for the current query.

Constructors

EpochInfo

Fields

epochInfoSize_ :: HasCallStack => EpochNo -> m EpochSize

Return the size of the given epoch as a number of slots

Note that the number of slots does not bound the number of blocks, since the EBB and a regular block share a slot number.
epochInfoFirst_ :: HasCallStack => EpochNo -> m SlotNo

First slot in the specified epoch

See also epochInfoRange
epochInfoEpoch_ :: HasCallStack => SlotNo -> m EpochNo
Epoch containing the given slot

We should have the property that
```
s `inRange` epochInfoRange (epochInfoEpoch s)
```
epochInfoSlotToRelativeTime_ :: HasCallStack => SlotNo -> m RelativeTime

The RelativeTime of the start of the given slot

This calculation depends on the varying slot lengths of the relevant epochs.

See also epochInfoSlotToUTCTime .
epochInfoSlotLength_ :: HasCallStack => SlotNo -> m SlotLength

Return the length of the specified slot.

Instances

Instances details

Show ( EpochInfo f)	Unhelpful instance, but this type occurs in records (eg `Shelley.Globals` ) that we want to be able to `show`
Instance details Defined in Cardano.Slotting.EpochInfo.API Methods showsPrec :: Int -> EpochInfo f -> ShowS Source # show :: EpochInfo f -> String Source # showList :: [ EpochInfo f] -> ShowS Source #
NoThunks ( EpochInfo m)
Instance details Defined in Cardano.Slotting.EpochInfo.API Methods noThunks :: Context -> EpochInfo m -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> EpochInfo m -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( EpochInfo m) -> String Source #

newtype LedgerEraInfo blk Source #

Additional newtype wrapper around SingleEraInfo

This is primarily useful for use in error messages: it marks which era info came from the ledger, and which came from a tx block header/etc.

Constructors

LedgerEraInfo
Fields getLedgerEraInfo :: SingleEraInfo blk

Instances

Instances details

Eq ( LedgerEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods (==) :: LedgerEraInfo blk -> LedgerEraInfo blk -> Bool Source # (/=) :: LedgerEraInfo blk -> LedgerEraInfo blk -> Bool Source #
Show ( LedgerEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods showsPrec :: Int -> LedgerEraInfo blk -> ShowS Source # show :: LedgerEraInfo blk -> String Source # showList :: [ LedgerEraInfo blk] -> ShowS Source #
NoThunks ( LedgerEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods noThunks :: Context -> LedgerEraInfo blk -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> LedgerEraInfo blk -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( LedgerEraInfo blk) -> String Source #
Serialise ( LedgerEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods encode :: LedgerEraInfo blk -> Encoding Source # decode :: Decoder s ( LedgerEraInfo blk) Source # encodeList :: [ LedgerEraInfo blk] -> Encoding Source # decodeList :: Decoder s [ LedgerEraInfo blk] Source #

data SingleEraInfo blk Source #

Information about an era (mostly for type errors)

Constructors

SingleEraInfo
Fields singleEraName :: ! Text

Instances

Instances details

Eq ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods (==) :: SingleEraInfo blk -> SingleEraInfo blk -> Bool Source # (/=) :: SingleEraInfo blk -> SingleEraInfo blk -> Bool Source #
Show ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods showsPrec :: Int -> SingleEraInfo blk -> ShowS Source # show :: SingleEraInfo blk -> String Source # showList :: [ SingleEraInfo blk] -> ShowS Source #
Generic ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Associated Types type Rep ( SingleEraInfo blk) :: Type -> Type Source # Methods from :: SingleEraInfo blk -> Rep ( SingleEraInfo blk) x Source # to :: Rep ( SingleEraInfo blk) x -> SingleEraInfo blk Source #
NoThunks ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods noThunks :: Context -> SingleEraInfo blk -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> SingleEraInfo blk -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( SingleEraInfo blk) -> String Source #
Serialise ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info Methods encode :: SingleEraInfo blk -> Encoding Source # decode :: Decoder s ( SingleEraInfo blk) Source # encodeList :: [ SingleEraInfo blk] -> Encoding Source # decodeList :: Decoder s [ SingleEraInfo blk] Source #
type Rep ( SingleEraInfo blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Info type Rep ( SingleEraInfo blk) = D1 (' MetaData "SingleEraInfo" "Ouroboros.Consensus.HardFork.Combinator.Info" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "SingleEraInfo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "singleEraName") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 Text )))

data Product2 f g x y Source #

Constructors

Pair2 (f x y) (g x y)

Instances

Instances details

( Eq (f x y), Eq (g x y)) => Eq ( Product2 f g x y) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Functors Methods (==) :: Product2 f g x y -> Product2 f g x y -> Bool Source # (/=) :: Product2 f g x y -> Product2 f g x y -> Bool Source #
( Show (f x y), Show (g x y)) => Show ( Product2 f g x y) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Functors Methods showsPrec :: Int -> Product2 f g x y -> ShowS Source # show :: Product2 f g x y -> String Source # showList :: [ Product2 f g x y] -> ShowS Source #
Generic ( Product2 f g x y) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Functors Associated Types type Rep ( Product2 f g x y) :: Type -> Type Source # Methods from :: Product2 f g x y -> Rep ( Product2 f g x y) x0 Source # to :: Rep ( Product2 f g x y) x0 -> Product2 f g x y Source #
type Rep ( Product2 f g x y) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Functors type Rep ( Product2 f g x y) = D1 (' MetaData "Product2" "Ouroboros.Consensus.HardFork.Combinator.Util.Functors" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "Pair2" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f x y)) :*: S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (g x y))))

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 Source # show :: Ticked () -> String Source # showList :: [ Ticked ()] -> ShowS Source #
Show ( Ticked a) => Show ( Ticked ( K a x)) Source #
Instance details Defined in Ouroboros.Consensus.Ticked Methods showsPrec :: Int -> Ticked ( K a x) -> ShowS Source # show :: Ticked ( K a x) -> String Source # showList :: [ Ticked ( K a x)] -> ShowS Source #
( 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 Source # show :: Ticked ( HardForkLedgerView_ ( K a) xs) -> String Source # showList :: [ Ticked ( HardForkLedgerView_ ( K a) xs)] -> ShowS Source #
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 Source # Methods from :: Ticked ( LedgerState ( HardForkBlock xs)) -> Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x Source # to :: Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x -> Ticked ( LedgerState ( HardForkBlock xs)) Source #
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 ( 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 #
IsLedger l => GetTip ( Ticked ( LedgerDB l)) Source #
Instance details Defined in Ouroboros.Consensus.Storage.LedgerDB.InMemory Methods getTip :: Ticked ( LedgerDB l) -> Point ( Ticked ( LedgerDB l)) Source #
Isomorphic ( Ticked :.: LedgerState ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.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 Source # show :: ( Ticked :.: f) a -> String Source # showList :: [( Ticked :.: f) a] -> ShowS Source #
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.1-DT4Cvwf63DZKctsEvaJqCU" ' 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)) }
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 ( 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) }
data Ticked ( LedgerDB l) 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) = TickedLedgerDB { tickedLedgerDbTicked :: Ticked l tickedLedgerDbOrig :: LedgerDB l }
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 ( Except PastHorizonException ) }
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 }
newtype Ticked ( PBftLedgerView c) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT newtype Ticked ( PBftLedgerView c) = TickedPBftLedgerView { tickedPBftDelegates :: Bimap ( PBftVerKeyHash c) ( PBftVerKeyHash c) }
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 }

data family NestedCtxt_ blk :: ( Type -> Type ) -> Type -> Type Source #

Context identifying what kind of block we have

In almost all places we will use NestedCtxt rather than NestedCtxt_ .

Instances

Instances details

SameDepIndex ( NestedCtxt_ m f) => SameDepIndex ( NestedCtxt_ ( DualBlock m a) f) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods sameDepIndex :: NestedCtxt_ ( DualBlock m a) f a0 -> NestedCtxt_ ( DualBlock m a) f b -> Maybe (a0 :~: b) Source #
CanHardFork xs => SameDepIndex ( NestedCtxt_ ( HardForkBlock xs) Header ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods sameDepIndex :: NestedCtxt_ ( HardForkBlock xs) Header a -> NestedCtxt_ ( HardForkBlock xs) Header b -> Maybe (a :~: b) Source #
Show ( NestedCtxt_ m f x) => Show ( NestedCtxt_ ( DualBlock m a) f x) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> NestedCtxt_ ( DualBlock m a) f x -> ShowS Source # show :: NestedCtxt_ ( DualBlock m a) f x -> String Source # showList :: [ NestedCtxt_ ( DualBlock m a) f x] -> ShowS Source #
All SingleEraBlock xs => Show ( NestedCtxt_ ( HardForkBlock xs) Header a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods showsPrec :: Int -> NestedCtxt_ ( HardForkBlock xs) Header a -> ShowS Source # show :: NestedCtxt_ ( HardForkBlock xs) Header a -> String Source # showList :: [ NestedCtxt_ ( HardForkBlock xs) Header a] -> ShowS Source #
data NestedCtxt_ ( HardForkBlock xs) a b Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block data NestedCtxt_ ( HardForkBlock xs) a b where NCZ :: forall x (f :: Type -> Type ) a (xs :: [ Type ]). !( NestedCtxt_ x f a) -> NestedCtxt_ ( HardForkBlock (x ': xs)) f a NCS :: forall (xs :: [ Type ]) (f :: Type -> Type ) a x. !( NestedCtxt_ ( HardForkBlock xs) f a) -> NestedCtxt_ ( HardForkBlock (x ': xs)) f a
newtype NestedCtxt_ ( DualBlock m a) f x Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual newtype NestedCtxt_ ( DualBlock m a) f x where CtxtDual :: forall m (f :: Type -> Type ) x a. NestedCtxt_ m f x -> NestedCtxt_ ( DualBlock m a) f x

data family Header blk :: Type Source #

Instances

data family StorageConfig blk :: Type Source #

Config needed for the NodeInitStorage class. Defined here to avoid circular dependencies.

Instances

Instances details

Isomorphic StorageConfig Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => StorageConfig ( HardForkBlock '[blk]) -> StorageConfig blk Source # inject :: NoHardForks blk => StorageConfig blk -> StorageConfig ( HardForkBlock '[blk]) Source #
Generic ( StorageConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Associated Types type Rep ( StorageConfig ( DualBlock m a)) :: Type -> Type Source # Methods from :: StorageConfig ( DualBlock m a) -> Rep ( StorageConfig ( DualBlock m a)) x Source # to :: Rep ( StorageConfig ( DualBlock m a)) x -> StorageConfig ( DualBlock m a) Source #
( NoThunks ( StorageConfig m), NoThunks ( StorageConfig a)) => NoThunks ( StorageConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> StorageConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> StorageConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( StorageConfig ( DualBlock m a)) -> String Source #
CanHardFork xs => NoThunks ( StorageConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> StorageConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> StorageConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( StorageConfig ( HardForkBlock xs)) -> String Source #
type Rep ( StorageConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual type Rep ( StorageConfig ( DualBlock m a)) = D1 (' MetaData "StorageConfig" "Ouroboros.Consensus.Ledger.Dual" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "DualStorageConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "dualStorageConfigMain") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( StorageConfig m)) :*: S1 (' MetaSel (' Just "dualStorageConfigAux") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( StorageConfig a))))
newtype StorageConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype StorageConfig ( HardForkBlock xs) = HardForkStorageConfig { hardForkStorageConfigPerEra :: PerEraStorageConfig xs }
data StorageConfig ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data StorageConfig ( DualBlock m a) = DualStorageConfig { dualStorageConfigMain :: !( StorageConfig m) dualStorageConfigAux :: !( StorageConfig a) }

data family CodecConfig blk :: Type Source #

Static configuration required for serialisation and deserialisation of types pertaining to this type of block.

Data family instead of type family to get better type inference.

Instances

Instances details

Isomorphic CodecConfig Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => CodecConfig ( HardForkBlock '[blk]) -> CodecConfig blk Source # inject :: NoHardForks blk => CodecConfig blk -> CodecConfig ( HardForkBlock '[blk]) Source #
Generic ( CodecConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Associated Types type Rep ( CodecConfig ( DualBlock m a)) :: Type -> Type Source # Methods from :: CodecConfig ( DualBlock m a) -> Rep ( CodecConfig ( DualBlock m a)) x Source # to :: Rep ( CodecConfig ( DualBlock m a)) x -> CodecConfig ( DualBlock m a) Source #
( NoThunks ( CodecConfig m), NoThunks ( CodecConfig a)) => NoThunks ( CodecConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> CodecConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> CodecConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( CodecConfig ( DualBlock m a)) -> String Source #
CanHardFork xs => NoThunks ( CodecConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> CodecConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> CodecConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( CodecConfig ( HardForkBlock xs)) -> String Source #
type Rep ( CodecConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual type Rep ( CodecConfig ( DualBlock m a)) = D1 (' MetaData "CodecConfig" "Ouroboros.Consensus.Ledger.Dual" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "DualCodecConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "dualCodecConfigMain") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( CodecConfig m)) :*: S1 (' MetaSel (' Just "dualCodecConfigAux") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( CodecConfig a))))
newtype CodecConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype CodecConfig ( HardForkBlock xs) = HardForkCodecConfig { hardForkCodecConfigPerEra :: PerEraCodecConfig xs }
data CodecConfig ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data CodecConfig ( DualBlock m a) = DualCodecConfig { dualCodecConfigMain :: !( CodecConfig m) dualCodecConfigAux :: !( CodecConfig a) }

data family BlockConfig blk :: Type Source #

Static configuration required to work with this type of blocks

Instances

Instances details

Isomorphic BlockConfig Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => BlockConfig ( HardForkBlock '[blk]) -> BlockConfig blk Source # inject :: NoHardForks blk => BlockConfig blk -> BlockConfig ( HardForkBlock '[blk]) Source #
NoThunks ( BlockConfig ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> BlockConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> BlockConfig ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( BlockConfig ( DualBlock m a)) -> String Source #
CanHardFork xs => NoThunks ( BlockConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> BlockConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> BlockConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( BlockConfig ( HardForkBlock xs)) -> String Source #
newtype BlockConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype BlockConfig ( HardForkBlock xs) = HardForkBlockConfig { hardForkBlockConfigPerEra :: PerEraBlockConfig xs }
data BlockConfig ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data BlockConfig ( DualBlock m a) = DualBlockConfig { dualBlockConfigMain :: BlockConfig m dualBlockConfigAux :: BlockConfig a }

data family ConsensusConfig p :: Type Source #

Static configuration required to run the consensus protocol

Every method in the ConsensusProtocol class takes the consensus configuration as a parameter, so having this as a data family rather than a type family resolves most ambiguity.

Defined out of the class so that protocols can define this type without having to define the entire protocol at the same time (or indeed in the same module).

Instances

Instances details

Generic ( ConsensusConfig ( ModChainSel p s)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.ModChainSel Associated Types type Rep ( ConsensusConfig ( ModChainSel p s)) :: Type -> Type Source # Methods from :: ConsensusConfig ( ModChainSel p s) -> Rep ( ConsensusConfig ( ModChainSel p s)) x Source # to :: Rep ( ConsensusConfig ( ModChainSel p s)) x -> ConsensusConfig ( ModChainSel p s) Source #
Generic ( ConsensusConfig ( Bft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.BFT Associated Types type Rep ( ConsensusConfig ( Bft c)) :: Type -> Type Source # Methods from :: ConsensusConfig ( Bft c) -> Rep ( ConsensusConfig ( Bft c)) x Source # to :: Rep ( ConsensusConfig ( Bft c)) x -> ConsensusConfig ( Bft c) Source #
Generic ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Associated Types type Rep ( ConsensusConfig ( HardForkProtocol xs)) :: Type -> Type Source # Methods from :: ConsensusConfig ( HardForkProtocol xs) -> Rep ( ConsensusConfig ( HardForkProtocol xs)) x Source # to :: Rep ( ConsensusConfig ( HardForkProtocol xs)) x -> ConsensusConfig ( HardForkProtocol xs) Source #
Generic ( ConsensusConfig ( PBft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT Associated Types type Rep ( ConsensusConfig ( PBft c)) :: Type -> Type Source # Methods from :: ConsensusConfig ( PBft c) -> Rep ( ConsensusConfig ( PBft c)) x Source # to :: Rep ( ConsensusConfig ( PBft c)) x -> ConsensusConfig ( PBft c) Source #
ConsensusProtocol p => NoThunks ( ConsensusConfig ( ModChainSel p s)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.ModChainSel Methods noThunks :: Context -> ConsensusConfig ( ModChainSel p s) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConsensusConfig ( ModChainSel p s) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConsensusConfig ( ModChainSel p s)) -> String Source #
BftCrypto c => NoThunks ( ConsensusConfig ( Bft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.BFT Methods noThunks :: Context -> ConsensusConfig ( Bft c) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConsensusConfig ( Bft c) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConsensusConfig ( Bft c)) -> String Source #
CanHardFork xs => NoThunks ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> ConsensusConfig ( HardForkProtocol xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConsensusConfig ( HardForkProtocol xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConsensusConfig ( HardForkProtocol xs)) -> String Source #
NoThunks ( ConsensusConfig ( PBft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT Methods noThunks :: Context -> ConsensusConfig ( PBft c) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConsensusConfig ( PBft c) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConsensusConfig ( PBft c)) -> String Source #
type Rep ( ConsensusConfig ( ModChainSel p s)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.ModChainSel type Rep ( ConsensusConfig ( ModChainSel p s)) = D1 (' MetaData "ConsensusConfig" "Ouroboros.Consensus.Protocol.ModChainSel" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "McsConsensusConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "mcsConfigP") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( ConsensusConfig p))))
type Rep ( ConsensusConfig ( Bft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.BFT type Rep ( ConsensusConfig ( Bft c)) = D1 (' MetaData "ConsensusConfig" "Ouroboros.Consensus.Protocol.BFT" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "BftConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "bftParams") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 BftParams ) :: ( S1 (' MetaSel (' Just "bftSignKey") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( SignKeyDSIGN ( BftDSIGN c))) :: S1 (' MetaSel (' Just "bftVerKeys") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Map NodeId ( VerKeyDSIGN ( BftDSIGN c)))))))
type Rep ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type Rep ( ConsensusConfig ( HardForkProtocol xs)) = D1 (' MetaData "ConsensusConfig" "Ouroboros.Consensus.HardFork.Combinator.Basics" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkConsensusConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "hardForkConsensusConfigK") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 SecurityParam ) :: ( S1 (' MetaSel (' Just "hardForkConsensusConfigShape") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Shape xs)) :: S1 (' MetaSel (' Just "hardForkConsensusConfigPerEra") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( PerEraConsensusConfig xs)))))
type Rep ( ConsensusConfig ( PBft c)) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT type Rep ( ConsensusConfig ( PBft c)) = D1 (' MetaData "ConsensusConfig" "Ouroboros.Consensus.Protocol.PBFT" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "PBftConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "pbftParams") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 PBftParams )))
data ConsensusConfig ( Bft c) Source #	(Static) node configuration
Instance details Defined in Ouroboros.Consensus.Protocol.BFT data ConsensusConfig ( Bft c) = BftConfig { bftParams :: ! BftParams bftSignKey :: !( SignKeyDSIGN ( BftDSIGN c)) bftVerKeys :: !( Map NodeId ( VerKeyDSIGN ( BftDSIGN c))) }
data ConsensusConfig ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics data ConsensusConfig ( HardForkProtocol xs) = HardForkConsensusConfig { hardForkConsensusConfigK :: ! SecurityParam hardForkConsensusConfigShape :: !( Shape xs) hardForkConsensusConfigPerEra :: !( PerEraConsensusConfig xs) }
newtype ConsensusConfig ( PBft c) Source #	(Static) node configuration
Instance details Defined in Ouroboros.Consensus.Protocol.PBFT newtype ConsensusConfig ( PBft c) = PBftConfig { pbftParams :: PBftParams }
newtype ConsensusConfig ( ModChainSel p s) Source #
Instance details Defined in Ouroboros.Consensus.Protocol.ModChainSel newtype ConsensusConfig ( ModChainSel p s) = McsConsensusConfig { mcsConfigP :: ConsensusConfig p }

data family LedgerState blk :: Type Source #

Ledger state associated with a block

Instances

Instances details

Isomorphic LedgerState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => LedgerState ( HardForkBlock '[blk]) -> LedgerState blk Source # inject :: NoHardForks blk => LedgerState blk -> LedgerState ( HardForkBlock '[blk]) Source #
Inject LedgerState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Nary Methods inject :: forall x (xs :: [ Type ]). CanHardFork xs => Exactly xs Bound -> Index xs x -> LedgerState x -> LedgerState ( HardForkBlock xs) Source #
( Eq ( LedgerState m), Eq ( LedgerState a), Bridge m a) => Eq ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods (==) :: LedgerState ( DualBlock m a) -> LedgerState ( DualBlock m a) -> Bool Source # (/=) :: LedgerState ( DualBlock m a) -> LedgerState ( DualBlock m a) -> Bool Source #
CanHardFork xs => Eq ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods (==) :: LedgerState ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Bool Source # (/=) :: LedgerState ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Bool Source #
( Show ( LedgerState m), Show ( LedgerState a), Bridge m a) => Show ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> LedgerState ( DualBlock m a) -> ShowS Source # show :: LedgerState ( DualBlock m a) -> String Source # showList :: [ LedgerState ( DualBlock m a)] -> ShowS Source #
CanHardFork xs => Show ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods showsPrec :: Int -> LedgerState ( HardForkBlock xs) -> ShowS Source # show :: LedgerState ( HardForkBlock xs) -> String Source # showList :: [ LedgerState ( HardForkBlock xs)] -> ShowS Source #
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 Source # Methods from :: Ticked ( LedgerState ( HardForkBlock xs)) -> Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x Source # to :: Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x -> Ticked ( LedgerState ( HardForkBlock xs)) Source #
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 #
NoThunks ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> LedgerState ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> LedgerState ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( LedgerState ( DualBlock m a)) -> String Source #
CanHardFork xs => NoThunks ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> LedgerState ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> LedgerState ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( LedgerState ( HardForkBlock xs)) -> String Source #
Bridge m a => IsLedger ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Associated Types type LedgerErr ( LedgerState ( DualBlock m a)) Source # type AuxLedgerEvent ( LedgerState ( DualBlock m a)) Source # Methods applyChainTickLedgerResult :: LedgerCfg ( LedgerState ( DualBlock m a)) -> SlotNo -> LedgerState ( DualBlock m a) -> LedgerResult ( LedgerState ( DualBlock m a)) ( Ticked ( LedgerState ( DualBlock m a))) Source #
CanHardFork xs => IsLedger ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type LedgerErr ( LedgerState ( HardForkBlock xs)) Source # type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) Source # Methods applyChainTickLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> SlotNo -> LedgerState ( HardForkBlock xs) -> LedgerResult ( LedgerState ( HardForkBlock xs)) ( Ticked ( LedgerState ( HardForkBlock xs))) 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 #
Bridge m a => GetTip ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods getTip :: LedgerState ( DualBlock m a) -> Point ( LedgerState ( DualBlock m a)) Source #
CanHardFork xs => GetTip ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods getTip :: LedgerState ( HardForkBlock xs) -> Point ( LedgerState ( HardForkBlock xs)) Source #
CanHardFork xs => ApplyBlock ( LedgerState ( HardForkBlock xs)) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods applyBlockLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> HardForkBlock xs -> Ticked ( LedgerState ( HardForkBlock xs)) -> Except ( LedgerErr ( LedgerState ( HardForkBlock xs))) ( LedgerResult ( LedgerState ( HardForkBlock xs)) ( LedgerState ( HardForkBlock xs))) Source # reapplyBlockLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> HardForkBlock xs -> Ticked ( LedgerState ( HardForkBlock xs)) -> LedgerResult ( LedgerState ( HardForkBlock xs)) ( LedgerState ( HardForkBlock xs)) Source #
SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( LedgerState ( HardForkBlock xs)) Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Encoding Source #
Bridge m a => ApplyBlock ( LedgerState ( DualBlock m a)) ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods applyBlockLedgerResult :: LedgerCfg ( LedgerState ( DualBlock m a)) -> DualBlock m a -> Ticked ( LedgerState ( DualBlock m a)) -> Except ( LedgerErr ( LedgerState ( DualBlock m a))) ( LedgerResult ( LedgerState ( DualBlock m a)) ( LedgerState ( DualBlock m a))) Source # reapplyBlockLedgerResult :: LedgerCfg ( LedgerState ( DualBlock m a)) -> DualBlock m a -> Ticked ( LedgerState ( DualBlock m a)) -> LedgerResult ( LedgerState ( DualBlock m a)) ( LedgerState ( DualBlock m a)) Source #
Isomorphic ( Ticked :.: LedgerState ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => ( Ticked :.: LedgerState ) ( HardForkBlock '[blk]) -> ( Ticked :.: LedgerState ) blk Source # inject :: NoHardForks blk => ( Ticked :.: LedgerState ) blk -> ( Ticked :.: LedgerState ) ( HardForkBlock '[blk]) Source #
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.1-DT4Cvwf63DZKctsEvaJqCU" ' 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 ( LedgerState blk) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Basics type HeaderHash ( LedgerState blk) = HeaderHash blk
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) }
newtype LedgerState ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype LedgerState ( HardForkBlock xs) = HardForkLedgerState { hardForkLedgerStatePerEra :: HardForkState LedgerState xs }
type LedgerErr ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual type LedgerErr ( LedgerState ( DualBlock m a)) = DualLedgerError m a
type LedgerErr ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type LedgerErr ( LedgerState ( HardForkBlock xs)) = HardForkLedgerError xs
type AuxLedgerEvent ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual type AuxLedgerEvent ( LedgerState ( DualBlock m a)) = AuxLedgerEvent ( LedgerState m)
type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) = OneEraLedgerEvent xs
type LedgerCfg ( LedgerState ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual type LedgerCfg ( LedgerState ( DualBlock m a)) = DualLedgerConfig m a
type LedgerCfg ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type LedgerCfg ( LedgerState ( HardForkBlock xs)) = HardForkLedgerConfig xs
data LedgerState ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data LedgerState ( DualBlock m a) = DualLedgerState { dualLedgerStateMain :: LedgerState m dualLedgerStateAux :: LedgerState a dualLedgerStateBridge :: BridgeLedger m a }

data family Validated x :: Type Source #

" Validated " transaction or block

The ledger defines how to validate transactions and blocks. It's possible the type before and after validation may be distinct (eg Alonzo transactions), which originally motivated this family.

We also gain the related benefit that certain interface functions, such as those that reapply blocks, can have a more precise type now. TODO

Similarly, the Node-to-Client mini protocols can explicitly indicate that the client trusts the blocks from the local server, by having the server send Validated blocks to the client. TODO

Note that validation has different implications for a transaction than for a block. In particular, a validated transaction can be " reapplied " to different ledger states, whereas a validated block must only be " reapplied " to the exact same ledger state (eg as part of rebuilding from an on-disk ledger snapshot).

Since the ledger defines validation, see the ledger details for concrete examples of what determines the validity (wrt to a LedgerState ) of a transaction and/or block. Example properties include: a transaction's claimed inputs exist and are still unspent, a block carries a sufficient cryptographic signature, etc.

Instances

Instances details

CanHardFork xs => Eq ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source #
Bridge m a => Show ( Validated ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> Validated ( GenTx ( DualBlock m a)) -> ShowS Source # show :: Validated ( GenTx ( DualBlock m a)) -> String Source # showList :: [ Validated ( GenTx ( DualBlock m a))] -> ShowS Source #
CanHardFork xs => Show ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> Validated ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: Validated ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ Validated ( GenTx ( HardForkBlock xs))] -> ShowS Source #
Generic ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( Validated ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: Validated ( GenTx ( HardForkBlock xs)) -> Rep ( Validated ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( Validated ( GenTx ( HardForkBlock xs))) x -> Validated ( GenTx ( HardForkBlock xs)) Source #
NoThunks ( Validated ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> Validated ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Validated ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Validated ( GenTx ( DualBlock m a))) -> String Source #
CanHardFork xs => NoThunks ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Validated ( GenTx ( HardForkBlock xs))) -> String Source #
type Rep ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( Validated ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "Validated" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkValidatedGenTx" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkValidatedGenTx") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraValidatedGenTx xs))))
data Validated ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data Validated ( GenTx ( DualBlock m a)) = ValidatedDualGenTx { vDualGenTxMain :: Validated ( GenTx m) vDualGenTxAux :: Validated ( GenTx a) vDualGenTxBridge :: BridgeTx m a }
newtype Validated ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype Validated ( GenTx ( HardForkBlock xs)) = HardForkValidatedGenTx { getHardForkValidatedGenTx :: OneEraValidatedGenTx xs }

data family TxId tx :: Type Source #

A generalized transaction, GenTx , identifier.

Instances

Instances details

( Typeable m, Typeable a) => ShowProxy ( TxId ( GenTx ( DualBlock m a)) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showProxy :: Proxy ( TxId ( GenTx ( DualBlock m a))) -> String Source #
Typeable xs => ShowProxy ( TxId ( GenTx ( HardForkBlock xs)) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
Eq ( GenTxId m) => Eq ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods (==) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (/=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source #
CanHardFork xs => Eq ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source #
Ord ( GenTxId m) => Ord ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods compare :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Ordering Source # (<) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (<=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (>) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (>=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # max :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) Source # min :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) Source #
CanHardFork xs => Ord ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods compare :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Ordering Source # (<) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (<=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # max :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source # min :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source #
Show ( GenTxId m) => Show ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> TxId ( GenTx ( DualBlock m a)) -> ShowS Source # show :: TxId ( GenTx ( DualBlock m a)) -> String Source # showList :: [ TxId ( GenTx ( DualBlock m a))] -> ShowS Source #
CanHardFork xs => Show ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> TxId ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: TxId ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ TxId ( GenTx ( HardForkBlock xs))] -> ShowS Source #
Generic ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( TxId ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: TxId ( GenTx ( HardForkBlock xs)) -> Rep ( TxId ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( TxId ( GenTx ( HardForkBlock xs))) x -> TxId ( GenTx ( HardForkBlock xs)) Source #
NoThunks ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> TxId ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> TxId ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( TxId ( GenTx ( DualBlock m a))) -> String Source #
CanHardFork xs => NoThunks ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
All CondenseConstraints xs => Condense ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: TxId ( GenTx ( HardForkBlock xs)) -> String Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
type Rep ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( TxId ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "TxId" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkGenTxId" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkGenTxId") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraGenTxId xs))))
newtype TxId ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual newtype TxId ( GenTx ( DualBlock m a)) = DualGenTxId { dualGenTxIdMain :: GenTxId m }
newtype TxId ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype TxId ( GenTx ( HardForkBlock xs)) = HardForkGenTxId { getHardForkGenTxId :: OneEraGenTxId xs }

data family GenTx blk :: Type Source #

Generalized transaction

The mempool (and, accordingly, blocks) consist of "generalized transactions"; this could be "proper" transactions (transferring funds) but also other kinds of things such as update proposals, delegations, etc.

Instances

Instances details

Isomorphic GenTx Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Unary Methods project :: NoHardForks blk => GenTx ( HardForkBlock '[blk]) -> GenTx blk Source # inject :: NoHardForks blk => GenTx blk -> GenTx ( HardForkBlock '[blk]) Source #
Inject GenTx Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Nary Methods inject :: forall x (xs :: [ Type ]). CanHardFork xs => Exactly xs Bound -> Index xs x -> GenTx x -> GenTx ( HardForkBlock xs) Source #
( Typeable m, Typeable a) => ShowProxy ( TxId ( GenTx ( DualBlock m a)) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showProxy :: Proxy ( TxId ( GenTx ( DualBlock m a))) -> String Source #
Typeable xs => ShowProxy ( TxId ( GenTx ( HardForkBlock xs)) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
( Typeable m, Typeable a) => ShowProxy ( GenTx ( DualBlock m a) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showProxy :: Proxy ( GenTx ( DualBlock m a)) -> String Source #
Typeable xs => ShowProxy ( GenTx ( HardForkBlock xs) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( GenTx ( HardForkBlock xs)) -> String Source #
CanHardFork xs => Eq ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source #
Eq ( GenTxId m) => Eq ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods (==) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (/=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source #
CanHardFork xs => Eq ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source #
CanHardFork xs => Eq ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: GenTx ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Bool Source # (/=) :: GenTx ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Bool Source #
Ord ( GenTxId m) => Ord ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods compare :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Ordering Source # (<) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (<=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (>) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # (>=) :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> Bool Source # max :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) Source # min :: TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) -> TxId ( GenTx ( DualBlock m a)) Source #
CanHardFork xs => Ord ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods compare :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Ordering Source # (<) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (<=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # max :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source # min :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source #
Bridge m a => Show ( Validated ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> Validated ( GenTx ( DualBlock m a)) -> ShowS Source # show :: Validated ( GenTx ( DualBlock m a)) -> String Source # showList :: [ Validated ( GenTx ( DualBlock m a))] -> ShowS Source #
CanHardFork xs => Show ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> Validated ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: Validated ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ Validated ( GenTx ( HardForkBlock xs))] -> ShowS Source #
Show ( GenTxId m) => Show ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> TxId ( GenTx ( DualBlock m a)) -> ShowS Source # show :: TxId ( GenTx ( DualBlock m a)) -> String Source # showList :: [ TxId ( GenTx ( DualBlock m a))] -> ShowS Source #
CanHardFork xs => Show ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> TxId ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: TxId ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ TxId ( GenTx ( HardForkBlock xs))] -> ShowS Source #
Bridge m a => Show ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> GenTx ( DualBlock m a) -> ShowS Source # show :: GenTx ( DualBlock m a) -> String Source # showList :: [ GenTx ( DualBlock m a)] -> ShowS Source #
CanHardFork xs => Show ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> GenTx ( HardForkBlock xs) -> ShowS Source # show :: GenTx ( HardForkBlock xs) -> String Source # showList :: [ GenTx ( HardForkBlock xs)] -> ShowS Source #
Generic ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( Validated ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: Validated ( GenTx ( HardForkBlock xs)) -> Rep ( Validated ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( Validated ( GenTx ( HardForkBlock xs))) x -> Validated ( GenTx ( HardForkBlock xs)) Source #
Generic ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( TxId ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: TxId ( GenTx ( HardForkBlock xs)) -> Rep ( TxId ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( TxId ( GenTx ( HardForkBlock xs))) x -> TxId ( GenTx ( HardForkBlock xs)) Source #
Generic ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( GenTx ( HardForkBlock xs)) :: Type -> Type Source # Methods from :: GenTx ( HardForkBlock xs) -> Rep ( GenTx ( HardForkBlock xs)) x Source # to :: Rep ( GenTx ( HardForkBlock xs)) x -> GenTx ( HardForkBlock xs) Source #
NoThunks ( Validated ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> Validated ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Validated ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Validated ( GenTx ( DualBlock m a))) -> String Source #
CanHardFork xs => NoThunks ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Validated ( GenTx ( HardForkBlock xs))) -> String Source #
NoThunks ( TxId ( GenTx ( DualBlock m a))) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> TxId ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> TxId ( GenTx ( DualBlock m a)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( TxId ( GenTx ( DualBlock m a))) -> String Source #
CanHardFork xs => NoThunks ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
NoThunks ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods noThunks :: Context -> GenTx ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> GenTx ( DualBlock m a) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( GenTx ( DualBlock m a)) -> String Source #
CanHardFork xs => NoThunks ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> GenTx ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> GenTx ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( GenTx ( HardForkBlock xs)) -> String Source #
All CondenseConstraints xs => Condense ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: TxId ( GenTx ( HardForkBlock xs)) -> String Source #
All CondenseConstraints xs => Condense ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: GenTx ( HardForkBlock xs) -> String Source #
Bridge m a => HasTxId ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods txId :: GenTx ( DualBlock m a) -> TxId ( GenTx ( DualBlock m a)) Source #
CanHardFork xs => HasTxId ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods txId :: GenTx ( HardForkBlock xs) -> TxId ( GenTx ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTx ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTx ( HardForkBlock xs)) Source #
type Rep ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( Validated ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "Validated" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkValidatedGenTx" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkValidatedGenTx") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraValidatedGenTx xs))))
type Rep ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( TxId ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "TxId" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkGenTxId" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkGenTxId") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraGenTxId xs))))
type Rep ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( GenTx ( HardForkBlock xs)) = D1 (' MetaData "GenTx" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkGenTx" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkGenTx") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraGenTx xs))))
data Validated ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data Validated ( GenTx ( DualBlock m a)) = ValidatedDualGenTx { vDualGenTxMain :: Validated ( GenTx m) vDualGenTxAux :: Validated ( GenTx a) vDualGenTxBridge :: BridgeTx m a }
newtype Validated ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype Validated ( GenTx ( HardForkBlock xs)) = HardForkValidatedGenTx { getHardForkValidatedGenTx :: OneEraValidatedGenTx xs }
newtype TxId ( GenTx ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual newtype TxId ( GenTx ( DualBlock m a)) = DualGenTxId { dualGenTxIdMain :: GenTxId m }
newtype TxId ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype TxId ( GenTx ( HardForkBlock xs)) = HardForkGenTxId { getHardForkGenTxId :: OneEraGenTxId xs }
newtype GenTx ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype GenTx ( HardForkBlock xs) = HardForkGenTx { getHardForkGenTx :: OneEraGenTx xs }
data GenTx ( DualBlock m a) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data GenTx ( DualBlock m a) = DualGenTx { dualGenTxMain :: GenTx m dualGenTxAux :: GenTx a dualGenTxBridge :: BridgeTx m a }

class IsNonEmpty xs where Source #

Methods

isNonEmpty :: proxy xs -> ProofNonEmpty xs Source #

Instances

Instances details

IsNonEmpty (x ': xs :: [a]) Source #
Instance details Defined in Ouroboros.Consensus.Util.SOP Methods isNonEmpty :: proxy (x ': xs) -> ProofNonEmpty (x ': xs) Source #

data ProofNonEmpty :: [a] -> Type where Source #

Constructors

ProofNonEmpty :: Proxy x -> Proxy xs -> ProofNonEmpty (x ': xs)

data PastHorizonException Source #

We tried to convert something that is past the horizon

That is, we tried to convert something that is past the point in time beyond which we lack information due to uncertainty about the next hard fork.

Instances

Instances details

Show PastHorizonException Source #
Instance details Defined in Ouroboros.Consensus.HardFork.History.Qry Methods showsPrec :: Int -> PastHorizonException -> ShowS Source # show :: PastHorizonException -> String Source # showList :: [ PastHorizonException ] -> ShowS Source #
Exception PastHorizonException Source #
Instance details Defined in Ouroboros.Consensus.HardFork.History.Qry Methods toException :: PastHorizonException -> SomeException Source # fromException :: SomeException -> Maybe PastHorizonException Source # displayException :: PastHorizonException -> String Source #

newtype WrapPartialConsensusConfig blk Source #

Constructors

WrapPartialConsensusConfig
Fields unwrapPartialConsensusConfig :: PartialConsensusConfig ( BlockProtocol blk)

Instances

Instances details

NoThunks ( PartialConsensusConfig ( BlockProtocol blk)) => NoThunks ( WrapPartialConsensusConfig blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.PartialConfig Methods noThunks :: Context -> WrapPartialConsensusConfig blk -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> WrapPartialConsensusConfig blk -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( WrapPartialConsensusConfig blk) -> String Source #

newtype WrapPartialLedgerConfig blk Source #

Constructors

WrapPartialLedgerConfig
Fields unwrapPartialLedgerConfig :: PartialLedgerConfig blk

Instances

Instances details

NoThunks ( PartialLedgerConfig blk) => NoThunks ( WrapPartialLedgerConfig blk) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.PartialConfig Methods noThunks :: Context -> WrapPartialLedgerConfig blk -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> WrapPartialLedgerConfig blk -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( WrapPartialLedgerConfig blk) -> String Source #

class ( UpdateLedger blk, NoThunks ( PartialLedgerConfig blk)) => HasPartialLedgerConfig blk where Source #

Partial ledger config

Minimal complete definition

Nothing

Associated Types

type PartialLedgerConfig blk :: Type Source #

type PartialLedgerConfig blk = LedgerConfig blk

Methods

completeLedgerConfig :: proxy blk -> EpochInfo ( Except PastHorizonException ) -> PartialLedgerConfig blk -> LedgerConfig blk Source #

Construct LedgerConfig from PartialLedgerCfg

NOTE: The EpochInfo provided will have limited range, any attempt to look past its horizon will result in a pure PastHorizonException . The horizon is determined by the tip of the ledger state (not view) from which the EpochInfo is derived.

default completeLedgerConfig :: PartialLedgerConfig blk ~ LedgerConfig blk => proxy blk -> EpochInfo ( Except PastHorizonException ) -> PartialLedgerConfig blk -> LedgerConfig blk Source #

class ( ConsensusProtocol p, NoThunks ( PartialConsensusConfig p)) => HasPartialConsensusConfig p where Source #

Partial consensus config

Minimal complete definition

Nothing

Associated Types

type PartialConsensusConfig p :: Type Source #

type PartialConsensusConfig p = ConsensusConfig p

Methods

completeConsensusConfig :: proxy p -> EpochInfo ( Except PastHorizonException ) -> PartialConsensusConfig p -> ConsensusConfig p Source #

Construct ConsensusConfig from PartialConsensusConfig

See comments for completeLedgerConfig for some details about the EpochInfo .

default completeConsensusConfig :: PartialConsensusConfig p ~ ConsensusConfig p => proxy p -> EpochInfo ( Except PastHorizonException ) -> PartialConsensusConfig p -> ConsensusConfig p Source #

toPartialConsensusConfig :: proxy p -> ConsensusConfig p -> PartialConsensusConfig p Source #

Construct partial consensus config from full consensus config

NOTE: This is basically just losing EpochInfo , but that is constant anyway when we are dealing with a single era.

default toPartialConsensusConfig :: PartialConsensusConfig p ~ ConsensusConfig p => proxy p -> ConsensusConfig p -> PartialConsensusConfig p Source #

data InPairs (f :: k -> k -> Type ) (xs :: [k]) where Source #

We have an f x y for each pair (x, y) of successive list elements

Constructors

PNil :: InPairs f '[x]
PCons :: f x y -> InPairs f (y ': zs) -> InPairs f (x ': (y ': zs))

data Telescope (g :: k -> Type ) (f :: k -> Type ) (xs :: [k]) where Source #

Telescope

A telescope is an extension of an NS , where every time we "go right" in the sum we have an additional value.

Blockchain intuition: think of g as representing some kind of past state, and f some kind of current state. Then depending on how many hard fork transitions we have had, we might either have, say

TZ currentByronState
TS pastByronState $ TZ currentShelleyState
TS pastByronState $ TS pastShelleyState $ TZ currentGoguenState

The Telescope API mostly follows sop-core conventions, supporting functor ( hmap , hcmap ), applicative ( hap , hpure ), foldable ( hcollapse ) and traversable ( hsequence' ). However, since Telescope is a bi-functor, it cannot reuse the sop-core classes. The naming scheme of the functions is adopted from sop-core though; for example:

bi h (c) zipWith
|  |  |    |
|  |  |    \ zipWith: the name from base
|  |  |
|  |  \ constrained: version of the function with a constraint parameter
|  |
|  \ higher order: 'Telescope' (like 'NS'/'NP') is a /higher order/ functor
|
\ bifunctor: 'Telescope' (unlike 'NS'/'NP') is a higher order /bifunctor/

In addition to the standard SOP operators, the new operators that make a Telescope a telescope are extend , retract and align ; see their documentation for details.

Constructors

TZ :: !(f x) -> Telescope g f (x ': xs)
TS :: !(g x) -> !( Telescope g f xs) -> Telescope g f (x ': xs)

Instances

Instances details

HAp ( Telescope g :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods hap :: forall (f :: k0 -> Type ) (g0 :: k0 -> Type ) (xs :: l). Prod ( Telescope g) (f -.-> g0) xs -> Telescope g f xs -> Telescope g g0 xs Source #
HTraverse_ ( Telescope g :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods hctraverse_ :: forall c (xs :: l) g0 proxy f. ( AllN ( Telescope g) c xs, Applicative g0) => proxy c -> ( forall (a :: k0). c a => f a -> g0 ()) -> Telescope g f xs -> g0 () Source # htraverse_ :: forall (xs :: l) g0 f. ( SListIN ( Telescope g) xs, Applicative g0) => ( forall (a :: k0). f a -> g0 ()) -> Telescope g f xs -> g0 () Source #
HSequence ( Telescope g :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods hsequence' :: forall (xs :: l) f (g0 :: k0 -> Type ). ( SListIN ( Telescope g) xs, Applicative f) => Telescope g (f :.: g0) xs -> f ( Telescope g g0 xs) Source # hctraverse' :: forall c (xs :: l) g0 proxy f f'. ( AllN ( Telescope g) c xs, Applicative g0) => proxy c -> ( forall (a :: k0). c a => f a -> g0 (f' a)) -> Telescope g f xs -> g0 ( Telescope g f' xs) Source # htraverse' :: forall (xs :: l) g0 f f'. ( SListIN ( Telescope g) xs, Applicative g0) => ( forall (a :: k0). f a -> g0 (f' a)) -> Telescope g f xs -> g0 ( Telescope g f' xs) Source #
( All ( Compose Eq g) xs, All ( Compose Eq f) xs) => Eq ( Telescope g f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods (==) :: Telescope g f xs -> Telescope g f xs -> Bool Source # (/=) :: Telescope g f xs -> Telescope g f xs -> Bool Source #
( All ( Compose Eq g) xs, All ( Compose Ord g) xs, All ( Compose Eq f) xs, All ( Compose Ord f) xs) => Ord ( Telescope g f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods compare :: Telescope g f xs -> Telescope g f xs -> Ordering Source # (<) :: Telescope g f xs -> Telescope g f xs -> Bool Source # (<=) :: Telescope g f xs -> Telescope g f xs -> Bool Source # (>) :: Telescope g f xs -> Telescope g f xs -> Bool Source # (>=) :: Telescope g f xs -> Telescope g f xs -> Bool Source # max :: Telescope g f xs -> Telescope g f xs -> Telescope g f xs Source # min :: Telescope g f xs -> Telescope g f xs -> Telescope g f xs Source #
( All ( Compose Show g) xs, All ( Compose Show f) xs) => Show ( Telescope g f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods showsPrec :: Int -> Telescope g f xs -> ShowS Source # show :: Telescope g f xs -> String Source # showList :: [ Telescope g f xs] -> ShowS Source #
( All ( Compose NoThunks g) xs, All ( Compose NoThunks f) xs) => NoThunks ( Telescope g f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope Methods noThunks :: Context -> Telescope g f xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Telescope g f xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Telescope g f xs) -> String Source #
type Prod ( Telescope g :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope type Prod ( Telescope g :: (k -> Type ) -> [k] -> Type ) = NP :: (k -> Type ) -> [k] -> Type
type SListIN ( Telescope g :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope type SListIN ( Telescope g :: (k -> Type ) -> [k] -> Type ) = SListI :: [k] -> Constraint
type AllN ( Telescope g :: (k -> Type ) -> [k] -> Type ) (c :: k -> Constraint ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Telescope type AllN ( Telescope g :: (k -> Type ) -> [k] -> Type ) (c :: k -> Constraint ) = All c

data Mismatch :: (k -> Type ) -> (k -> Type ) -> [k] -> Type where Source #

Constructors

ML :: f x -> NS g xs -> Mismatch f g (x ': xs)
MR :: NS f xs -> g x -> Mismatch f g (x ': xs)
MS :: Mismatch f g xs -> Mismatch f g (x ': xs)

Instances

Instances details

HAp ( Mismatch f :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match Methods hap :: forall (f0 :: k0 -> Type ) (g :: k0 -> Type ) (xs :: l). Prod ( Mismatch f) (f0 -.-> g) xs -> Mismatch f f0 xs -> Mismatch f g xs Source #
( All ( Compose Eq f) xs, All ( Compose Eq g) xs) => Eq ( Mismatch f g xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match Methods (==) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source # (/=) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source #
( All ( Compose Eq f) xs, All ( Compose Ord f) xs, All ( Compose Eq g) xs, All ( Compose Ord g) xs) => Ord ( Mismatch f g xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match Methods compare :: Mismatch f g xs -> Mismatch f g xs -> Ordering Source # (<) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source # (<=) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source # (>) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source # (>=) :: Mismatch f g xs -> Mismatch f g xs -> Bool Source # max :: Mismatch f g xs -> Mismatch f g xs -> Mismatch f g xs Source # min :: Mismatch f g xs -> Mismatch f g xs -> Mismatch f g xs Source #
( All ( Compose Show f) xs, All ( Compose Show g) xs) => Show ( Mismatch f g xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match Methods showsPrec :: Int -> Mismatch f g xs -> ShowS Source # show :: Mismatch f g xs -> String Source # showList :: [ Mismatch f g xs] -> ShowS Source #
( All ( Compose NoThunks f) xs, All ( Compose NoThunks g) xs) => NoThunks ( Mismatch f g xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match Methods noThunks :: Context -> Mismatch f g xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Mismatch f g xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Mismatch f g xs) -> String Source #
type Prod ( Mismatch f :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match type Prod ( Mismatch f :: (k -> Type ) -> [k] -> Type ) = NP :: (k -> Type ) -> [k] -> Type
type SListIN ( Mismatch f :: (k -> Type ) -> [k] -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match type SListIN ( Mismatch f :: (k -> Type ) -> [k] -> Type ) = SListI :: [k] -> Constraint
type AllN ( Mismatch f :: (k -> Type ) -> [k] -> Type ) (c :: k -> Constraint ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Util.Match type AllN ( Mismatch f :: (k -> Type ) -> [k] -> Type ) (c :: k -> Constraint ) = All c

newtype HardForkState f xs Source #

Generic hard fork state

This is used both for the consensus state and the ledger state.

Constructors

HardForkState
Fields getHardForkState :: Telescope ( K Past ) ( Current f) xs

Instances

Instances details

SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( HardForkChainDepState xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( HardForkChainDepState xs) Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( HardForkChainDepState xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> HardForkChainDepState xs -> Encoding Source #
HAp HardForkState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods hap :: forall (f :: k -> Type ) (g :: k -> Type ) (xs :: l). Prod HardForkState (f -.-> g) xs -> HardForkState f xs -> HardForkState g xs Source #
HCollapse HardForkState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods hcollapse :: forall (xs :: l) a. SListIN HardForkState xs => HardForkState ( K a) xs -> CollapseTo HardForkState a Source #
HSequence HardForkState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods hsequence' :: forall (xs :: l) f (g :: k -> Type ). ( SListIN HardForkState xs, Applicative f) => HardForkState (f :.: g) xs -> f ( HardForkState g xs) Source # hctraverse' :: forall c (xs :: l) g proxy f f'. ( AllN HardForkState c xs, Applicative g) => proxy c -> ( forall (a :: k). c a => f a -> g (f' a)) -> HardForkState f xs -> g ( HardForkState f' xs) Source # htraverse' :: forall (xs :: l) g f f'. ( SListIN HardForkState xs, Applicative g) => ( forall (a :: k). f a -> g (f' a)) -> HardForkState f xs -> g ( HardForkState f' xs) Source #
( All SingleEraBlock xs, forall blk. SingleEraBlock blk => Eq (f blk)) => Eq ( HardForkState f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods (==) :: HardForkState f xs -> HardForkState f xs -> Bool Source # (/=) :: HardForkState f xs -> HardForkState f xs -> Bool Source #
( All SingleEraBlock xs, forall blk. SingleEraBlock blk => Show (f blk)) => Show ( HardForkState f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods showsPrec :: Int -> HardForkState f xs -> ShowS Source # show :: HardForkState f xs -> String Source # showList :: [ HardForkState f xs] -> ShowS Source #
( All SingleEraBlock xs, forall blk. SingleEraBlock blk => NoThunks (f blk)) => NoThunks ( HardForkState f xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances Methods noThunks :: Context -> HardForkState f xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> HardForkState f xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( HardForkState f xs) -> String Source #
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 ( Except PastHorizonException ) }
type Prod HardForkState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances type Prod HardForkState = NP :: ( Type -> Type ) -> [ Type ] -> Type
type SListIN HardForkState Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances type SListIN HardForkState = SListI :: [ Type ] -> Constraint
type CollapseTo HardForkState a Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances type CollapseTo HardForkState a = a
type AllN HardForkState (c :: Type -> Constraint ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.State.Instances type AllN HardForkState (c :: Type -> Constraint ) = All c

data EraTranslation xs Source #

Constructors

EraTranslation
Fields translateLedgerState :: InPairs ( RequiringBoth WrapLedgerConfig ( Translate LedgerState )) xs translateChainDepState :: InPairs ( RequiringBoth WrapConsensusConfig ( Translate WrapChainDepState )) xs translateLedgerView :: InPairs ( RequiringBoth WrapLedgerConfig ( TranslateForecast LedgerState WrapLedgerView )) xs

Instances

Instances details

NoThunks ( EraTranslation xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Translation Methods noThunks :: Context -> EraTranslation xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> EraTranslation xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( EraTranslation xs) -> String Source #

trivialEraTranslation :: EraTranslation '[blk] Source #

type InjectValidatedTx = InjectPolyTx WrapValidatedGenTx Source #

type InjectTx = InjectPolyTx GenTx Source #

pattern InjectValidatedTx :: ( WrapValidatedGenTx blk -> Maybe ( WrapValidatedGenTx blk')) -> InjectValidatedTx blk blk' Source #

InjectPolyTx at type InjectValidatedTx

pattern InjectTx :: ( GenTx blk -> Maybe ( GenTx blk')) -> InjectTx blk blk' Source #

InjectPolyTx at type InjectTx

cannotInjectTx :: InjectTx blk blk' Source #

cannotInjectPolyTx at type InjectTx

cannotInjectValidatedTx :: InjectValidatedTx blk blk' Source #

cannotInjectPolyTx at type InjectValidatedTx

data family BlockQuery blk :: Type -> Type Source #

Different queries supported by the ledger, indexed by the result type.

Instances

Instances details

ShowQuery ( BlockQuery ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showResult :: BlockQuery ( DualBlock m a) result -> result -> String Source #
All SingleEraBlock xs => ShowQuery ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showResult :: BlockQuery ( HardForkBlock xs) result -> result -> String Source #
SameDepIndex ( BlockQuery ( DualBlock m a)) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods sameDepIndex :: BlockQuery ( DualBlock m a) a0 -> BlockQuery ( DualBlock m a) b -> Maybe (a0 :~: b) Source #
All SingleEraBlock xs => SameDepIndex ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods sameDepIndex :: BlockQuery ( HardForkBlock xs) a -> BlockQuery ( HardForkBlock xs) b -> Maybe (a :~: b) Source #
Inject ( SomeSecond BlockQuery ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Embed.Nary Methods inject :: forall x (xs :: [ Type ]). CanHardFork xs => Exactly xs Bound -> Index xs x -> SomeSecond BlockQuery x -> SomeSecond BlockQuery ( HardForkBlock xs) Source #
SerialiseHFC xs => SerialiseResult ( HardForkBlock xs) ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeResult :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> BlockQuery ( HardForkBlock xs) result -> result -> Encoding Source # decodeResult :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> BlockQuery ( HardForkBlock xs) result -> forall s. Decoder s result Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( SomeSecond BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> SomeSecond BlockQuery ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( SomeSecond BlockQuery ( HardForkBlock xs)) Source #
SameDepIndex ( BlockQuery blk) => Eq ( SomeSecond BlockQuery blk) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Query Methods (==) :: SomeSecond BlockQuery blk -> SomeSecond BlockQuery blk -> Bool Source # (/=) :: SomeSecond BlockQuery blk -> SomeSecond BlockQuery blk -> Bool Source #
( forall result. Show ( BlockQuery blk result)) => Show ( SomeSecond BlockQuery blk) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Query Methods showsPrec :: Int -> SomeSecond BlockQuery blk -> ShowS Source # show :: SomeSecond BlockQuery blk -> String Source # showList :: [ SomeSecond BlockQuery blk] -> ShowS Source #
Show ( BlockQuery ( DualBlock m a) result) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showsPrec :: Int -> BlockQuery ( DualBlock m a) result -> ShowS Source # show :: BlockQuery ( DualBlock m a) result -> String Source # showList :: [ BlockQuery ( DualBlock m a) result] -> ShowS Source #
All SingleEraBlock xs => Show ( BlockQuery ( HardForkBlock xs) result) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showsPrec :: Int -> BlockQuery ( HardForkBlock xs) result -> ShowS Source # show :: BlockQuery ( HardForkBlock xs) result -> String Source # showList :: [ BlockQuery ( HardForkBlock xs) result] -> ShowS Source #
( Typeable m, Typeable a) => ShowProxy ( BlockQuery ( DualBlock m a) :: Type -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual Methods showProxy :: Proxy ( BlockQuery ( DualBlock m a)) -> String Source #
Typeable xs => ShowProxy ( BlockQuery ( HardForkBlock xs) :: Type -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showProxy :: Proxy ( BlockQuery ( HardForkBlock xs)) -> String Source #
data BlockQuery ( HardForkBlock xs) a Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query data BlockQuery ( HardForkBlock xs) a where QueryIfCurrent :: forall (xs :: [ Type ]) result. QueryIfCurrent xs result -> BlockQuery ( HardForkBlock xs) ( HardForkQueryResult xs result) QueryAnytime :: forall (xs :: [ Type ]) result x. IsNonEmpty xs => QueryAnytime result -> EraIndex (x ': xs) -> BlockQuery ( HardForkBlock (x ': xs)) result QueryHardFork :: forall (xs :: [ Type ]) x result. IsNonEmpty xs => QueryHardFork (x ': xs) result -> BlockQuery ( HardForkBlock (x ': xs)) result
data BlockQuery ( DualBlock m a) result Source #
Instance details Defined in Ouroboros.Consensus.Ledger.Dual data BlockQuery ( DualBlock m a) result

newtype EraIndex xs Source #

Constructors

EraIndex
Fields getEraIndex :: NS ( K ()) xs

Instances

Instances details

Eq ( EraIndex xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Abstract.SingleEraBlock Methods (==) :: EraIndex xs -> EraIndex xs -> Bool Source # (/=) :: EraIndex xs -> EraIndex xs -> Bool Source #
All SingleEraBlock xs => Show ( EraIndex xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Abstract.SingleEraBlock Methods showsPrec :: Int -> EraIndex xs -> ShowS Source # show :: EraIndex xs -> String Source # showList :: [ EraIndex xs] -> ShowS Source #
SListI xs => Serialise ( EraIndex xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Abstract.SingleEraBlock Methods encode :: EraIndex xs -> Encoding Source # decode :: Decoder s ( EraIndex xs) Source # encodeList :: [ EraIndex xs] -> Encoding Source # decodeList :: Decoder s [ EraIndex xs] Source #
All SingleEraBlock xs => Condense ( EraIndex xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Abstract.SingleEraBlock Methods condense :: EraIndex xs -> String Source #

class ( LedgerSupportsProtocol blk, InspectLedger blk, LedgerSupportsMempool blk, HasTxId ( GenTx blk), QueryLedger blk, HasPartialConsensusConfig ( BlockProtocol blk), HasPartialLedgerConfig blk, ConvertRawHash blk, ReconstructNestedCtxt Header blk, CommonProtocolParams blk, LedgerSupportsPeerSelection blk, ConfigSupportsNode blk, NodeInitStorage blk, BlockSupportsMetrics blk, Eq ( GenTx blk), Eq ( Validated ( GenTx blk)), Eq ( ApplyTxErr blk), Show blk, Show ( Header blk), Show ( CannotForge blk), Show ( ForgeStateInfo blk), Show ( ForgeStateUpdateError blk)) => SingleEraBlock blk where Source #

Blocks from which we can assemble a hard fork

Methods

singleEraTransition Source #

Arguments

:: PartialLedgerConfig blk
-> EraParams	Current era parameters
-> Bound	Start of this era
-> LedgerState blk
-> Maybe EpochNo

Era transition

This should only report the transition point once it is stable (rollback cannot affect it anymore).

Since we need this to construct the HardForkSummary (and hence the EpochInfo ), this takes the partial config, not the full config (or we'd end up with a catch-22).

singleEraInfo :: proxy blk -> SingleEraInfo blk Source #

Era information (for use in error messages)

proxySingle :: Proxy SingleEraBlock Source #

singleEraTransition' :: SingleEraBlock blk => WrapPartialLedgerConfig blk -> EraParams -> Bound -> LedgerState blk -> Maybe EpochNo Source #

eraIndexEmpty :: EraIndex '[] -> Void Source #

eraIndexFromNS :: SListI xs => NS f xs -> EraIndex xs Source #

eraIndexFromIndex :: Index xs blk -> EraIndex xs Source #

eraIndexZero :: EraIndex (x ': xs) Source #

eraIndexSucc :: EraIndex xs -> EraIndex (x ': xs) Source #

eraIndexToInt :: EraIndex xs -> Int Source #

initHardForkState :: f x -> HardForkState f (x ': xs) Source #

data WithBlockNo (f :: k -> Type ) (a :: k) Source #

Constructors

WithBlockNo
Fields getBlockNo :: BlockNo dropBlockNo :: f a

Instances

Instances details

Eq (f a) => Eq ( WithBlockNo f a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel Methods (==) :: WithBlockNo f a -> WithBlockNo f a -> Bool Source # (/=) :: WithBlockNo f a -> WithBlockNo f a -> Bool Source #
Show (f a) => Show ( WithBlockNo f a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel Methods showsPrec :: Int -> WithBlockNo f a -> ShowS Source # show :: WithBlockNo f a -> String Source # showList :: [ WithBlockNo f a] -> ShowS Source #
Generic ( WithBlockNo f a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel Associated Types type Rep ( WithBlockNo f a) :: Type -> Type Source # Methods from :: WithBlockNo f a -> Rep ( WithBlockNo f a) x Source # to :: Rep ( WithBlockNo f a) x -> WithBlockNo f a Source #
NoThunks (f a) => NoThunks ( WithBlockNo f a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel Methods noThunks :: Context -> WithBlockNo f a -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> WithBlockNo f a -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( WithBlockNo f a) -> String Source #
type Rep ( WithBlockNo f a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel type Rep ( WithBlockNo f a) = D1 (' MetaData "WithBlockNo" "Ouroboros.Consensus.HardFork.Combinator.Protocol.ChainSel" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "WithBlockNo" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getBlockNo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 BlockNo ) :*: S1 (' MetaSel (' Just "dropBlockNo") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 (f a))))

data AcrossEraSelection :: Type -> Type -> Type where Source #

Constructors

CompareBlockNo :: AcrossEraSelection x y

Just compare block numbers

This is a useful default when two eras run totally different consensus protocols, and we just want to choose the longer chain.

SelectSameProtocol :: BlockProtocol x ~ BlockProtocol y => AcrossEraSelection x y

Two eras running the same protocol

In this case, we can just call compareChains even across eras. (The ChainSelConfig must also be the same in both eras: we assert this at the value level.)

NOTE: We require that the eras have the same protocol , not merely the same SelectView , because if we have two eras with different protocols that happen to use the same SelectView but a different way to compare chains, it's not clear how to do cross-era selection.

CustomChainSel :: ( SelectView ( BlockProtocol x) -> SelectView ( BlockProtocol y) -> Ordering ) -> AcrossEraSelection x y

Custom chain selection

This is the most general form, and allows to override chain selection for the specific combination of two eras with a custom comparison function.

acrossEraSelection :: All SingleEraBlock xs => Tails AcrossEraSelection xs -> WithBlockNo ( NS WrapSelectView ) xs -> WithBlockNo ( NS WrapSelectView ) xs -> Ordering Source #

mapWithBlockNo :: (f x -> g y) -> WithBlockNo f x -> WithBlockNo g y Source #

class SingleEraBlock blk => NoHardForks blk where Source #

Methods

getEraParams :: TopLevelConfig blk -> EraParams Source #

Extract EraParams from the top-level config

The HFC itself does not care about this, as it must be given the full shape across all eras.

toPartialLedgerConfig :: proxy blk -> LedgerConfig blk -> PartialLedgerConfig blk Source #

Construct partial ledger config from full ledger config

Instances

Instances details

SingleEraBlock blk => CanHardFork '[blk] Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Abstract.CanHardFork Methods hardForkEraTranslation :: EraTranslation '[blk] Source # hardForkChainSel :: Tails AcrossEraSelection '[blk] Source # hardForkInjectTxs :: InPairs ( RequiringBoth WrapLedgerConfig ( Product2 InjectTx InjectValidatedTx )) '[blk] Source #

type HardForkLedgerView = HardForkLedgerView_ WrapLedgerView Source #

data HardForkLedgerView_ f xs Source #

Constructors

HardForkLedgerView
Fields hardForkLedgerViewTransition :: ! TransitionInfo Information about the transition to the next era, if known hardForkLedgerViewPerEra :: !( HardForkState f xs) The underlying ledger view

Instances

Instances details

( 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 Source # show :: Ticked ( HardForkLedgerView_ ( K a) xs) -> String Source # showList :: [ Ticked ( HardForkLedgerView_ ( K a) xs)] -> ShowS Source #
( SListI xs, Show a) => Show ( HardForkLedgerView_ ( K a :: Type -> Type ) xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.LedgerView Methods showsPrec :: Int -> HardForkLedgerView_ ( K a) xs -> ShowS Source # show :: HardForkLedgerView_ ( K a) xs -> String Source # showList :: [ HardForkLedgerView_ ( K a) xs] -> ShowS Source #
CanHardFork xs => Show ( HardForkLedgerView_ WrapLedgerView xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol.LedgerView Methods showsPrec :: Int -> HardForkLedgerView_ WrapLedgerView xs -> ShowS Source # show :: HardForkLedgerView_ WrapLedgerView xs -> String Source # showList :: [ HardForkLedgerView_ WrapLedgerView xs] -> ShowS Source #
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 MismatchEraInfo xs Source #

Constructors

MismatchEraInfo
Fields getMismatchEraInfo :: Mismatch SingleEraInfo LedgerEraInfo xs Era mismatch We have an era mismatch between the era of a block header tx/query and the era of the current ledger.

Instances

Instances details

All SingleEraBlock xs => Eq ( MismatchEraInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: MismatchEraInfo xs -> MismatchEraInfo xs -> Bool Source # (/=) :: MismatchEraInfo xs -> MismatchEraInfo xs -> Bool Source #
All SingleEraBlock xs => Show ( MismatchEraInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> MismatchEraInfo xs -> ShowS Source # show :: MismatchEraInfo xs -> String Source # showList :: [ MismatchEraInfo xs] -> ShowS Source #
CanHardFork xs => NoThunks ( MismatchEraInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> MismatchEraInfo xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> MismatchEraInfo xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( MismatchEraInfo xs) -> String Source #

newtype OneEraHash (xs :: [k]) Source #

The hash for an era

This type is special: we don't use an NS here, because the hash by itself should not allow us to differentiate between eras. If it did, the size of the hash would necessarily have to increase, and that leads to trouble. So, the type parameter xs here is merely a phantom one, and we just store the underlying raw hash.

Constructors

OneEraHash
Fields getOneEraHash :: ShortByteString

Instances

Instances details

Eq ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: OneEraHash xs -> OneEraHash xs -> Bool Source # (/=) :: OneEraHash xs -> OneEraHash xs -> Bool Source #
Ord ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods compare :: OneEraHash xs -> OneEraHash xs -> Ordering Source # (<) :: OneEraHash xs -> OneEraHash xs -> Bool Source # (<=) :: OneEraHash xs -> OneEraHash xs -> Bool Source # (>) :: OneEraHash xs -> OneEraHash xs -> Bool Source # (>=) :: OneEraHash xs -> OneEraHash xs -> Bool Source # max :: OneEraHash xs -> OneEraHash xs -> OneEraHash xs Source # min :: OneEraHash xs -> OneEraHash xs -> OneEraHash xs Source #
Show ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraHash xs -> ShowS Source # show :: OneEraHash xs -> String Source # showList :: [ OneEraHash xs] -> ShowS Source #
NoThunks ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> OneEraHash xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> OneEraHash xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( OneEraHash xs) -> String Source #
Serialise ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods encode :: OneEraHash xs -> Encoding Source # decode :: Decoder s ( OneEraHash xs) Source # encodeList :: [ OneEraHash xs] -> Encoding Source # decodeList :: Decoder s [ OneEraHash xs] Source #
Condense ( OneEraHash xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods condense :: OneEraHash xs -> String Source #

newtype OneEraTipInfo xs Source #

Constructors

OneEraTipInfo
Fields getOneEraTipInfo :: NS WrapTipInfo xs

Instances

Instances details

CanHardFork xs => Eq ( OneEraTipInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: OneEraTipInfo xs -> OneEraTipInfo xs -> Bool Source # (/=) :: OneEraTipInfo xs -> OneEraTipInfo xs -> Bool Source #
CanHardFork xs => Show ( OneEraTipInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraTipInfo xs -> ShowS Source # show :: OneEraTipInfo xs -> String Source # showList :: [ OneEraTipInfo xs] -> ShowS Source #
CanHardFork xs => NoThunks ( OneEraTipInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> OneEraTipInfo xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> OneEraTipInfo xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( OneEraTipInfo xs) -> String Source #

newtype OneEraHeader xs Source #

Constructors

OneEraHeader
Fields getOneEraHeader :: NS Header xs

Instances

Instances details

CanHardFork xs => Show ( OneEraHeader xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraHeader xs -> ShowS Source # show :: OneEraHeader xs -> String Source # showList :: [ OneEraHeader xs] -> ShowS Source #
CanHardFork xs => NoThunks ( OneEraHeader xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> OneEraHeader xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> OneEraHeader xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( OneEraHeader xs) -> String Source #

newtype OneEraGenTxId xs Source #

Constructors

OneEraGenTxId
Fields getOneEraGenTxId :: NS WrapGenTxId xs

Instances

Instances details

CanHardFork xs => Eq ( OneEraGenTxId xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source # (/=) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source #
CanHardFork xs => Ord ( OneEraGenTxId xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods compare :: OneEraGenTxId xs -> OneEraGenTxId xs -> Ordering Source # (<) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source # (<=) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source # (>) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source # (>=) :: OneEraGenTxId xs -> OneEraGenTxId xs -> Bool Source # max :: OneEraGenTxId xs -> OneEraGenTxId xs -> OneEraGenTxId xs Source # min :: OneEraGenTxId xs -> OneEraGenTxId xs -> OneEraGenTxId xs Source #
CanHardFork xs => Show ( OneEraGenTxId xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraGenTxId xs -> ShowS Source # show :: OneEraGenTxId xs -> String Source # showList :: [ OneEraGenTxId xs] -> ShowS Source #
CanHardFork xs => NoThunks ( OneEraGenTxId xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> OneEraGenTxId xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> OneEraGenTxId xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( OneEraGenTxId xs) -> String Source #

newtype OneEraGenTx xs Source #

Constructors

OneEraGenTx
Fields getOneEraGenTx :: NS GenTx xs

Instances

Instances details

CanHardFork xs => Eq ( OneEraGenTx xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: OneEraGenTx xs -> OneEraGenTx xs -> Bool Source # (/=) :: OneEraGenTx xs -> OneEraGenTx xs -> Bool Source #
CanHardFork xs => Show ( OneEraGenTx xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraGenTx xs -> ShowS Source # show :: OneEraGenTx xs -> String Source # showList :: [ OneEraGenTx xs] -> ShowS Source #
CanHardFork xs => NoThunks ( OneEraGenTx xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> OneEraGenTx xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> OneEraGenTx xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( OneEraGenTx xs) -> String Source #

newtype OneEraBlock xs Source #

Constructors

OneEraBlock
Fields getOneEraBlock :: NS I xs

Instances

Instances details

CanHardFork xs => Show ( OneEraBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraBlock xs -> ShowS Source # show :: OneEraBlock xs -> String Source # showList :: [ OneEraBlock xs] -> ShowS Source #

newtype OneEraApplyTxErr xs Source #

Constructors

OneEraApplyTxErr
Fields getOneEraApplyTxErr :: NS WrapApplyTxErr xs

Instances

Instances details

CanHardFork xs => Eq ( OneEraApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods (==) :: OneEraApplyTxErr xs -> OneEraApplyTxErr xs -> Bool Source # (/=) :: OneEraApplyTxErr xs -> OneEraApplyTxErr xs -> Bool Source #
CanHardFork xs => Show ( OneEraApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods showsPrec :: Int -> OneEraApplyTxErr xs -> ShowS Source # show :: OneEraApplyTxErr xs -> String Source # showList :: [ OneEraApplyTxErr xs] -> ShowS Source #

newtype PerEraStorageConfig xs Source #

Constructors

PerEraStorageConfig
Fields getPerEraStorageConfig :: NP StorageConfig xs

Instances

Instances details

CanHardFork xs => NoThunks ( PerEraStorageConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> PerEraStorageConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> PerEraStorageConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( PerEraStorageConfig xs) -> String Source #

newtype PerEraLedgerConfig xs Source #

Constructors

PerEraLedgerConfig
Fields getPerEraLedgerConfig :: NP WrapPartialLedgerConfig xs

Instances

Instances details

CanHardFork xs => NoThunks ( PerEraLedgerConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> PerEraLedgerConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> PerEraLedgerConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( PerEraLedgerConfig xs) -> String Source #

newtype PerEraConsensusConfig xs Source #

Constructors

PerEraConsensusConfig
Fields getPerEraConsensusConfig :: NP WrapPartialConsensusConfig xs

Instances

Instances details

CanHardFork xs => NoThunks ( PerEraConsensusConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> PerEraConsensusConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> PerEraConsensusConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( PerEraConsensusConfig xs) -> String Source #

newtype PerEraCodecConfig xs Source #

Constructors

PerEraCodecConfig
Fields getPerEraCodecConfig :: NP CodecConfig xs

Instances

Instances details

CanHardFork xs => NoThunks ( PerEraCodecConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> PerEraCodecConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> PerEraCodecConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( PerEraCodecConfig xs) -> String Source #

newtype PerEraBlockConfig xs Source #

Constructors

PerEraBlockConfig
Fields getPerEraBlockConfig :: NP BlockConfig xs

Instances

Instances details

CanHardFork xs => NoThunks ( PerEraBlockConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.AcrossEras Methods noThunks :: Context -> PerEraBlockConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> PerEraBlockConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( PerEraBlockConfig xs) -> String Source #

data HardForkLedgerConfig xs Source #

Constructors

HardForkLedgerConfig
Fields hardForkLedgerConfigShape :: !( Shape xs) hardForkLedgerConfigPerEra :: !( PerEraLedgerConfig xs)

Instances

Instances details

Generic ( HardForkLedgerConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Associated Types type Rep ( HardForkLedgerConfig xs) :: Type -> Type Source # Methods from :: HardForkLedgerConfig xs -> Rep ( HardForkLedgerConfig xs) x Source # to :: Rep ( HardForkLedgerConfig xs) x -> HardForkLedgerConfig xs Source #
CanHardFork xs => NoThunks ( HardForkLedgerConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> HardForkLedgerConfig xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> HardForkLedgerConfig xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( HardForkLedgerConfig xs) -> String Source #
type Rep ( HardForkLedgerConfig xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type Rep ( HardForkLedgerConfig xs) = D1 (' MetaData "HardForkLedgerConfig" "Ouroboros.Consensus.HardFork.Combinator.Basics" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkLedgerConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "hardForkLedgerConfigShape") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Shape xs)) :*: S1 (' MetaSel (' Just "hardForkLedgerConfigPerEra") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( PerEraLedgerConfig xs))))

newtype HardForkBlock xs Source #

Constructors

HardForkBlock
Fields getHardForkBlock :: OneEraBlock xs

Instances

Instances details

Typeable xs => ShowProxy ( Header ( HardForkBlock xs) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods showProxy :: Proxy ( Header ( HardForkBlock xs)) -> String Source #
Typeable xs => ShowProxy ( TxId ( GenTx ( HardForkBlock xs)) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
Typeable xs => ShowProxy ( GenTx ( HardForkBlock xs) :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( GenTx ( HardForkBlock xs)) -> String Source #
CanHardFork xs => HasNestedContent Header ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods unnest :: Header ( HardForkBlock xs) -> DepPair ( NestedCtxt Header ( HardForkBlock xs)) Source # nest :: DepPair ( NestedCtxt Header ( HardForkBlock xs)) -> Header ( HardForkBlock xs) Source #
SerialiseHFC xs => ReconstructNestedCtxt Header ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods reconstructPrefixLen :: proxy ( Header ( HardForkBlock xs)) -> PrefixLen Source # reconstructNestedCtxt :: proxy ( Header ( HardForkBlock xs)) -> ShortByteString -> SizeInBytes -> SomeSecond ( NestedCtxt Header ) ( HardForkBlock xs) Source #
All ( Compose Eq Header ) xs => Eq ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods (==) :: Header ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> Bool Source # (/=) :: Header ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> Bool Source #
CanHardFork xs => Eq ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods (==) :: LedgerState ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Bool Source # (/=) :: LedgerState ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Bool Source #
CanHardFork xs => Eq ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: Validated ( GenTx ( HardForkBlock xs)) -> Validated ( GenTx ( HardForkBlock xs)) -> Bool Source #
CanHardFork xs => Eq ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (/=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source #
CanHardFork xs => Eq ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: GenTx ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Bool Source # (/=) :: GenTx ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Bool Source #
All Eq xs => Eq ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods (==) :: HardForkBlock xs -> HardForkBlock xs -> Bool Source # (/=) :: HardForkBlock xs -> HardForkBlock xs -> Bool Source #
CanHardFork xs => Ord ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods compare :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Ordering Source # (<) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (<=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # (>=) :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> Bool Source # max :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source # min :: TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) -> TxId ( GenTx ( HardForkBlock xs)) Source #
CanHardFork xs => Show ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods showsPrec :: Int -> Header ( HardForkBlock xs) -> ShowS Source # show :: Header ( HardForkBlock xs) -> String Source # showList :: [ Header ( HardForkBlock xs)] -> ShowS Source #
CanHardFork xs => Show ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods showsPrec :: Int -> LedgerState ( HardForkBlock xs) -> ShowS Source # show :: LedgerState ( HardForkBlock xs) -> String Source # showList :: [ LedgerState ( HardForkBlock xs)] -> ShowS Source #
CanHardFork xs => Show ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> Validated ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: Validated ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ Validated ( GenTx ( HardForkBlock xs))] -> ShowS Source #
CanHardFork xs => Show ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> TxId ( GenTx ( HardForkBlock xs)) -> ShowS Source # show :: TxId ( GenTx ( HardForkBlock xs)) -> String Source # showList :: [ TxId ( GenTx ( HardForkBlock xs))] -> ShowS Source #
CanHardFork xs => Show ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> GenTx ( HardForkBlock xs) -> ShowS Source # show :: GenTx ( HardForkBlock xs) -> String Source # showList :: [ GenTx ( HardForkBlock xs)] -> ShowS Source #
CanHardFork xs => Show ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods showsPrec :: Int -> HardForkBlock xs -> ShowS Source # show :: HardForkBlock xs -> String Source # showList :: [ HardForkBlock xs] -> ShowS Source #
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 Source # Methods from :: Ticked ( LedgerState ( HardForkBlock xs)) -> Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x Source # to :: Rep ( Ticked ( LedgerState ( HardForkBlock xs))) x -> Ticked ( LedgerState ( HardForkBlock xs)) Source #
Generic ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( Validated ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: Validated ( GenTx ( HardForkBlock xs)) -> Rep ( Validated ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( Validated ( GenTx ( HardForkBlock xs))) x -> Validated ( GenTx ( HardForkBlock xs)) Source #
Generic ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( TxId ( GenTx ( HardForkBlock xs))) :: Type -> Type Source # Methods from :: TxId ( GenTx ( HardForkBlock xs)) -> Rep ( TxId ( GenTx ( HardForkBlock xs))) x Source # to :: Rep ( TxId ( GenTx ( HardForkBlock xs))) x -> TxId ( GenTx ( HardForkBlock xs)) Source #
Generic ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( GenTx ( HardForkBlock xs)) :: Type -> Type Source # Methods from :: GenTx ( HardForkBlock xs) -> Rep ( GenTx ( HardForkBlock xs)) x Source # to :: Rep ( GenTx ( HardForkBlock xs)) x -> GenTx ( HardForkBlock xs) 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 #
CanHardFork xs => NoThunks ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods noThunks :: Context -> Header ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Header ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Header ( HardForkBlock xs)) -> String Source #
CanHardFork xs => NoThunks ( StorageConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> StorageConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> StorageConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( StorageConfig ( HardForkBlock xs)) -> String Source #
CanHardFork xs => NoThunks ( CodecConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> CodecConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> CodecConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( CodecConfig ( HardForkBlock xs)) -> String Source #
CanHardFork xs => NoThunks ( BlockConfig ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> BlockConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> BlockConfig ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( BlockConfig ( HardForkBlock xs)) -> String Source #
CanHardFork xs => NoThunks ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> LedgerState ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> LedgerState ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( LedgerState ( HardForkBlock xs)) -> String Source #
CanHardFork xs => NoThunks ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Validated ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Validated ( GenTx ( HardForkBlock xs))) -> String Source #
CanHardFork xs => NoThunks ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> TxId ( GenTx ( HardForkBlock xs)) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( TxId ( GenTx ( HardForkBlock xs))) -> String Source #
CanHardFork xs => NoThunks ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods noThunks :: Context -> GenTx ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> GenTx ( HardForkBlock xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( GenTx ( HardForkBlock xs)) -> String Source #
All SingleEraBlock xs => ShowQuery ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showResult :: BlockQuery ( HardForkBlock xs) result -> result -> String Source #
CanHardFork xs => HasHeader ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods getHeaderFields :: Header ( HardForkBlock xs) -> HeaderFields ( Header ( HardForkBlock xs)) Source #
CanHardFork xs => HasHeader ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods getHeaderFields :: HardForkBlock xs -> HeaderFields ( HardForkBlock xs) Source #
CanHardFork xs => StandardHash ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block
SerialiseHFC xs => HasNetworkProtocolVersion ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.Common Associated Types type BlockNodeToNodeVersion ( HardForkBlock xs) Source # type BlockNodeToClientVersion ( HardForkBlock xs) Source #
All SingleEraBlock xs => SameDepIndex ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods sameDepIndex :: BlockQuery ( HardForkBlock xs) a -> BlockQuery ( HardForkBlock xs) b -> Maybe (a :~: b) Source #
All CondenseConstraints xs => Condense ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: Header ( HardForkBlock xs) -> String Source #
All CondenseConstraints xs => Condense ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: TxId ( GenTx ( HardForkBlock xs)) -> String Source #
All CondenseConstraints xs => Condense ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: GenTx ( HardForkBlock xs) -> String Source #
All CondenseConstraints xs => Condense ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Condense Methods condense :: HardForkBlock xs -> String Source #
CanHardFork xs => ConvertRawHash ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods toRawHash :: proxy ( HardForkBlock xs) -> HeaderHash ( HardForkBlock xs) -> ByteString Source # fromRawHash :: proxy ( HardForkBlock xs) -> ByteString -> HeaderHash ( HardForkBlock xs) Source # toShortRawHash :: proxy ( HardForkBlock xs) -> HeaderHash ( HardForkBlock xs) -> ShortByteString Source # fromShortRawHash :: proxy ( HardForkBlock xs) -> ShortByteString -> HeaderHash ( HardForkBlock xs) Source # hashSize :: proxy ( HardForkBlock xs) -> Word32 Source #
CanHardFork xs => GetHeader ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods getHeader :: HardForkBlock xs -> Header ( HardForkBlock xs) Source # blockMatchesHeader :: Header ( HardForkBlock xs) -> HardForkBlock xs -> Bool Source # headerIsEBB :: Header ( HardForkBlock xs) -> Maybe EpochNo Source #
CanHardFork xs => GetPrevHash ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods headerPrevHash :: Header ( HardForkBlock xs) -> ChainHash ( HardForkBlock xs) Source #
CanHardFork xs => IsLedger ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type LedgerErr ( LedgerState ( HardForkBlock xs)) Source # type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) Source # Methods applyChainTickLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> SlotNo -> LedgerState ( HardForkBlock xs) -> LedgerResult ( LedgerState ( HardForkBlock xs)) ( Ticked ( LedgerState ( HardForkBlock xs))) 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 #
CanHardFork xs => GetTip ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods getTip :: LedgerState ( HardForkBlock xs) -> Point ( LedgerState ( HardForkBlock xs)) Source #
CanHardFork xs => UpdateLedger ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger
CanHardFork xs => LedgerSupportsPeerSelection ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.PeerSelection Methods getPeers :: LedgerState ( HardForkBlock xs) -> [( PoolStake , NonEmpty StakePoolRelay )] Source #
CanHardFork xs => CommonProtocolParams ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.CommonProtocolParams Methods maxHeaderSize :: LedgerState ( HardForkBlock xs) -> Word32 Source # maxTxSize :: LedgerState ( HardForkBlock xs) -> Word32 Source #
CanHardFork xs => BlockSupportsProtocol ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Methods validateView :: BlockConfig ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> ValidateView ( BlockProtocol ( HardForkBlock xs)) Source # selectView :: BlockConfig ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> SelectView ( BlockProtocol ( HardForkBlock xs)) Source #
CanHardFork xs => BlockSupportsMetrics ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Node.Metrics Methods isSelfIssued :: BlockConfig ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> WhetherSelfIssued Source #
All HasTxs xs => HasTxs ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods extractTxs :: HardForkBlock xs -> [ GenTx ( HardForkBlock xs)] Source #
CanHardFork xs => HasTxId ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods txId :: GenTx ( HardForkBlock xs) -> TxId ( GenTx ( HardForkBlock xs)) Source #
CanHardFork xs => LedgerSupportsMempool ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods txInvariant :: GenTx ( HardForkBlock xs) -> Bool Source # applyTx :: LedgerConfig ( HardForkBlock xs) -> WhetherToIntervene -> SlotNo -> GenTx ( HardForkBlock xs) -> TickedLedgerState ( HardForkBlock xs) -> Except ( ApplyTxErr ( HardForkBlock xs)) ( TickedLedgerState ( HardForkBlock xs), Validated ( GenTx ( HardForkBlock xs))) Source # reapplyTx :: LedgerConfig ( HardForkBlock xs) -> SlotNo -> Validated ( GenTx ( HardForkBlock xs)) -> TickedLedgerState ( HardForkBlock xs) -> Except ( ApplyTxErr ( HardForkBlock xs)) ( TickedLedgerState ( HardForkBlock xs)) Source # txsMaxBytes :: TickedLedgerState ( HardForkBlock xs) -> Word32 Source # txInBlockSize :: GenTx ( HardForkBlock xs) -> Word32 Source # txForgetValidated :: Validated ( GenTx ( HardForkBlock xs)) -> GenTx ( HardForkBlock xs) Source #
CanHardFork xs => ValidateEnvelope ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type OtherHeaderEnvelopeError ( HardForkBlock xs) Source # Methods additionalEnvelopeChecks :: TopLevelConfig ( HardForkBlock xs) -> Ticked ( LedgerView ( BlockProtocol ( HardForkBlock xs))) -> Header ( HardForkBlock xs) -> Except ( OtherHeaderEnvelopeError ( HardForkBlock xs)) () Source #
CanHardFork xs => BasicEnvelopeValidation ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods expectedFirstBlockNo :: proxy ( HardForkBlock xs) -> BlockNo Source # expectedNextBlockNo :: proxy ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) -> BlockNo -> BlockNo Source # minimumPossibleSlotNo :: Proxy ( HardForkBlock xs) -> SlotNo Source # minimumNextSlotNo :: proxy ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) -> SlotNo -> SlotNo Source #
CanHardFork xs => HasAnnTip ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Associated Types type TipInfo ( HardForkBlock xs) Source # Methods getTipInfo :: Header ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) Source # tipInfoHash :: proxy ( HardForkBlock xs) -> TipInfo ( HardForkBlock xs) -> HeaderHash ( HardForkBlock xs) Source #
CanHardFork xs => InspectLedger ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type LedgerWarning ( HardForkBlock xs) Source # type LedgerUpdate ( HardForkBlock xs) Source # Methods inspectLedger :: TopLevelConfig ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> [ LedgerEvent ( HardForkBlock xs)] Source #
SerialiseHFC xs => HasBinaryBlockInfo ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods getBinaryBlockInfo :: HardForkBlock xs -> BinaryBlockInfo Source #
CanHardFork xs => LedgerSupportsProtocol ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods protocolLedgerView :: LedgerConfig ( HardForkBlock xs) -> Ticked ( LedgerState ( HardForkBlock xs)) -> Ticked ( LedgerView ( BlockProtocol ( HardForkBlock xs))) Source # ledgerViewForecastAt :: LedgerConfig ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Forecast ( LedgerView ( BlockProtocol ( HardForkBlock xs))) Source #
All SingleEraBlock xs => HasHardForkHistory ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type HardForkIndices ( HardForkBlock xs) :: [ Type ] Source # Methods hardForkSummary :: LedgerConfig ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Summary ( HardForkIndices ( HardForkBlock xs)) Source #
CanHardFork xs => ConfigSupportsNode ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Node Methods getSystemStart :: BlockConfig ( HardForkBlock xs) -> SystemStart Source # getNetworkMagic :: BlockConfig ( HardForkBlock xs) -> NetworkMagic Source #
All SingleEraBlock xs => QueryLedger ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods answerBlockQuery :: ExtLedgerCfg ( HardForkBlock xs) -> BlockQuery ( HardForkBlock xs) result -> ExtLedgerState ( HardForkBlock xs) -> result Source #
CanHardFork xs => NodeInitStorage ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Node.InitStorage Methods nodeImmutableDbChunkInfo :: StorageConfig ( HardForkBlock xs) -> ChunkInfo Source # nodeCheckIntegrity :: StorageConfig ( HardForkBlock xs) -> HardForkBlock xs -> Bool Source # nodeInitChainDB :: IOLike m => StorageConfig ( HardForkBlock xs) -> InitChainDB m ( HardForkBlock xs) -> m () Source #
SerialiseHFC xs => SerialiseDiskConstraints ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk
( CanHardFork xs, SupportedNetworkProtocolVersion ( HardForkBlock xs), SerialiseHFC xs) => RunNode ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Node
SerialiseHFC xs => SerialiseNodeToClientConstraints ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient
SerialiseHFC xs => SerialiseNodeToNodeConstraints ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods estimateBlockSize :: Header ( HardForkBlock xs) -> SizeInBytes Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) SlotNo Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> SlotNo -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s SlotNo Source #
Typeable xs => ShowProxy ( HardForkBlock xs :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods showProxy :: Proxy ( HardForkBlock xs) -> String Source #
CanHardFork xs => ApplyBlock ( LedgerState ( HardForkBlock xs)) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods applyBlockLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> HardForkBlock xs -> Ticked ( LedgerState ( HardForkBlock xs)) -> Except ( LedgerErr ( LedgerState ( HardForkBlock xs))) ( LedgerResult ( LedgerState ( HardForkBlock xs)) ( LedgerState ( HardForkBlock xs))) Source # reapplyBlockLedgerResult :: LedgerCfg ( LedgerState ( HardForkBlock xs)) -> HardForkBlock xs -> Ticked ( LedgerState ( HardForkBlock xs)) -> LedgerResult ( LedgerState ( HardForkBlock xs)) ( LedgerState ( HardForkBlock xs)) Source #
SerialiseHFC xs => DecodeDiskDep ( NestedCtxt Header ) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDiskDep :: CodecConfig ( HardForkBlock xs) -> NestedCtxt Header ( HardForkBlock xs) a -> forall s. Decoder s ( ByteString -> a) Source #
SerialiseHFC xs => DecodeDiskDepIx ( NestedCtxt Header ) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDiskDepIx :: CodecConfig ( HardForkBlock xs) -> Decoder s ( SomeSecond ( NestedCtxt Header ) ( HardForkBlock xs)) Source #
SerialiseHFC xs => EncodeDiskDep ( NestedCtxt Header ) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDiskDep :: CodecConfig ( HardForkBlock xs) -> NestedCtxt Header ( HardForkBlock xs) a -> a -> Encoding Source #
SerialiseHFC xs => EncodeDiskDepIx ( NestedCtxt Header ) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDiskDepIx :: CodecConfig ( HardForkBlock xs) -> SomeSecond ( NestedCtxt Header ) ( HardForkBlock xs) -> Encoding Source #
SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( LedgerState ( HardForkBlock xs)) Source #
SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( HardForkChainDepState xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( HardForkChainDepState xs) Source #
SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( AnnTip ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( AnnTip ( HardForkBlock xs)) Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> LedgerState ( HardForkBlock xs) -> Encoding Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( HardForkChainDepState xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> HardForkChainDepState xs -> Encoding Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( AnnTip ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> AnnTip ( HardForkBlock xs) -> Encoding Source #
SerialiseHFC xs => EncodeDisk ( HardForkBlock xs) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods encodeDisk :: CodecConfig ( HardForkBlock xs) -> HardForkBlock xs -> Encoding Source #
SerialiseHFC xs => SerialiseResult ( HardForkBlock xs) ( BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeResult :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> BlockQuery ( HardForkBlock xs) result -> result -> Encoding Source # decodeResult :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> BlockQuery ( HardForkBlock xs) result -> forall s. Decoder s result Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> HardForkApplyTxErr xs -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( HardForkApplyTxErr xs) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTx ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( Serialised ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> Serialised ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( Serialised ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> HardForkBlock xs -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( HardForkBlock xs) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( GenTxId ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> GenTxId ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTxId ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> GenTx ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( GenTx ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( SerialisedHeader ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> SerialisedHeader ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( SerialisedHeader ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( Serialised ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> Serialised ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( Serialised ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( Header ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> Header ( HardForkBlock xs) -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( Header ( HardForkBlock xs)) Source #
SerialiseHFC xs => SerialiseNodeToNode ( HardForkBlock xs) ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToNode Methods encodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> HardForkBlock xs -> Encoding Source # decodeNodeToNode :: CodecConfig ( HardForkBlock xs) -> BlockNodeToNodeVersion ( HardForkBlock xs) -> forall s. Decoder s ( HardForkBlock xs) Source #
SerialiseHFC xs => DecodeDisk ( HardForkBlock xs) ( ByteString -> HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseDisk Methods decodeDisk :: CodecConfig ( HardForkBlock xs) -> forall s. Decoder s ( ByteString -> HardForkBlock xs) Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( SomeSecond BlockQuery ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> SomeSecond BlockQuery ( HardForkBlock xs) -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( SomeSecond BlockQuery ( HardForkBlock xs)) Source #
All SingleEraBlock xs => Show ( BlockQuery ( HardForkBlock xs) result) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showsPrec :: Int -> BlockQuery ( HardForkBlock xs) result -> ShowS Source # show :: BlockQuery ( HardForkBlock xs) result -> String Source # showList :: [ BlockQuery ( HardForkBlock xs) result] -> ShowS Source #
CanHardFork xs => SameDepIndex ( NestedCtxt_ ( HardForkBlock xs) Header ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods sameDepIndex :: NestedCtxt_ ( HardForkBlock xs) Header a -> NestedCtxt_ ( HardForkBlock xs) Header b -> Maybe (a :~: b) Source #
Typeable xs => ShowProxy ( BlockQuery ( HardForkBlock xs) :: Type -> Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showProxy :: Proxy ( BlockQuery ( HardForkBlock xs)) -> String Source #
All SingleEraBlock xs => Show ( NestedCtxt_ ( HardForkBlock xs) Header a) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block Methods showsPrec :: Int -> NestedCtxt_ ( HardForkBlock xs) Header a -> ShowS Source # show :: NestedCtxt_ ( HardForkBlock xs) Header a -> String Source # showList :: [ NestedCtxt_ ( HardForkBlock xs) Header a] -> ShowS Source #
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.1-DT4Cvwf63DZKctsEvaJqCU" ' 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 Rep ( Validated ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( Validated ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "Validated" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkValidatedGenTx" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkValidatedGenTx") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraValidatedGenTx xs))))
type Rep ( TxId ( GenTx ( HardForkBlock xs))) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( TxId ( GenTx ( HardForkBlock xs))) = D1 (' MetaData "TxId" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkGenTxId" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkGenTxId") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraGenTxId xs))))
type Rep ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( GenTx ( HardForkBlock xs)) = D1 (' MetaData "GenTx" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' True ) ( C1 (' MetaCons "HardForkGenTx" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "getHardForkGenTx") ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraGenTx xs))))
type HeaderHash ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type HeaderHash ( HardForkBlock xs) = OneEraHash xs
type BlockNodeToNodeVersion ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.Common type BlockNodeToNodeVersion ( HardForkBlock xs) = HardForkNodeToNodeVersion xs
type BlockNodeToClientVersion ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.Common type BlockNodeToClientVersion ( HardForkBlock xs) = HardForkNodeToClientVersion xs
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 NestedCtxt_ ( HardForkBlock xs) a b Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block data NestedCtxt_ ( HardForkBlock xs) a b where NCZ :: forall x (f :: Type -> Type ) a (xs :: [ Type ]). !( NestedCtxt_ x f a) -> NestedCtxt_ ( HardForkBlock (x ': xs)) f a NCS :: forall (xs :: [ Type ]) (f :: Type -> Type ) a x. !( NestedCtxt_ ( HardForkBlock xs) f a) -> NestedCtxt_ ( HardForkBlock (x ': xs)) f a
newtype Header ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block newtype Header ( HardForkBlock xs) = HardForkHeader { getHardForkHeader :: OneEraHeader xs }
newtype StorageConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype StorageConfig ( HardForkBlock xs) = HardForkStorageConfig { hardForkStorageConfigPerEra :: PerEraStorageConfig xs }
newtype CodecConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype CodecConfig ( HardForkBlock xs) = HardForkCodecConfig { hardForkCodecConfigPerEra :: PerEraCodecConfig xs }
newtype BlockConfig ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype BlockConfig ( HardForkBlock xs) = HardForkBlockConfig { hardForkBlockConfigPerEra :: PerEraBlockConfig xs }
type BlockProtocol ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type BlockProtocol ( HardForkBlock xs) = HardForkProtocol xs
newtype LedgerState ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics newtype LedgerState ( HardForkBlock xs) = HardForkLedgerState { hardForkLedgerStatePerEra :: HardForkState LedgerState xs }
type LedgerErr ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type LedgerErr ( LedgerState ( HardForkBlock xs)) = HardForkLedgerError xs
type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type AuxLedgerEvent ( LedgerState ( HardForkBlock xs)) = OneEraLedgerEvent xs
type LedgerCfg ( LedgerState ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type LedgerCfg ( LedgerState ( HardForkBlock xs)) = HardForkLedgerConfig xs
newtype Validated ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype Validated ( GenTx ( HardForkBlock xs)) = HardForkValidatedGenTx { getHardForkValidatedGenTx :: OneEraValidatedGenTx xs }
newtype TxId ( GenTx ( HardForkBlock xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype TxId ( GenTx ( HardForkBlock xs)) = HardForkGenTxId { getHardForkGenTxId :: OneEraGenTxId xs }
type ApplyTxErr ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type ApplyTxErr ( HardForkBlock xs) = HardForkApplyTxErr xs
newtype GenTx ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool newtype GenTx ( HardForkBlock xs) = HardForkGenTx { getHardForkGenTx :: OneEraGenTx xs }
type ForgeStateUpdateError ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Forging type ForgeStateUpdateError ( HardForkBlock xs) = HardForkForgeStateUpdateError xs
type ForgeStateInfo ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Forging type ForgeStateInfo ( HardForkBlock xs) = HardForkForgeStateInfo xs
type CannotForge ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Forging type CannotForge ( HardForkBlock xs) = HardForkCannotForge xs
type OtherHeaderEnvelopeError ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type OtherHeaderEnvelopeError ( HardForkBlock xs) = HardForkEnvelopeErr xs
type TipInfo ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Block type TipInfo ( HardForkBlock xs) = OneEraTipInfo xs
type LedgerWarning ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type LedgerWarning ( HardForkBlock xs) = HardForkLedgerWarning xs
type LedgerUpdate ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type LedgerUpdate ( HardForkBlock xs) = HardForkLedgerUpdate xs
type HardForkIndices ( HardForkBlock xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type HardForkIndices ( HardForkBlock xs) = xs
data BlockQuery ( HardForkBlock xs) a Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query data BlockQuery ( HardForkBlock xs) a where QueryIfCurrent :: forall (xs :: [ Type ]) result. QueryIfCurrent xs result -> BlockQuery ( HardForkBlock xs) ( HardForkQueryResult xs result) QueryAnytime :: forall (xs :: [ Type ]) result x. IsNonEmpty xs => QueryAnytime result -> EraIndex (x ': xs) -> BlockQuery ( HardForkBlock (x ': xs)) result QueryHardFork :: forall (xs :: [ Type ]) x result. IsNonEmpty xs => QueryHardFork (x ': xs) result -> BlockQuery ( HardForkBlock (x ': xs)) result

data HardForkProtocol (xs :: [ Type ]) Source #

Instances

Instances details

Generic ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Associated Types type Rep ( ConsensusConfig ( HardForkProtocol xs)) :: Type -> Type Source # Methods from :: ConsensusConfig ( HardForkProtocol xs) -> Rep ( ConsensusConfig ( HardForkProtocol xs)) x Source # to :: Rep ( ConsensusConfig ( HardForkProtocol xs)) x -> ConsensusConfig ( HardForkProtocol xs) Source #
CanHardFork xs => NoThunks ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics Methods noThunks :: Context -> ConsensusConfig ( HardForkProtocol xs) -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> ConsensusConfig ( HardForkProtocol xs) -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( ConsensusConfig ( HardForkProtocol xs)) -> String Source #
CanHardFork xs => ConsensusProtocol ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Associated Types type ChainDepState ( HardForkProtocol xs) Source # type IsLeader ( HardForkProtocol xs) Source # type CanBeLeader ( HardForkProtocol xs) Source # type SelectView ( HardForkProtocol xs) Source # type LedgerView ( HardForkProtocol xs) Source # type ValidationErr ( HardForkProtocol xs) Source # type ValidateView ( HardForkProtocol xs) Source # Methods checkIsLeader :: ConsensusConfig ( HardForkProtocol xs) -> CanBeLeader ( HardForkProtocol xs) -> SlotNo -> Ticked ( ChainDepState ( HardForkProtocol xs)) -> Maybe ( IsLeader ( HardForkProtocol xs)) Source # tickChainDepState :: ConsensusConfig ( HardForkProtocol xs) -> Ticked ( LedgerView ( HardForkProtocol xs)) -> SlotNo -> ChainDepState ( HardForkProtocol xs) -> Ticked ( ChainDepState ( HardForkProtocol xs)) Source # updateChainDepState :: ConsensusConfig ( HardForkProtocol xs) -> ValidateView ( HardForkProtocol xs) -> SlotNo -> Ticked ( ChainDepState ( HardForkProtocol xs)) -> Except ( ValidationErr ( HardForkProtocol xs)) ( ChainDepState ( HardForkProtocol xs)) Source # reupdateChainDepState :: ConsensusConfig ( HardForkProtocol xs) -> ValidateView ( HardForkProtocol xs) -> SlotNo -> Ticked ( ChainDepState ( HardForkProtocol xs)) -> ChainDepState ( HardForkProtocol xs) Source # protocolSecurityParam :: ConsensusConfig ( HardForkProtocol xs) -> SecurityParam Source #
type Rep ( ConsensusConfig ( HardForkProtocol xs)) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics type Rep ( ConsensusConfig ( HardForkProtocol xs)) = D1 (' MetaData "ConsensusConfig" "Ouroboros.Consensus.HardFork.Combinator.Basics" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkConsensusConfig" ' PrefixI ' True ) ( S1 (' MetaSel (' Just "hardForkConsensusConfigK") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 SecurityParam ) :: ( S1 (' MetaSel (' Just "hardForkConsensusConfigShape") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( Shape xs)) :: S1 (' MetaSel (' Just "hardForkConsensusConfigPerEra") ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( PerEraConsensusConfig xs)))))
type ChainDepState ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type ChainDepState ( HardForkProtocol xs) = HardForkChainDepState xs
type IsLeader ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type IsLeader ( HardForkProtocol xs) = HardForkIsLeader xs
type CanBeLeader ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type CanBeLeader ( HardForkProtocol xs) = HardForkCanBeLeader xs
type SelectView ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type SelectView ( HardForkProtocol xs)
type LedgerView ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type LedgerView ( HardForkProtocol xs) = HardForkLedgerView xs
type ValidationErr ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type ValidationErr ( HardForkProtocol xs) = HardForkValidationErr xs
type ValidateView ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type ValidateView ( HardForkProtocol xs) = OneEraValidateView xs
data ConsensusConfig ( HardForkProtocol xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Basics data ConsensusConfig ( HardForkProtocol xs) = HardForkConsensusConfig { hardForkConsensusConfigK :: ! SecurityParam hardForkConsensusConfigShape :: !( Shape xs) hardForkConsensusConfigPerEra :: !( PerEraConsensusConfig xs) }

completeLedgerConfig' :: forall blk. HasPartialLedgerConfig blk => EpochInfo ( Except PastHorizonException ) -> WrapPartialLedgerConfig blk -> LedgerConfig blk Source #

completeLedgerConfig'' :: forall blk. HasPartialLedgerConfig blk => EpochInfo ( Except PastHorizonException ) -> WrapPartialLedgerConfig blk -> WrapLedgerConfig blk Source #

completeConsensusConfig' :: forall blk. HasPartialConsensusConfig ( BlockProtocol blk) => EpochInfo ( Except PastHorizonException ) -> WrapPartialConsensusConfig blk -> ConsensusConfig ( BlockProtocol blk) Source #

completeConsensusConfig'' :: forall blk. HasPartialConsensusConfig ( BlockProtocol blk) => EpochInfo ( Except PastHorizonException ) -> WrapPartialConsensusConfig blk -> WrapConsensusConfig blk Source #

distribLedgerConfig :: CanHardFork xs => EpochInfo ( Except PastHorizonException ) -> LedgerConfig ( HardForkBlock xs) -> NP WrapLedgerConfig xs Source #

distribTopLevelConfig :: All SingleEraBlock xs => EpochInfo ( Except PastHorizonException ) -> TopLevelConfig ( HardForkBlock xs) -> NP TopLevelConfig xs Source #

distribAnnTip :: SListI xs => AnnTip ( HardForkBlock xs) -> NS AnnTip xs Source #

undistribAnnTip :: SListI xs => NS AnnTip xs -> AnnTip ( HardForkBlock xs) Source #

data HardForkValidationErr xs Source #

Constructors

HardForkValidationErrFromEra ( OneEraValidationErr xs)	Validation error from one of the eras
HardForkValidationErrWrongEra ( MismatchEraInfo xs)	We tried to apply a block from the wrong era

Instances

Instances details

CanHardFork xs => Eq ( HardForkValidationErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Methods (==) :: HardForkValidationErr xs -> HardForkValidationErr xs -> Bool Source # (/=) :: HardForkValidationErr xs -> HardForkValidationErr xs -> Bool Source #
CanHardFork xs => Show ( HardForkValidationErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Methods showsPrec :: Int -> HardForkValidationErr xs -> ShowS Source # show :: HardForkValidationErr xs -> String Source # showList :: [ HardForkValidationErr xs] -> ShowS Source #
Generic ( HardForkValidationErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Associated Types type Rep ( HardForkValidationErr xs) :: Type -> Type Source # Methods from :: HardForkValidationErr xs -> Rep ( HardForkValidationErr xs) x Source # to :: Rep ( HardForkValidationErr xs) x -> HardForkValidationErr xs Source #
CanHardFork xs => NoThunks ( HardForkValidationErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol Methods noThunks :: Context -> HardForkValidationErr xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> HardForkValidationErr xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( HardForkValidationErr xs) -> String Source #
type Rep ( HardForkValidationErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Protocol type Rep ( HardForkValidationErr xs) = D1 (' MetaData "HardForkValidationErr" "Ouroboros.Consensus.HardFork.Combinator.Protocol" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkValidationErrFromEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraValidationErr xs))) :+: C1 (' MetaCons "HardForkValidationErrWrongEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( MismatchEraInfo xs))))

type HardForkCanBeLeader xs = SomeErasCanBeLeader xs Source #

We have one or more BlockForging s, and thus CanBeLeader proofs, for each era in which we can forge blocks.

type HardForkIsLeader xs = OneEraIsLeader xs Source #

We are a leader if we have a proof from one of the eras

type HardForkChainDepState xs = HardForkState WrapChainDepState xs Source #

data HardForkLedgerUpdate xs Source #

Constructors

HardForkUpdateInEra ( OneEraLedgerUpdate xs)
HardForkUpdateTransitionConfirmed ( EraIndex xs) ( EraIndex xs) EpochNo	Hard fork transition got confirmed
HardForkUpdateTransitionDone ( EraIndex xs) ( EraIndex xs) EpochNo	Hard fork transition happened We record the `EpochNo` at the start of the era after the transition
HardForkUpdateTransitionRolledBack ( EraIndex xs) ( EraIndex xs)	The hard fork transition rolled back

Instances

Instances details

CanHardFork xs => Eq ( HardForkLedgerUpdate xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods (==) :: HardForkLedgerUpdate xs -> HardForkLedgerUpdate xs -> Bool Source # (/=) :: HardForkLedgerUpdate xs -> HardForkLedgerUpdate xs -> Bool Source #
CanHardFork xs => Show ( HardForkLedgerUpdate xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods showsPrec :: Int -> HardForkLedgerUpdate xs -> ShowS Source # show :: HardForkLedgerUpdate xs -> String Source # showList :: [ HardForkLedgerUpdate xs] -> ShowS Source #
CanHardFork xs => Condense ( HardForkLedgerUpdate xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods condense :: HardForkLedgerUpdate xs -> String Source #

data HardForkLedgerWarning xs Source #

Constructors

HardForkWarningInEra ( OneEraLedgerWarning xs)	Warning from the underlying era
HardForkWarningTransitionMismatch ( EraIndex xs) EraParams EpochNo	The transition to the next era does not match the `EraParams` The `EraParams` can specify a lower bound on when the transition to the next era will happen. If the actual transition, when confirmed, is before this lower bound, the node is misconfigured and will likely not work correctly. This should be taken care of as soon as possible (before the transition happens).
HardForkWarningTransitionInFinalEra ( EraIndex xs) EpochNo	Transition in the final era The final era should never confirm any transitions. For clarity, we also record the index of that final era.
HardForkWarningTransitionUnconfirmed ( EraIndex xs)	An already-confirmed transition got un-confirmed
HardForkWarningTransitionReconfirmed ( EraIndex xs) ( EraIndex xs) EpochNo EpochNo	An already-confirmed transition got changed We record the indices of the era we are transitioning from and to, as well as the old and new `EpochNo` of that transition, in that order.

Instances

Instances details

CanHardFork xs => Eq ( HardForkLedgerWarning xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods (==) :: HardForkLedgerWarning xs -> HardForkLedgerWarning xs -> Bool Source # (/=) :: HardForkLedgerWarning xs -> HardForkLedgerWarning xs -> Bool Source #
CanHardFork xs => Show ( HardForkLedgerWarning xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods showsPrec :: Int -> HardForkLedgerWarning xs -> ShowS Source # show :: HardForkLedgerWarning xs -> String Source # showList :: [ HardForkLedgerWarning xs] -> ShowS Source #

data AnnForecast state view blk Source #

Forecast annotated with details about the ledger it was derived from

Constructors

AnnForecast
Fields annForecast :: Forecast (view blk) annForecastState :: state blk annForecastTip :: WithOrigin SlotNo annForecastEnd :: Maybe Bound

data HardForkEnvelopeErr xs Source #

Constructors

HardForkEnvelopeErrFromEra ( OneEraEnvelopeErr xs)	Validation error from one of the eras
HardForkEnvelopeErrWrongEra ( MismatchEraInfo xs)	We tried to apply a block from the wrong era

Instances

Instances details

CanHardFork xs => Eq ( HardForkEnvelopeErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods (==) :: HardForkEnvelopeErr xs -> HardForkEnvelopeErr xs -> Bool Source # (/=) :: HardForkEnvelopeErr xs -> HardForkEnvelopeErr xs -> Bool Source #
CanHardFork xs => Show ( HardForkEnvelopeErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods showsPrec :: Int -> HardForkEnvelopeErr xs -> ShowS Source # show :: HardForkEnvelopeErr xs -> String Source # showList :: [ HardForkEnvelopeErr xs] -> ShowS Source #
Generic ( HardForkEnvelopeErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type Rep ( HardForkEnvelopeErr xs) :: Type -> Type Source # Methods from :: HardForkEnvelopeErr xs -> Rep ( HardForkEnvelopeErr xs) x Source # to :: Rep ( HardForkEnvelopeErr xs) x -> HardForkEnvelopeErr xs Source #
CanHardFork xs => NoThunks ( HardForkEnvelopeErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods noThunks :: Context -> HardForkEnvelopeErr xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> HardForkEnvelopeErr xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( HardForkEnvelopeErr xs) -> String Source #
type Rep ( HardForkEnvelopeErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type Rep ( HardForkEnvelopeErr xs) = D1 (' MetaData "HardForkEnvelopeErr" "Ouroboros.Consensus.HardFork.Combinator.Ledger" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkEnvelopeErrFromEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraEnvelopeErr xs))) :+: C1 (' MetaCons "HardForkEnvelopeErrWrongEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( MismatchEraInfo xs))))

data HardForkLedgerError xs Source #

Constructors

HardForkLedgerErrorFromEra ( OneEraLedgerError xs)	Validation error from one of the eras
HardForkLedgerErrorWrongEra ( MismatchEraInfo xs)	We tried to apply a block from the wrong era

Instances

Instances details

CanHardFork xs => Eq ( HardForkLedgerError xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods (==) :: HardForkLedgerError xs -> HardForkLedgerError xs -> Bool Source # (/=) :: HardForkLedgerError xs -> HardForkLedgerError xs -> Bool Source #
CanHardFork xs => Show ( HardForkLedgerError xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods showsPrec :: Int -> HardForkLedgerError xs -> ShowS Source # show :: HardForkLedgerError xs -> String Source # showList :: [ HardForkLedgerError xs] -> ShowS Source #
Generic ( HardForkLedgerError xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Associated Types type Rep ( HardForkLedgerError xs) :: Type -> Type Source # Methods from :: HardForkLedgerError xs -> Rep ( HardForkLedgerError xs) x Source # to :: Rep ( HardForkLedgerError xs) x -> HardForkLedgerError xs Source #
CanHardFork xs => NoThunks ( HardForkLedgerError xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger Methods noThunks :: Context -> HardForkLedgerError xs -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> HardForkLedgerError xs -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( HardForkLedgerError xs) -> String Source #
type Rep ( HardForkLedgerError xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger type Rep ( HardForkLedgerError xs) = D1 (' MetaData "HardForkLedgerError" "Ouroboros.Consensus.HardFork.Combinator.Ledger" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkLedgerErrorFromEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( OneEraLedgerError xs))) :+: C1 (' MetaCons "HardForkLedgerErrorWrongEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' NoSourceStrictness ' DecidedLazy ) ( Rec0 ( MismatchEraInfo xs))))

mkHardForkForecast :: forall state view xs. SListI xs => InPairs ( TranslateForecast state view) xs -> HardForkState ( AnnForecast state view) xs -> Forecast ( HardForkLedgerView_ view xs) Source #

Change a telescope of a forecast into a forecast of a telescope

data HardForkApplyTxErr xs Source #

Constructors

HardForkApplyTxErrFromEra !( OneEraApplyTxErr xs)	Validation error from one of the eras
HardForkApplyTxErrWrongEra !( MismatchEraInfo xs)	We tried to apply a block from the wrong era

Instances

Instances details

CanHardFork xs => Eq ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods (==) :: HardForkApplyTxErr xs -> HardForkApplyTxErr xs -> Bool Source # (/=) :: HardForkApplyTxErr xs -> HardForkApplyTxErr xs -> Bool Source #
CanHardFork xs => Show ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showsPrec :: Int -> HardForkApplyTxErr xs -> ShowS Source # show :: HardForkApplyTxErr xs -> String Source # showList :: [ HardForkApplyTxErr xs] -> ShowS Source #
Generic ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Associated Types type Rep ( HardForkApplyTxErr xs) :: Type -> Type Source # Methods from :: HardForkApplyTxErr xs -> Rep ( HardForkApplyTxErr xs) x Source # to :: Rep ( HardForkApplyTxErr xs) x -> HardForkApplyTxErr xs Source #
Typeable xs => ShowProxy ( HardForkApplyTxErr xs :: Type ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool Methods showProxy :: Proxy ( HardForkApplyTxErr xs) -> String Source #
SerialiseHFC xs => SerialiseNodeToClient ( HardForkBlock xs) ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Serialisation.SerialiseNodeToClient Methods encodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> HardForkApplyTxErr xs -> Encoding Source # decodeNodeToClient :: CodecConfig ( HardForkBlock xs) -> BlockNodeToClientVersion ( HardForkBlock xs) -> forall s. Decoder s ( HardForkApplyTxErr xs) Source #
type Rep ( HardForkApplyTxErr xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Mempool type Rep ( HardForkApplyTxErr xs) = D1 (' MetaData "HardForkApplyTxErr" "Ouroboros.Consensus.HardFork.Combinator.Mempool" "ouroboros-consensus-0.1.0.1-DT4Cvwf63DZKctsEvaJqCU" ' False ) ( C1 (' MetaCons "HardForkApplyTxErrFromEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( OneEraApplyTxErr xs))) :+: C1 (' MetaCons "HardForkApplyTxErrWrongEra" ' PrefixI ' False ) ( S1 (' MetaSel (' Nothing :: Maybe Symbol ) ' NoSourceUnpackedness ' SourceStrict ' DecidedStrict ) ( Rec0 ( MismatchEraInfo xs))))

hardForkApplyTxErrToEither :: HardForkApplyTxErr xs -> Either ( MismatchEraInfo xs) ( OneEraApplyTxErr xs) Source #

hardForkApplyTxErrFromEither :: Either ( MismatchEraInfo xs) ( OneEraApplyTxErr xs) -> HardForkApplyTxErr xs Source #

data QueryHardFork xs result where Source #

Constructors

GetInterpreter :: QueryHardFork xs ( Interpreter xs)
GetCurrentEra :: QueryHardFork xs ( EraIndex xs)

Instances

Instances details

All SingleEraBlock xs => ShowQuery ( QueryHardFork xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showResult :: QueryHardFork xs result -> result -> String Source #
SameDepIndex ( QueryHardFork xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods sameDepIndex :: QueryHardFork xs a -> QueryHardFork xs b -> Maybe (a :~: b) Source #
Show ( QueryHardFork xs result) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showsPrec :: Int -> QueryHardFork xs result -> ShowS Source # show :: QueryHardFork xs result -> String Source # showList :: [ QueryHardFork xs result] -> ShowS Source #

data QueryAnytime result where Source #

Constructors

GetEraStart :: QueryAnytime ( Maybe Bound )

Instances

Instances details

ShowQuery QueryAnytime Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showResult :: QueryAnytime result -> result -> String Source #
SameDepIndex QueryAnytime Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods sameDepIndex :: QueryAnytime a -> QueryAnytime b -> Maybe (a :~: b) Source #
Show ( QueryAnytime result) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showsPrec :: Int -> QueryAnytime result -> ShowS Source # show :: QueryAnytime result -> String Source # showList :: [ QueryAnytime result] -> ShowS Source #
Serialise ( Some QueryAnytime ) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods encode :: Some QueryAnytime -> Encoding Source # decode :: Decoder s ( Some QueryAnytime ) Source # encodeList :: [ Some QueryAnytime ] -> Encoding Source # decodeList :: Decoder s [ Some QueryAnytime ] Source #

data QueryIfCurrent :: [ Type ] -> Type -> Type where Source #

Constructors

QZ :: BlockQuery x result -> QueryIfCurrent (x ': xs) result
QS :: QueryIfCurrent xs result -> QueryIfCurrent (x ': xs) result

Instances

Instances details

All SingleEraBlock xs => ShowQuery ( QueryIfCurrent xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showResult :: QueryIfCurrent xs result -> result -> String Source #
All SingleEraBlock xs => SameDepIndex ( QueryIfCurrent xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods sameDepIndex :: QueryIfCurrent xs a -> QueryIfCurrent xs b -> Maybe (a :~: b) Source #
All SingleEraBlock xs => Show ( QueryIfCurrent xs result) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Ledger.Query Methods showsPrec :: Int -> QueryIfCurrent xs result -> ShowS Source # show :: QueryIfCurrent xs result -> String Source # showList :: [ QueryIfCurrent xs result] -> ShowS Source #

type HardForkQueryResult xs = Either ( MismatchEraInfo xs) Source #

getHardForkQuery :: BlockQuery ( HardForkBlock xs) result -> ( forall result'. (result :~: HardForkQueryResult xs result') -> QueryIfCurrent xs result' -> r) -> ( forall x' xs'. (xs :~: (x' ': xs')) -> ProofNonEmpty xs' -> QueryAnytime result -> EraIndex xs -> r) -> ( forall x' xs'. (xs :~: (x' ': xs')) -> ProofNonEmpty xs' -> QueryHardFork xs result -> r) -> r Source #

encodeQueryAnytimeResult :: QueryAnytime result -> result -> Encoding Source #

decodeQueryAnytimeResult :: QueryAnytime result -> forall s. Decoder s result Source #

encodeQueryHardForkResult :: SListI xs => QueryHardFork xs result -> result -> Encoding Source #

decodeQueryHardForkResult :: SListI xs => QueryHardFork xs result -> forall s. Decoder s result Source #

hardForkQueryInfo :: All SingleEraBlock xs => QueryIfCurrent xs result -> NS SingleEraInfo xs Source #

data HardForkForgeStateInfo xs where Source #

For each era in which we want to forge blocks, we have a BlockForging , and thus ForgeStateInfo .

When we update the hard fork forge state, we only update the forge state of the current era. However, the current era might not have a forge state as it lacks a BlockForging .

TODO #2766: expire past ForgeState

Constructors

CurrentEraLacksBlockForging :: EraIndex (x ': (y ': xs)) -> HardForkForgeStateInfo (x ': (y ': xs))	There is no `BlockForging` record for the current era.
CurrentEraForgeStateUpdated :: OneEraForgeStateInfo xs -> HardForkForgeStateInfo xs	The `ForgeState` of the current era was updated.

Instances

Instances details

CanHardFork xs => Show ( HardForkForgeStateInfo xs) Source #
Instance details Defined in Ouroboros.Consensus.HardFork.Combinator.Forging Methods showsPrec :: Int -> HardForkForgeStateInfo xs -> ShowS Source # show :: HardForkForgeStateInfo xs -> String Source # showList :: [ HardForkForgeStateInfo xs] -> ShowS Source #

hardForkBlockForging Source #

Arguments

:: forall m xs. ( CanHardFork xs, Monad m)
=> Text	Used as the `forgeLabel` , the labels of the given `BlockForging` s will be ignored.
-> NonEmptyOptNP ( BlockForging m) xs
-> BlockForging m ( HardForkBlock xs)