{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}

module Cardano.Api.LedgerEvents.ConvertLedgerEvent
  ( LedgerEvent (..)
  , toLedgerEvent
  )
where

import           Cardano.Api.LedgerEvents.LedgerEvent
import           Cardano.Api.LedgerEvents.Rule.BBODY.DELEGS
import           Cardano.Api.LedgerEvents.Rule.BBODY.LEDGER
import           Cardano.Api.LedgerEvents.Rule.BBODY.UTXOW
import           Cardano.Api.LedgerEvents.Rule.TICK.NEWEPOCH
import           Cardano.Api.LedgerEvents.Rule.TICK.RUPD

import qualified Cardano.Ledger.Allegra.Rules as Allegra
import           Cardano.Ledger.Alonzo.Rules (AlonzoBbodyEvent (..))
import           Cardano.Ledger.Api.Era (AllegraEra, AlonzoEra, BabbageEra, ConwayEra, MaryEra,
                   ShelleyEra)
import qualified Cardano.Ledger.Conway.Rules as Conway
import           Cardano.Ledger.Core
import qualified Cardano.Ledger.Core as Ledger.Core
import           Cardano.Ledger.Crypto (StandardCrypto)
import           Cardano.Ledger.Shelley.Rules (RupdEvent (..), ShelleyBbodyEvent (LedgersEvent),
                   ShelleyNewEpochEvent (..), ShelleyTickEvent (TickNewEpochEvent, TickRupdEvent),
                   ShelleyUtxowEvent (..))
import qualified Cardano.Ledger.Shelley.Rules as Shelley
import           Ouroboros.Consensus.Byron.Ledger.Block (ByronBlock)
import           Ouroboros.Consensus.Cardano.Block (HardForkBlock)
import qualified Ouroboros.Consensus.Cardano.Block as Consensus
import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (getOneEraLedgerEvent)
import qualified Ouroboros.Consensus.Protocol.Praos as Consensus
import qualified Ouroboros.Consensus.Protocol.TPraos as Consensus
import           Ouroboros.Consensus.Shelley.Ledger (ShelleyBlock,
                   ShelleyLedgerEvent (ShelleyLedgerEventBBODY, ShelleyLedgerEventTICK))
import           Ouroboros.Consensus.TypeFamilyWrappers (WrapLedgerEvent (unwrapLedgerEvent))

import           Control.State.Transition (Event)
import           Data.SOP.Strict

class ConvertLedgerEvent blk where
  toLedgerEvent :: WrapLedgerEvent blk -> Maybe LedgerEvent

instance ConvertLedgerEvent ByronBlock where
  toLedgerEvent :: WrapLedgerEvent ByronBlock -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent ByronBlock
_ = Maybe LedgerEvent
forall a. Maybe a
Nothing

instance ConvertLedgerEvent (ShelleyBlock protocol (ShelleyEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (ShelleyEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (ShelleyEra StandardCrypto))
-> Maybe LedgerEvent
forall ledgerera protocol.
(EraCrypto ledgerera ~ StandardCrypto,
 Event (EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera,
 Event (EraRule "NEWEPOCH" ledgerera)
 ~ ShelleyNewEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ShelleyEpochEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto,
 Event (EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera,
 Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ UtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toLedgerEventShelley

toLedgerEventShelley
  :: EraCrypto ledgerera ~ StandardCrypto
  => Event (Ledger.Core.EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera
  => Event (Ledger.Core.EraRule "NEWEPOCH" ledgerera) ~ ShelleyNewEpochEvent ledgerera
  => Event (Ledger.Core.EraRule "POOLREAP" ledgerera) ~ Shelley.ShelleyPoolreapEvent ledgerera
  => Event (Ledger.Core.EraRule "EPOCH" ledgerera) ~ Shelley.ShelleyEpochEvent ledgerera
  => Event (Ledger.Core.EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto
  => Event (Ledger.Core.EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGERS" ledgerera) ~ Shelley.ShelleyLedgersEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGER" ledgerera) ~ Shelley.ShelleyLedgerEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXO" ledgerera) ~ Shelley.UtxoEvent ledgerera
  => Event (Ledger.Core.EraRule "PPUP" ledgerera) ~ Shelley.PpupEvent ledgerera
  => Event (EraRule "DELEGS" ledgerera) ~ Shelley.ShelleyDelegsEvent ledgerera
  => WrapLedgerEvent (ShelleyBlock protocol ledgerera) -> Maybe LedgerEvent
toLedgerEventShelley :: forall ledgerera protocol.
(EraCrypto ledgerera ~ StandardCrypto,
 Event (EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera,
 Event (EraRule "NEWEPOCH" ledgerera)
 ~ ShelleyNewEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ShelleyEpochEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto,
 Event (EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera,
 Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ UtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toLedgerEventShelley WrapLedgerEvent (ShelleyBlock protocol ledgerera)
evt = case WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> AuxLedgerEvent (LedgerState (ShelleyBlock protocol ledgerera))
forall blk. WrapLedgerEvent blk -> AuxLedgerEvent (LedgerState blk)
unwrapLedgerEvent WrapLedgerEvent (ShelleyBlock protocol ledgerera)
evt of
  ShelleyLedgerEventTICK Event (EraRule "TICK" ledgerera)
e -> ShelleyTickEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(EraCrypto ledgerera ~ StandardCrypto,
 LatestTickEventConstraints ledgerera) =>
ShelleyTickEvent ledgerera -> Maybe LedgerEvent
handleLedgerTICKEvents Event (EraRule "TICK" ledgerera)
ShelleyTickEvent ledgerera
e
  ShelleyLedgerEventBBODY Event (EraRule "BBODY" ledgerera)
e -> ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ UtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleShelleyLedgerBBODYEvents Event (EraRule "BBODY" ledgerera)
ShelleyBbodyEvent ledgerera
e

handleShelleyLedgerBBODYEvents
  :: Event (Ledger.Core.EraRule "LEDGERS" ledgerera) ~ Shelley.ShelleyLedgersEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGER" ledgerera) ~ Shelley.ShelleyLedgerEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXO" ledgerera) ~ Shelley.UtxoEvent ledgerera
  => Event (Ledger.Core.EraRule "PPUP" ledgerera) ~ Shelley.PpupEvent ledgerera
  => Event (EraRule "DELEGS" ledgerera) ~ Shelley.ShelleyDelegsEvent ledgerera
  => ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleShelleyLedgerBBODYEvents :: forall ledgerera.
(Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ UtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleShelleyLedgerBBODYEvents (LedgersEvent (Shelley.LedgerEvent Event (EraRule "LEDGER" ledgerera)
e)) =
  case Event (EraRule "LEDGER" ledgerera)
e of
    Shelley.UtxowEvent Event (EraRule "UTXOW" ledgerera)
ev -> ShelleyUtxowEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(Event (EraRule "UTXO" ledgerera) ~ UtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera) =>
ShelleyUtxowEvent ledgerera -> Maybe LedgerEvent
handlePreAlonzoUTxOWEvent Event (EraRule "UTXOW" ledgerera)
ShelleyUtxowEvent ledgerera
ev
    Shelley.DelegsEvent Event (EraRule "DELEGS" ledgerera)
ev -> ShelleyDelegsEvent ledgerera -> Maybe LedgerEvent
forall ledgerera. ShelleyDelegsEvent ledgerera -> Maybe LedgerEvent
handleShelleyDELEGSEvent Event (EraRule "DELEGS" ledgerera)
ShelleyDelegsEvent ledgerera
ev

instance ConvertLedgerEvent (ShelleyBlock protocol (MaryEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (MaryEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (MaryEra StandardCrypto))
-> Maybe LedgerEvent
forall ledgerera protocol.
(EraCrypto ledgerera ~ StandardCrypto,
 Event (EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera,
 Event (EraRule "NEWEPOCH" ledgerera)
 ~ ShelleyNewEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ShelleyEpochEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto,
 Event (EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera,
 Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toLedgerEventAllegraMary

instance ConvertLedgerEvent (ShelleyBlock protocol (AllegraEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (AllegraEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (AllegraEra StandardCrypto))
-> Maybe LedgerEvent
forall ledgerera protocol.
(EraCrypto ledgerera ~ StandardCrypto,
 Event (EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera,
 Event (EraRule "NEWEPOCH" ledgerera)
 ~ ShelleyNewEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ShelleyEpochEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto,
 Event (EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera,
 Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toLedgerEventAllegraMary

toLedgerEventAllegraMary
  :: EraCrypto ledgerera ~ StandardCrypto
  => Event (Ledger.Core.EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera
  => Event (Ledger.Core.EraRule "NEWEPOCH" ledgerera) ~ ShelleyNewEpochEvent ledgerera
  => Event (Ledger.Core.EraRule "POOLREAP" ledgerera) ~ Shelley.ShelleyPoolreapEvent ledgerera
  => Event (Ledger.Core.EraRule "EPOCH" ledgerera) ~ Shelley.ShelleyEpochEvent ledgerera
  => Event (Ledger.Core.EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto
  => Event (Ledger.Core.EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGERS" ledgerera) ~ Shelley.ShelleyLedgersEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGER" ledgerera) ~ Shelley.ShelleyLedgerEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXO" ledgerera) ~ Allegra.AllegraUtxoEvent ledgerera
  => Event (Ledger.Core.EraRule "PPUP" ledgerera) ~ Shelley.PpupEvent ledgerera
  => Event (Ledger.Core.EraRule "DELEGS" ledgerera) ~ Shelley.ShelleyDelegsEvent ledgerera
  => WrapLedgerEvent (ShelleyBlock protocol ledgerera)
  -> Maybe LedgerEvent
toLedgerEventAllegraMary :: forall ledgerera protocol.
(EraCrypto ledgerera ~ StandardCrypto,
 Event (EraRule "TICK" ledgerera) ~ ShelleyTickEvent ledgerera,
 Event (EraRule "NEWEPOCH" ledgerera)
 ~ ShelleyNewEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ShelleyEpochEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto,
 Event (EraRule "BBODY" ledgerera) ~ ShelleyBbodyEvent ledgerera,
 Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toLedgerEventAllegraMary WrapLedgerEvent (ShelleyBlock protocol ledgerera)
evt = case WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> AuxLedgerEvent (LedgerState (ShelleyBlock protocol ledgerera))
forall blk. WrapLedgerEvent blk -> AuxLedgerEvent (LedgerState blk)
unwrapLedgerEvent WrapLedgerEvent (ShelleyBlock protocol ledgerera)
evt of
  ShelleyLedgerEventTICK Event (EraRule "TICK" ledgerera)
e -> ShelleyTickEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(EraCrypto ledgerera ~ StandardCrypto,
 LatestTickEventConstraints ledgerera) =>
ShelleyTickEvent ledgerera -> Maybe LedgerEvent
handleLedgerTICKEvents Event (EraRule "TICK" ledgerera)
ShelleyTickEvent ledgerera
e
  ShelleyLedgerEventBBODY Event (EraRule "BBODY" ledgerera)
e -> ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleAllegraMaryLedgerBBODYEvents Event (EraRule "BBODY" ledgerera)
ShelleyBbodyEvent ledgerera
e

handleAllegraMaryLedgerBBODYEvents
  :: Event (Ledger.Core.EraRule "LEDGERS" ledgerera) ~ Shelley.ShelleyLedgersEvent ledgerera
  => Event (Ledger.Core.EraRule "LEDGER" ledgerera) ~ Shelley.ShelleyLedgerEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera
  => Event (Ledger.Core.EraRule "UTXO" ledgerera) ~ Allegra.AllegraUtxoEvent ledgerera
  => Event (Ledger.Core.EraRule "PPUP" ledgerera) ~ Shelley.PpupEvent ledgerera
  => Event (Ledger.Core.EraRule "DELEGS" ledgerera) ~ Shelley.ShelleyDelegsEvent ledgerera
  => ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleAllegraMaryLedgerBBODYEvents :: forall ledgerera.
(Event (EraRule "LEDGERS" ledgerera)
 ~ ShelleyLedgersEvent ledgerera,
 Event (EraRule "LEDGER" ledgerera) ~ ShelleyLedgerEvent ledgerera,
 Event (EraRule "UTXOW" ledgerera) ~ ShelleyUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera)
 ~ ShelleyDelegsEvent ledgerera) =>
ShelleyBbodyEvent ledgerera -> Maybe LedgerEvent
handleAllegraMaryLedgerBBODYEvents (LedgersEvent (Shelley.LedgerEvent Event (EraRule "LEDGER" ledgerera)
e)) =
  case Event (EraRule "LEDGER" ledgerera)
e of
    Shelley.UtxowEvent Event (EraRule "UTXOW" ledgerera)
ev -> ShelleyUtxowEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(Event (EraRule "UTXO" ledgerera) ~ AllegraUtxoEvent ledgerera,
 Event (EraRule "PPUP" ledgerera) ~ PpupEvent ledgerera) =>
ShelleyUtxowEvent ledgerera -> Maybe LedgerEvent
handleAllegraMaryUTxOWEvent Event (EraRule "UTXOW" ledgerera)
ShelleyUtxowEvent ledgerera
ev
    Shelley.DelegsEvent Event (EraRule "DELEGS" ledgerera)
ev -> ShelleyDelegsEvent ledgerera -> Maybe LedgerEvent
forall ledgerera. ShelleyDelegsEvent ledgerera -> Maybe LedgerEvent
handleShelleyDELEGSEvent Event (EraRule "DELEGS" ledgerera)
ShelleyDelegsEvent ledgerera
ev

instance ConvertLedgerEvent (ShelleyBlock protocol (AlonzoEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (AlonzoEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (AlonzoEra StandardCrypto))
-> Maybe LedgerEvent
forall ledgerera protocol.
(LatestTickEventConstraints ledgerera,
 LatestBBodyEventConstraints ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toAlonzoOrBabbageLedgerEvents

instance ConvertLedgerEvent (ShelleyBlock protocol (BabbageEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (BabbageEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (BabbageEra StandardCrypto))
-> Maybe LedgerEvent
forall ledgerera protocol.
(LatestTickEventConstraints ledgerera,
 LatestBBodyEventConstraints ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toAlonzoOrBabbageLedgerEvents

toAlonzoOrBabbageLedgerEvents
  :: LatestTickEventConstraints ledgerera
  => LatestBBodyEventConstraints ledgerera
  => EraCrypto ledgerera ~ StandardCrypto
  => WrapLedgerEvent (ShelleyBlock protocol ledgerera) -> Maybe LedgerEvent
toAlonzoOrBabbageLedgerEvents :: forall ledgerera protocol.
(LatestTickEventConstraints ledgerera,
 LatestBBodyEventConstraints ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> Maybe LedgerEvent
toAlonzoOrBabbageLedgerEvents WrapLedgerEvent (ShelleyBlock protocol ledgerera)
e =
  case WrapLedgerEvent (ShelleyBlock protocol ledgerera)
-> AuxLedgerEvent (LedgerState (ShelleyBlock protocol ledgerera))
forall blk. WrapLedgerEvent blk -> AuxLedgerEvent (LedgerState blk)
unwrapLedgerEvent WrapLedgerEvent (ShelleyBlock protocol ledgerera)
e of
    ShelleyLedgerEventTICK Event (EraRule "TICK" ledgerera)
tickEvent -> ShelleyTickEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(EraCrypto ledgerera ~ StandardCrypto,
 LatestTickEventConstraints ledgerera) =>
ShelleyTickEvent ledgerera -> Maybe LedgerEvent
handleLedgerTICKEvents Event (EraRule "TICK" ledgerera)
ShelleyTickEvent ledgerera
tickEvent
    ShelleyLedgerEventBBODY Event (EraRule "BBODY" ledgerera)
bbodyEvent -> AlonzoBbodyEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(LatestBBodyEventConstraints ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
AlonzoBbodyEvent ledgerera -> Maybe LedgerEvent
handleAlonzoToBabbageLedgerBBODYEvents AlonzoBbodyEvent ledgerera
Event (EraRule "BBODY" ledgerera)
bbodyEvent

handleAlonzoToBabbageLedgerBBODYEvents
  :: LatestBBodyEventConstraints ledgerera
  => EraCrypto ledgerera ~ StandardCrypto
  => AlonzoBbodyEvent ledgerera -> Maybe LedgerEvent
handleAlonzoToBabbageLedgerBBODYEvents :: forall ledgerera.
(LatestBBodyEventConstraints ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
AlonzoBbodyEvent ledgerera -> Maybe LedgerEvent
handleAlonzoToBabbageLedgerBBODYEvents (ShelleyInAlonzoEvent (LedgersEvent (Shelley.LedgerEvent Event (EraRule "LEDGER" ledgerera)
ledgerEvent))) =
  ShelleyLedgerEvent ledgerera -> Maybe LedgerEvent
forall ledgerera.
(Event (EraRule "UTXOW" ledgerera) ~ AlonzoUtxowEvent ledgerera,
 Event (EraRule "UTXO" ledgerera) ~ AlonzoUtxoEvent ledgerera,
 Event (EraRule "UTXOS" ledgerera) ~ AlonzoUtxosEvent ledgerera,
 Event (EraRule "DELEGS" ledgerera) ~ ShelleyDelegsEvent ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
ShelleyLedgerEvent ledgerera -> Maybe LedgerEvent
handleShelleyLEDGEREvents Event (EraRule "LEDGER" ledgerera)
ShelleyLedgerEvent ledgerera
ledgerEvent

instance ConvertLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent = WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
-> Maybe LedgerEvent
forall protocol.
WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEventConway

-- LEDGER rule is defined anew in Conway

toLedgerEventConway
  :: WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
  -> Maybe LedgerEvent
toLedgerEventConway :: forall protocol.
WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
-> Maybe LedgerEvent
toLedgerEventConway WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
evt =
  case WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
-> AuxLedgerEvent
     (LedgerState (ShelleyBlock protocol (ConwayEra StandardCrypto)))
forall blk. WrapLedgerEvent blk -> AuxLedgerEvent (LedgerState blk)
unwrapLedgerEvent WrapLedgerEvent (ShelleyBlock protocol (ConwayEra StandardCrypto))
evt of
    ShelleyLedgerEventTICK (TickNewEpochEvent Event (EraRule "NEWEPOCH" (ConwayEra StandardCrypto))
newEpochEvent) -> ConwayNewEpochEvent (ConwayEra StandardCrypto) -> Maybe LedgerEvent
forall ledgerera.
(EraCrypto ledgerera ~ StandardCrypto, EraPParams ledgerera,
 Event (EraRule "EPOCH" ledgerera) ~ ConwayEpochEvent ledgerera,
 Event (EraRule "POOLREAP" ledgerera)
 ~ ShelleyPoolreapEvent ledgerera,
 Event (EraRule "RUPD" ledgerera) ~ RupdEvent StandardCrypto) =>
ConwayNewEpochEvent ledgerera -> Maybe LedgerEvent
handleConwayNEWEPOCHEvents ConwayNewEpochEvent (ConwayEra StandardCrypto)
Event (EraRule "NEWEPOCH" (ConwayEra StandardCrypto))
newEpochEvent
    ShelleyLedgerEventTICK (TickRupdEvent Event (EraRule "RUPD" (ConwayEra StandardCrypto))
rewardUpdate) -> RupdEvent StandardCrypto -> Maybe LedgerEvent
handleLedgerRUPDEvents Event (EraRule "RUPD" (ConwayEra StandardCrypto))
RupdEvent StandardCrypto
rewardUpdate
    ShelleyLedgerEventBBODY
      (ShelleyInAlonzoEvent (LedgersEvent (Shelley.LedgerEvent Event (EraRule "LEDGER" (ConwayEra StandardCrypto))
conwayLedgerEvent))) ->
        case Event (EraRule "LEDGER" (ConwayEra StandardCrypto))
conwayLedgerEvent of
          Conway.UtxowEvent{} -> Maybe LedgerEvent
forall a. Maybe a
Nothing
          Conway.CertsEvent{} -> Maybe LedgerEvent
forall a. Maybe a
Nothing
          Conway.GovEvent Event (EraRule "GOV" (ConwayEra StandardCrypto))
govEvent ->
            case Event (EraRule "GOV" (ConwayEra StandardCrypto))
govEvent of
              Conway.GovNewProposals TxId (EraCrypto (ConwayEra StandardCrypto))
txid Proposals (ConwayEra StandardCrypto)
props ->
                LedgerEvent -> Maybe LedgerEvent
forall a. a -> Maybe a
Just (LedgerEvent -> Maybe LedgerEvent)
-> LedgerEvent -> Maybe LedgerEvent
forall a b. (a -> b) -> a -> b
$ TxId StandardCrypto -> AnyProposals -> LedgerEvent
NewGovernanceProposals TxId (EraCrypto (ConwayEra StandardCrypto))
TxId StandardCrypto
txid (Proposals (ConwayEra StandardCrypto) -> AnyProposals
forall era. EraPParams era => Proposals era -> AnyProposals
AnyProposals Proposals (ConwayEra StandardCrypto)
props)

instance ConvertLedgerEvent (HardForkBlock (Consensus.CardanoEras StandardCrypto)) where
  toLedgerEvent :: WrapLedgerEvent (HardForkBlock (CardanoEras StandardCrypto))
-> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent (HardForkBlock (CardanoEras StandardCrypto))
wrappedLedgerEvent =
    case OneEraLedgerEvent (CardanoEras StandardCrypto)
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
forall (xs :: [*]). OneEraLedgerEvent xs -> NS WrapLedgerEvent xs
getOneEraLedgerEvent (OneEraLedgerEvent (CardanoEras StandardCrypto)
 -> NS WrapLedgerEvent (CardanoEras StandardCrypto))
-> OneEraLedgerEvent (CardanoEras StandardCrypto)
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
forall a b. (a -> b) -> a -> b
$ WrapLedgerEvent (HardForkBlock (CardanoEras StandardCrypto))
-> AuxLedgerEvent
     (LedgerState (HardForkBlock (CardanoEras StandardCrypto)))
forall blk. WrapLedgerEvent blk -> AuxLedgerEvent (LedgerState blk)
unwrapLedgerEvent WrapLedgerEvent (HardForkBlock (CardanoEras StandardCrypto))
wrappedLedgerEvent of
      ShelleyLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (ShelleyEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (ShelleyEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (ShelleyEra StandardCrypto))
ledgerEvent
      AllegraLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
ledgerEvent
      MaryLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
ledgerEvent
      AlonzoLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
ledgerEvent
      BabbageLedgerEvent WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
ledgerEvent
      ConwayLedgerEvent WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
ledgerEvent -> WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
-> Maybe LedgerEvent
forall blk.
ConvertLedgerEvent blk =>
WrapLedgerEvent blk -> Maybe LedgerEvent
toLedgerEvent WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
ledgerEvent

{-# COMPLETE
  ShelleyLedgerEvent
  , AllegraLedgerEvent
  , MaryLedgerEvent
  , AlonzoLedgerEvent
  , BabbageLedgerEvent
  , ConwayLedgerEvent
  #-}

pattern ShelleyLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.TPraos StandardCrypto) (ShelleyEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mShelleyLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (TPraos StandardCrypto) (ShelleyEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bShelleyLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (ShelleyEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
ShelleyLedgerEvent x = S (Z x)

pattern AllegraLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.TPraos StandardCrypto) (AllegraEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mAllegraLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bAllegraLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
AllegraLedgerEvent x = S (S (Z x))

pattern MaryLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.TPraos StandardCrypto) (MaryEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mMaryLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bMaryLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
MaryLedgerEvent x = S (S (S (Z x)))

pattern AlonzoLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.TPraos StandardCrypto) (AlonzoEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mAlonzoLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bAlonzoLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
AlonzoLedgerEvent x = S (S (S (S (Z x))))

pattern BabbageLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.Praos StandardCrypto) (BabbageEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mBabbageLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bBabbageLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
BabbageLedgerEvent x = S (S (S (S (S (Z x)))))

pattern ConwayLedgerEvent
  :: WrapLedgerEvent (ShelleyBlock (Consensus.Praos StandardCrypto) (ConwayEra StandardCrypto))
  -> NS WrapLedgerEvent (Consensus.CardanoEras StandardCrypto)
pattern $mConwayLedgerEvent :: forall {r}.
NS WrapLedgerEvent (CardanoEras StandardCrypto)
-> (WrapLedgerEvent
      (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
    -> r)
-> ((# #) -> r)
-> r
$bConwayLedgerEvent :: WrapLedgerEvent
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
-> NS WrapLedgerEvent (CardanoEras StandardCrypto)
ConwayLedgerEvent x = S (S (S (S (S (S (Z x))))))