diff --git a/.github/workflows/check-hlint.yml b/.github/workflows/check-hlint.yml
index 33376132a33..11897a531ae 100644
--- a/.github/workflows/check-hlint.yml
+++ b/.github/workflows/check-hlint.yml
@@ -23,7 +23,7 @@ jobs:
     - name: 'Set up HLint'
       uses: rwe/actions-hlint-setup@v1
       with:
-        version: 3.3
+        version: 3.5
 
     - name: 'Run HLint'
       uses: rwe/actions-hlint-run@v2
diff --git a/.github/workflows/check-mainnet-config.yml b/.github/workflows/check-mainnet-config.yml
index a9549738c2f..88b11c0e968 100644
--- a/.github/workflows/check-mainnet-config.yml
+++ b/.github/workflows/check-mainnet-config.yml
@@ -50,9 +50,9 @@ jobs:
         for f in "${test_files[@]}"; do
           nix_file="result/$f"
           repo_file="configuration/cardano/$f"
-          if ! jq -e --argfile nix "$nix_file" --argfile repo "$repo_file" -n '$repo | reduce keys[] as $k (true; . and $repo[$k] == $nix[$k])' &>/dev/null ; then
+          if ! jq -e --argfile nix "$nix_file" --argfile repo "$repo_file" -n '$repo | reduce keys[] as $k (true; . and $repo[$k] == $nix[$k])' >/dev/null ; then
             echo "Nix file $nix_file does not have all the same top-level entries as the file from repository $repo_file"
-            diff "$nix_file" "$repo_file"
+            diff <(jq -S . "$nix_file") <(jq -S . "$repo_file")
             exit 1
           fi
         done
diff --git a/cabal.project b/cabal.project
index 9ae783614b0..05151d9aae4 100644
--- a/cabal.project
+++ b/cabal.project
@@ -66,8 +66,8 @@ package bitvec
 source-repository-package
     type: git
     location: https://github.com/CardanoSolutions/ouroboros-consensus
-    tag: 019a99b71f9d009e1a2101d09f6be0e75a33ea96
-    --sha256: 1y39a5zp8g8bra5nss5n8wwjla3x8hc8xwnn3r8wwvkxsrgplgw4
+    tag: 79da9a368cb6d2e7ed5ff5e89bb318b94c3c606d
+    --sha256: 02wjbvgbfdr5rybncxgx6slxh4gzx1vh4i34n6h834qghiq4yykb
     subdir:
       ouroboros-consensus
       ouroboros-consensus-cardano
diff --git a/cardano-git-rev/src/Cardano/Git/Rev.hs b/cardano-git-rev/src/Cardano/Git/Rev.hs
index 7d8972465af..6b15f4cb295 100644
--- a/cardano-git-rev/src/Cardano/Git/Rev.hs
+++ b/cardano-git-rev/src/Cardano/Git/Rev.hs
@@ -1,7 +1,7 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE ForeignFunctionInterface #-}
 
 module Cardano.Git.Rev
   ( gitRev
@@ -13,8 +13,8 @@ import qualified Data.Text as T
 #if !defined(arm_HOST_ARCH)
 import           Cardano.Git.RevFromGit (gitRevFromGit)
 #endif
-import           GHC.Foreign (peekCStringLen)
 import           Foreign.C.String (CString)
+import           GHC.Foreign (peekCStringLen)
 import           System.IO (utf8)
 import           System.IO.Unsafe (unsafeDupablePerformIO)
 
diff --git a/cardano-node-capi/src/Node.hs b/cardano-node-capi/src/Node.hs
index 77af514c4fc..8c6406f72cc 100644
--- a/cardano-node-capi/src/Node.hs
+++ b/cardano-node-capi/src/Node.hs
@@ -19,7 +19,7 @@ foreign export ccall "runNode" crunNode :: Int -> Ptr CString -> IO ()
 crunNode :: Int -> Ptr CString -> IO ()
 crunNode argc argv = peekArray argc argv >>= mapM peekCString >>= \args ->
     case execParserPure pref opts args of
-        Success pnc -> runNode pnc
+        Success pnc -> runNode pnc []
         Failure f   -> print f
         CompletionInvoked _ -> putStrLn "Completion Invoked?"
   where
diff --git a/cardano-node/app/cardano-node.hs b/cardano-node/app/cardano-node.hs
index 20693e4cec7..cda9a85163f 100644
--- a/cardano-node/app/cardano-node.hs
+++ b/cardano-node/app/cardano-node.hs
@@ -30,7 +30,7 @@ main = do
     cmd <- Opt.customExecParser p opts
 
     case cmd of
-      RunCmd args -> runNode args
+      RunCmd args -> runNode args []
       TraceDocumentation tdc -> runTraceDocumentationCmd tdc
       VersionCmd  -> runVersionCommand
 
diff --git a/cardano-node/src/Cardano/Node/Configuration/POM.hs b/cardano-node/src/Cardano/Node/Configuration/POM.hs
index 2c446a2a89a..8efc3d693ff 100644
--- a/cardano-node/src/Cardano/Node/Configuration/POM.hs
+++ b/cardano-node/src/Cardano/Node/Configuration/POM.hs
@@ -40,7 +40,7 @@ import           System.FilePath (takeDirectory, (</>))
 
 import           Cardano.Crypto (RequiresNetworkMagic (..))
 import           Cardano.Logging.Types
-import           Cardano.Node.Configuration.NodeAddress (SocketPath, PortNumber)
+import           Cardano.Node.Configuration.NodeAddress (PortNumber, SocketPath)
 import           Cardano.Node.Configuration.Socket (SocketConfig (..))
 import           Cardano.Node.Handlers.Shutdown
 import           Cardano.Node.Protocol.Types (Protocol (..))
diff --git a/cardano-node/src/Cardano/Node/LedgerEvent.hs b/cardano-node/src/Cardano/Node/LedgerEvent.hs
index 80fdaf4ac78..dabd7281052 100644
--- a/cardano-node/src/Cardano/Node/LedgerEvent.hs
+++ b/cardano-node/src/Cardano/Node/LedgerEvent.hs
@@ -1,36 +1,39 @@
-{-# LANGUAGE ConstraintKinds            #-}
-{-# LANGUAGE DataKinds                  #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GADTs                      #-}
-{-# LANGUAGE LambdaCase                 #-}
-{-# LANGUAGE NamedFieldPuns             #-}
-{-# LANGUAGE NoImplicitPrelude          #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE PartialTypeSignatures      #-}
-{-# LANGUAGE RankNTypes                 #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
-{-# LANGUAGE TypeApplications           #-}
-{-# LANGUAGE TypeOperators              #-}
-{-# LANGUAGE UndecidableInstances       #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PartialTypeSignatures #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 -- | Local representation for display purpose of cardano-ledger events.
 --
 -- Shamelessly stolen and adapted from db-sync.
 module Cardano.Node.LedgerEvent (
     -- * Ledger Events
-    AnchoredEvent (..)
+    AnchoredEvents (..)
   , LedgerEvent (..)
   , LedgerNewEpochEvent (..)
   , LedgerRewardUpdateEvent (..)
-  , deserializeAnchoredEvent
-  , serializeAnchoredEvent
+  , Versioned (..)
   , ledgerEventName
 
     -- ** Using Ledger events
+  , StandardLedgerEventHandler
   , withLedgerEventsServerStream
   , foldEvent
+  , withLedgerEventsChan
+  , mkLedgerEventHandler
+  , LedgerEventsWriter
+  , LedgerEventsReader
 
     -- * Type-level plumbing
   , ConvertLedgerEvent (..)
@@ -54,64 +57,65 @@ module Cardano.Node.LedgerEvent (
 
 import           Cardano.Prelude hiding (All, Sum)
 
-import           Control.Monad.Fail (MonadFail(..))
-import           Cardano.Ledger.Binary (DecCBOR(..), EncCBOR(..), Version,
-                   decodeFull', fromCBOR, serialize', toCBOR)
-import           Cardano.Ledger.Binary.Coders (Decode(..), Encode (..), encode, (!>),
-                   (<!), decode)
+import           Cardano.Ledger.Alonzo.Rules (AlonzoBbodyEvent (ShelleyInAlonzoEvent),
+                   AlonzoUtxoEvent (UtxosEvent), AlonzoUtxosEvent,
+                   AlonzoUtxowEvent (WrappedShelleyEraEvent))
+import qualified Cardano.Ledger.Alonzo.Rules as Alonzo
+import           Cardano.Ledger.Binary (DecCBOR (..), EncCBOR (..), Version, decodeFull', fromCBOR,
+                   serialize', toCBOR)
+import           Cardano.Ledger.Binary.Coders (Decode (..), Encode (..), decode, encode, (!>), (<!))
 import           Cardano.Ledger.Coin (Coin (..), DeltaCoin (..))
-import           Cardano.Ledger.Credential (Credential (..))
-import           Cardano.Ledger.Rewards (Reward(..))
-import qualified Cardano.Ledger.Core as Ledger
+import           Cardano.Ledger.Conway.Rules (ConwayEpochEvent, ConwayNewEpochEvent)
+import qualified Cardano.Ledger.Conway.Rules as Conway
 import           Cardano.Ledger.Core (eraProtVerLow)
+import qualified Cardano.Ledger.Core as Ledger
+import           Cardano.Ledger.Credential (Credential (..))
 import           Cardano.Ledger.Crypto (Crypto, StandardCrypto)
 import           Cardano.Ledger.Keys (KeyRole (..))
-import           Cardano.Ledger.Shelley.API (InstantaneousRewards (..), KeyHash (..), ScriptHash (..))
+import           Cardano.Ledger.Rewards (Reward (..))
+import           Cardano.Ledger.Shelley.API (InstantaneousRewards (..), KeyHash (..),
+                   ScriptHash (..))
+import qualified Cardano.Ledger.Shelley.API as ShelleyAPI
 import           Cardano.Ledger.Shelley.Core (EraCrypto)
+import           Cardano.Ledger.Shelley.Rules (RupdEvent (..), ShelleyEpochEvent (..),
+                   ShelleyMirEvent (..), ShelleyNewEpochEvent, ShelleyPoolreapEvent (..),
+                   ShelleyTickEvent (..))
 import qualified Cardano.Ledger.Shelley.Rules as Shelley
-import qualified Cardano.Ledger.Alonzo.Rules as Alonzo
-import           Cardano.Ledger.Shelley.Rules (RupdEvent (..),
-                     ShelleyEpochEvent (..), ShelleyMirEvent (..),
-                     ShelleyNewEpochEvent, ShelleyPoolreapEvent (..),
-                     ShelleyTickEvent (..))
-import           Cardano.Slotting.Slot (SlotNo (..), EpochNo (..), WithOrigin (..))
-import           Cardano.Slotting.Block (BlockNo(..))
+import           Cardano.Slotting.Block (BlockNo (..))
+import           Cardano.Slotting.Slot (EpochNo (..), SlotNo (..), WithOrigin (..))
 import qualified Codec.CBOR.Decoding as CBOR
 import qualified Codec.CBOR.Encoding as CBOR
 import qualified Codec.CBOR.Read as CBOR
 import qualified Codec.CBOR.Write as CBOR
+import           Control.Arrow ((&&&))
+import           Control.Concurrent.STM (newTChanIO, readTChan, writeTChan)
+import           Control.Monad.Fail (MonadFail (..))
 import           Control.State.Transition (Event)
-import           Data.ByteString.Short(ShortByteString)
+import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as LBS
-import qualified Data.ByteString  as BS
-import           Data.SOP (All, K (..))
-import           Data.SOP.Strict (NS(..), hcmap, hcollapse)
+import           Data.ByteString.Short (ShortByteString)
+import qualified Data.List.NonEmpty as NE
 import qualified Data.Set as Set
+import           Data.SOP (All, K (..))
+import           Data.SOP.Strict (NS (..), hcmap, hcollapse)
 import           Data.String (String)
-import           Network.Socket(PortNumber, defaultProtocol, listen, accept,
-                  bind, close, socket, socketToHandle, withSocketsDo,
-                  SockAddr(..), SocketType(Stream), Family(AF_INET))
+import           GHC.IO.Exception (IOErrorType (ResourceVanished), IOException (IOError, ioe_type))
+import           Network.Socket (Family (AF_INET), PortNumber, SockAddr (..), SocketType (Stream),
+                   accept, bind, close, defaultProtocol, listen, socket, socketToHandle,
+                   withSocketsDo)
 import           Ouroboros.Consensus.Byron.Ledger.Block (ByronBlock)
-import           Ouroboros.Consensus.Cardano.Block (AllegraEra, AlonzoEra,
-                     BabbageEra, CardanoEras, ConwayEra, HardForkBlock,
-                     MaryEra, ShelleyEra)
-import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras
-                     (OneEraLedgerEvent(..), getOneEraHash, getOneEraLedgerEvent)
-import           Ouroboros.Consensus.Ledger.Abstract (AuxLedgerEvent,
-                     LedgerEventHandler(..))
+import           Ouroboros.Consensus.Cardano.Block (AllegraEra, AlonzoEra, BabbageEra, CardanoEras,
+                   ConwayEra, HardForkBlock, MaryEra, ShelleyEra)
+import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (OneEraLedgerEvent (..),
+                   getOneEraHash, getOneEraLedgerEvent)
+import           Ouroboros.Consensus.Ledger.Abstract (AuxLedgerEvent, LedgerEventHandler (..))
 import qualified Ouroboros.Consensus.Ledger.Abstract as Abstract
 import           Ouroboros.Consensus.Ledger.Extended (ExtLedgerState)
-import           Ouroboros.Consensus.Shelley.Ledger (ShelleyBlock,
-                     ShelleyLedgerEvent (..))
+import           Ouroboros.Consensus.Shelley.Ledger (ShelleyBlock, ShelleyLedgerEvent (..))
 import           Ouroboros.Consensus.TypeFamilyWrappers
-import           Prelude (type (~))
-import           System.IO(hIsEOF)
-import Cardano.Ledger.Conway.Rules (ConwayNewEpochEvent, ConwayEpochEvent)
-import qualified Cardano.Ledger.Conway.Rules as Conway
-import qualified Cardano.Ledger.Shelley.API as ShelleyAPI
-import Cardano.Ledger.Alonzo.Rules (AlonzoBbodyEvent (ShelleyInAlonzoEvent), AlonzoUtxowEvent (WrappedShelleyEraEvent), AlonzoUtxoEvent (UtxosEvent), AlonzoUtxosEvent)
-import GHC.IO.Exception (IOException(IOError, ioe_type), IOErrorType (ResourceVanished))
-import Ouroboros.Network.Block (ChainHash(GenesisHash, BlockHash))
+import           Ouroboros.Network.Block (ChainHash (BlockHash, GenesisHash), HeaderHash)
+import           Prelude hiding (MonadFail (..), String, map, print, putStrLn, show, (.))
+import           System.IO (hIsEOF)
 
 type LedgerState crypto =
   ExtLedgerState (HardForkBlock (CardanoEras crypto))
@@ -341,9 +345,9 @@ ledgerRewardUpdateEventName = \case
   LedgerIncrementalRewards {} -> "LedgerIncrementalRewards"
 
 fromAuxLedgerEvent
-  :: forall xs crypto. (All ConvertLedgerEvent xs, crypto ~ StandardCrypto)
+  :: forall xs. (All ConvertLedgerEvent xs)
   => AuxLedgerEvent (Abstract.LedgerState (HardForkBlock xs))
-  -> Maybe (LedgerEvent crypto)
+  -> Maybe (LedgerEvent StandardCrypto)
 fromAuxLedgerEvent =
   toLedgerEvent . WrapLedgerEvent @(HardForkBlock xs)
 
@@ -697,36 +701,38 @@ eventCodecVersion = \case
   OneEraLedgerEvent (  S(S(S(S(S(Z{}))))) ) -> eraProtVerLow @(BabbageEra crypto)
   OneEraLedgerEvent (S(S(S(S(S(S(Z{}))))))) -> eraProtVerLow @(ConwayEra crypto)
 
-data AnchoredEvent =
-  AnchoredEvent
+data AnchoredEvents =
+  AnchoredEvents
     { prevBlockHeaderHash :: !(WithOrigin ShortByteString)
     , blockHeaderHash :: !ShortByteString
     , slotNo :: !SlotNo
     , blockNo :: !BlockNo
-    , ledgerEvent :: !(LedgerEvent StandardCrypto)
+    , ledgerEvents :: !(NonEmpty (LedgerEvent StandardCrypto))
     }
   deriving (Eq, Show)
 
-instance EncCBOR AnchoredEvent where
-  encCBOR AnchoredEvent{prevBlockHeaderHash, blockHeaderHash , slotNo, blockNo, ledgerEvent} =
-    encode $ Rec AnchoredEvent
+instance EncCBOR AnchoredEvents where
+  encCBOR AnchoredEvents{prevBlockHeaderHash, blockHeaderHash , slotNo, blockNo, ledgerEvents} =
+    encode $ Rec AnchoredEvents
       !> To prevBlockHeaderHash
       !> To blockHeaderHash
       !> To slotNo
       !> To blockNo
-      !> To ledgerEvent
+      !> To ledgerEvents
 
-instance DecCBOR AnchoredEvent where
+instance DecCBOR AnchoredEvents where
   decCBOR =
-    decode $ RecD AnchoredEvent
+    decode $ RecD AnchoredEvents
       <! From
       <! From
       <! From
       <! From
       <! From
 
-serializeAnchoredEvent :: Version -> AnchoredEvent -> ByteString
-serializeAnchoredEvent version event =
+data Versioned a = Versioned Version a
+
+serializeVersioned :: EncCBOR a => Versioned a -> ByteString
+serializeVersioned (Versioned version x) =
   CBOR.toStrictByteString encoding
  where
   encoding =
@@ -734,12 +740,13 @@ serializeAnchoredEvent version event =
     <>
     toCBOR version
     <>
-    CBOR.encodeBytes (serialize' version event)
+    CBOR.encodeBytes (serialize' version x)
 
-deserializeAnchoredEvent
-  :: LBS.ByteString
-  -> Either CBOR.DeserialiseFailure (LBS.ByteString, AnchoredEvent)
-deserializeAnchoredEvent =
+deserializeVersioned
+  :: DecCBOR a
+  => LBS.ByteString
+  -> Either CBOR.DeserialiseFailure (LBS.ByteString, Versioned a)
+deserializeVersioned =
   CBOR.deserialiseFromBytes decoder
  where
    decoder = do
@@ -747,13 +754,13 @@ deserializeAnchoredEvent =
     _ <- CBOR.decodeListLen
     version <- fromCBOR
     bytes <- CBOR.decodeBytes
-    either (fail . show) pure (decodeFull' version bytes)
+    either (fail . show) (pure . Versioned version) $ decodeFull' version bytes
 
 -- IO action to read ledger events in binary form
 foldEvent
   :: Handle
   -> a
-  -> (a -> AnchoredEvent -> IO a)
+  -> (a -> AnchoredEvents -> IO a)
   -> IO a
 foldEvent h st0 fn =
   LBS.hGetContents h >>= go st0
@@ -763,21 +770,23 @@ foldEvent h st0 fn =
       if eof then
         pure st
       else do
-        (events, event) <- either (panic . show) pure $ deserializeAnchoredEvent bytes
+        (events, Versioned _ event) <- either (panic . show) pure $ deserializeVersioned bytes
         st' <- fn st event
         go st' events
 
+type StandardLedgerEventHandler = LedgerEventHandler IO (LedgerState StandardCrypto) (HardForkBlock (CardanoEras StandardCrypto))
+
 withLedgerEventsServerStream
   :: PortNumber
-  -> (LedgerEventHandler IO (LedgerState StandardCrypto) (HardForkBlock (CardanoEras crypto)) -> IO ())
+  -> (StandardLedgerEventHandler -> IO ())
   -> IO ()
-withLedgerEventsServerStream port handler = do
+withLedgerEventsServerStream port action = do
   withSocketsDo $ do
     bracket open closeSockets go
  where
   go s = do
     h <- socketToHandle s WriteMode
-    handler $ LedgerEventHandler $ writeLedgerEvents h
+    action $ mkLedgerEventHandler (writeAnchoredEvents h)
 
   open = do
     sock <- socket AF_INET Stream defaultProtocol
@@ -789,18 +798,52 @@ withLedgerEventsServerStream port handler = do
 
   closeSockets = close
 
-  writeLedgerEvents h ph headerHash slotNo blockNo events = do
-    forM_ events $ \event -> do
-      case fromAuxLedgerEvent event of
-        Nothing -> pure ()
-        Just e -> do
-          let chainHashToHeaderHash GenesisHash = Origin
-              chainHashToHeaderHash (BlockHash bh) = At bh
-          let anchoredEvent = AnchoredEvent (getOneEraHash <$> chainHashToHeaderHash ph) (getOneEraHash headerHash) slotNo blockNo e
-          catch (BS.hPut h $ serializeAnchoredEvent (eventCodecVersion event) anchoredEvent) $ \case
-            -- If the client closes the socket, we continue running the node, but ignore the events.
-            IOError { ioe_type = ResourceVanished } -> do
-              pure ()
-            err -> do
-              print err
-              throwIO err
+  writeAnchoredEvents h = handle errHandler . BS.hPut h . serializeVersioned
+    where
+      errHandler = \case
+        -- If the client closes the socket, we continue running the node, but ignore the events.
+        IOError { ioe_type = ResourceVanished } -> do
+          pure ()
+        err -> do
+          print err
+          throwIO err
+
+withLedgerEventsChan
+  :: (LedgerEventsWriter -> LedgerEventsReader -> IO a)
+  -> IO a
+withLedgerEventsChan action = do
+  chan <- newTChanIO
+  action (atomically . writeTChan chan) (atomically $ readTChan chan)
+
+type LedgerEventsWriter = Versioned AnchoredEvents -> IO ()
+type LedgerEventsReader = IO (Versioned AnchoredEvents)
+
+mkLedgerEventHandler
+  :: LedgerEventsWriter
+  -> StandardLedgerEventHandler
+mkLedgerEventHandler writer =
+  LedgerEventHandler $ \p h s b -> traverse_ writer . mkVersionedAnchoredEvents p h s b
+
+mkVersionedAnchoredEvents
+  :: ChainHash (HardForkBlock (CardanoEras StandardCrypto))
+  -> HeaderHash (HardForkBlock (CardanoEras StandardCrypto))
+  -> SlotNo
+  -> BlockNo
+  -> [AuxLedgerEvent (LedgerState StandardCrypto)]
+  -> [Versioned AnchoredEvents]
+mkVersionedAnchoredEvents prevHash headerHash slotNo blockNo auxEvents =
+  [ Versioned version $
+      AnchoredEvents
+        (getOneEraHash <$> chainHashToOriginHash prevHash)
+        (getOneEraHash headerHash)
+        slotNo
+        blockNo
+        ledgerEvents
+  | (version, ledgerEvents) <- versionedGroups
+  ]
+  where
+    chainHashToOriginHash :: ChainHash b -> WithOrigin (HeaderHash b)
+    chainHashToOriginHash GenesisHash = Origin
+    chainHashToOriginHash (BlockHash bh) = At bh
+    versionedEvents = mapMaybe (sequence . (eventCodecVersion &&& fromAuxLedgerEvent)) auxEvents
+    versionedGroups = map (first NE.head . NE.unzip) . NE.groupBy ((==) `on` fst) $ versionedEvents
diff --git a/cardano-node/src/Cardano/Node/Run.hs b/cardano-node/src/Cardano/Node/Run.hs
index 8f46a46f7d1..ed0ab8dae07 100644
--- a/cardano-node/src/Cardano/Node/Run.hs
+++ b/cardano-node/src/Cardano/Node/Run.hs
@@ -29,6 +29,7 @@ import           Cardano.Prelude (FatalError (..), bool, (:~:) (..))
 import           Data.Bits
 import           Data.IP (toSockAddr)
 
+import           Cardano.Ledger.Binary (serialize')
 import           Control.Concurrent (killThread, mkWeakThreadId, myThreadId)
 import           Control.Concurrent.Class.MonadSTM.Strict
 import           Control.Exception (try)
@@ -38,8 +39,6 @@ import           Control.Monad.IO.Class (MonadIO (..))
 import           Control.Monad.Trans.Except (ExceptT, runExceptT)
 import           Control.Monad.Trans.Except.Extra (left)
 import           "contra-tracer" Control.Tracer
-import           Cardano.Ledger.Binary (serialize')
-import           System.IO (withFile, IOMode(..))
 import qualified Data.ByteString as BS
 import           Data.Either (partitionEithers)
 import           Data.Map.Strict (Map)
@@ -59,6 +58,7 @@ import           Network.Socket (Socket)
 import           System.Directory (canonicalizePath, createDirectoryIfMissing, makeAbsolute)
 import           System.Environment (lookupEnv)
 import           System.Exit (exitFailure)
+import           System.IO (IOMode (..), withFile)
 #ifdef UNIX
 import           GHC.Weak (deRefWeak)
 import           System.Posix.Files
@@ -82,7 +82,7 @@ import           Cardano.Node.Configuration.NodeAddress
 import           Cardano.Node.Configuration.POM (NodeConfiguration (..),
                    PartialNodeConfiguration (..), SomeNetworkP2PMode (..),
                    defaultPartialNodeConfiguration, makeNodeConfiguration, parseNodeConfigurationFP)
-import           Cardano.Node.LedgerEvent (withLedgerEventsServerStream)
+import           Cardano.Node.LedgerEvent (StandardLedgerEventHandler, withLedgerEventsServerStream)
 import           Cardano.Node.Startup
 import           Cardano.Node.Tracing.API
 import           Cardano.Node.Tracing.StateRep (NodeState (NodeKernelOnline))
@@ -92,7 +92,9 @@ import           Cardano.Tracing.Config (TraceOptions (..), TraceSelection (..))
 
 import qualified Ouroboros.Consensus.Config as Consensus
 import           Ouroboros.Consensus.Config.SupportsNode (ConfigSupportsNode (..))
-import           Ouroboros.Consensus.Ledger.Basics (LedgerEventHandler(..), LedgerState,
+import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (OneEraHash (..),
+                   OneEraLedgerEvent (..))
+import           Ouroboros.Consensus.Ledger.Basics (LedgerEventHandler (..), LedgerState,
                    discardEvent)
 import           Ouroboros.Consensus.Ledger.Extended (ExtLedgerState)
 import           Ouroboros.Consensus.Node (NetworkP2PMode (..), RunNodeArgs (..),
@@ -100,10 +102,8 @@ import           Ouroboros.Consensus.Node (NetworkP2PMode (..), RunNodeArgs (..)
 import qualified Ouroboros.Consensus.Node as Node (getChainDB, run)
 import           Ouroboros.Consensus.Node.NetworkProtocolVersion
 import           Ouroboros.Consensus.Node.ProtocolInfo
-import           Ouroboros.Consensus.Util.Orphans ()
-import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (OneEraHash(..),
-                   OneEraLedgerEvent(..))
 import           Ouroboros.Consensus.TypeFamilyWrappers (unwrapLedgerEvent)
+import           Ouroboros.Consensus.Util.Orphans ()
 import qualified Ouroboros.Network.Diffusion as Diffusion
 import qualified Ouroboros.Network.Diffusion.NonP2P as NonP2P
 import qualified Ouroboros.Network.Diffusion.P2P as P2P
@@ -139,8 +139,9 @@ import           Ouroboros.Network.PeerSelection.State.LocalRootPeers (HotValenc
 
 runNode
   :: PartialNodeConfiguration
+  -> [StandardLedgerEventHandler]
   -> IO ()
-runNode cmdPc = do
+runNode cmdPc eventHandlers = do
     installSigTermHandler
 
     Crypto.cryptoInit
@@ -183,12 +184,16 @@ runNode cmdPc = do
       (SomeConsensusProtocol blockType@Api.CardanoBlockType runP, Just port) ->
         withLedgerEventsServerStream (fromIntegral port) $ \ledgerEventHandler ->
           handleNodeWithTracers
-            ledgerEventHandler
+            (mconcat $ ledgerEventHandler : eventHandlers)
             cmdPc nc p networkMagic blockType runP
-      (SomeConsensusProtocol blockType runP, _noGivenPort) ->
+      (SomeConsensusProtocol blockType@Api.CardanoBlockType runP, Nothing) ->
         handleNodeWithTracers
-          discardEvent
+          (mconcat eventHandlers)
           cmdPc nc p networkMagic blockType runP
+      (SomeConsensusProtocol otherBlockType runP, _somePort) ->
+        handleNodeWithTracers
+          mempty
+          cmdPc nc p networkMagic otherBlockType runP
 
 -- | Workaround to ensure that the main thread throws an async exception on
 -- receiving a SIGTERM signal.
diff --git a/cardano-node/test/Test/Cardano/Node/LedgerEvent.hs b/cardano-node/test/Test/Cardano/Node/LedgerEvent.hs
index 3d2dad4fa3a..dad92f851d3 100644
--- a/cardano-node/test/Test/Cardano/Node/LedgerEvent.hs
+++ b/cardano-node/test/Test/Cardano/Node/LedgerEvent.hs
@@ -1,10 +1,9 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TemplateHaskell #-}
 
 module Test.Cardano.Node.LedgerEvent where
 
-import Prelude
+import           Prelude
 
 import           Cardano.Node.LedgerEvent
 
@@ -12,23 +11,23 @@ import           Cardano.Crypto.Hash (Hash, HashAlgorithm, hashFromBytes)
 import qualified Codec.CBOR.Schema as CDDL
 import           Data.ByteString (ByteString)
 import qualified Data.ByteString.Base16 as Hex
-import           Data.ByteString.Lazy(fromStrict)
+import           Data.ByteString.Lazy (fromStrict)
 import           Data.ByteString.Short (ShortByteString, toShort)
 import           Data.Map (Map)
 import           Data.Maybe (fromJust)
 import           Data.Set (Set)
-import           Data.String (IsString(..))
+import           Data.String (IsString (..))
 import           Data.Text (Text)
+import qualified Data.Text as T
+import qualified Data.Text.IO as TIO
 import           Hedgehog (Property, discover, footnote)
 import qualified Hedgehog
-import qualified Hedgehog.Internal.Property as Hedgehog
 import qualified Hedgehog.Extras.Test.Process as Hedgehog
 import qualified Hedgehog.Gen as Gen
+import qualified Hedgehog.Internal.Property as Hedgehog
 import qualified Hedgehog.Range as Range
 import           System.FilePath ((</>))
 import           System.IO.Unsafe (unsafePerformIO)
-import qualified Data.Text as T
-import qualified Data.Text.IO as TIO
 
 specification :: Text
 specification =
diff --git a/cardano-node/test/cardano-node-test.hs b/cardano-node/test/cardano-node-test.hs
index fd89e9b3c88..fea4910d0c5 100644
--- a/cardano-node/test/cardano-node-test.hs
+++ b/cardano-node/test/cardano-node-test.hs
@@ -14,8 +14,8 @@ import qualified Test.Cardano.Node.FilePermissions
 import qualified Test.Cardano.Node.Json
 import qualified Test.Cardano.Node.LedgerEvent
 import qualified Test.Cardano.Node.POM
-import qualified Test.Cardano.Tracing.OrphanInstances.HardFork
 import qualified Test.Cardano.Tracing.NewTracing.Consistency
+import qualified Test.Cardano.Tracing.OrphanInstances.HardFork
 
 import qualified Cardano.Crypto.Init as Crypto
 
diff --git a/cddl/src/Codec/CBOR/Schema.hs b/cddl/src/Codec/CBOR/Schema.hs
index bffe8d0681d..c8376a1659f 100644
--- a/cddl/src/Codec/CBOR/Schema.hs
+++ b/cddl/src/Codec/CBOR/Schema.hs
@@ -3,17 +3,17 @@
 
 module Codec.CBOR.Schema where
 
-import Prelude
+import           Prelude
 
-import Data.Text (Text)
-import qualified Data.Text as Text
-import Data.ByteString (ByteString)
-import qualified Data.ByteString.Base16 as Base16
+import           Data.ByteString (ByteString)
 import qualified Data.ByteString as BS
+import qualified Data.ByteString.Base16 as Base16
 import qualified Data.ByteString.Char8 as B8
-import Foreign.Marshal.Alloc (free)
-import Foreign.C.String (CString, peekCString, withCStringLen)
-import System.IO.Unsafe (unsafePerformIO)
+import           Data.Text (Text)
+import qualified Data.Text as Text
+import           Foreign.C.String (CString, peekCString, withCStringLen)
+import           Foreign.Marshal.Alloc (free)
+import           System.IO.Unsafe (unsafePerformIO)
 
 data ValidationError = ValidationError
   { cbor :: String -- | The erroneous CBOR as a base16-encoded text string
diff --git a/cddl/test/Codec/CBOR/SchemaSpec.hs b/cddl/test/Codec/CBOR/SchemaSpec.hs
index 82df24816ab..4badc783082 100644
--- a/cddl/test/Codec/CBOR/SchemaSpec.hs
+++ b/cddl/test/Codec/CBOR/SchemaSpec.hs
@@ -1,12 +1,12 @@
 module Codec.CBOR.SchemaSpec where
 
-import Prelude
+import           Prelude
 
 import qualified Codec.CBOR.Schema as CDDL
 import qualified Data.ByteString.Base16 as Base16
-import Data.Text (Text)
+import           Data.Text (Text)
 import qualified Data.Text.Encoding as T
-import Test.Hspec (Spec, SpecWith, context, specify, shouldBe)
+import           Test.Hspec (Spec, SpecWith, context, shouldBe, specify)
 
 spec :: Spec
 spec = context "Codec.CBOR.SchemaSpec" $ do
diff --git a/nix/haskell.nix b/nix/haskell.nix
index 8d902acb3b0..02464e3e06f 100644
--- a/nix/haskell.nix
+++ b/nix/haskell.nix
@@ -20,7 +20,7 @@ let
     {
       src = ../.;
       name = "cardano-node";
-      compiler-nix-name = lib.mkDefault "ghc963";
+      compiler-nix-name = lib.mkDefault "ghc928";
       # extra-compilers
       flake.variants = lib.genAttrs [ ] (x: {compiler-nix-name = x;});
       cabalProjectLocal = ''