Stylish haskell

bench/tx-generator/src/Cardano/Benchmarking/GeneratorTx/NodeToNode.hs

@@ -23,8 +23,8 @@ import           Network.Socket (AddrInfo (..))
 import           System.Random (newStdGen)
 
 import           "contra-tracer" Control.Tracer (Tracer, nullTracer)
-import           Ouroboros.Consensus.Byron.Ledger.Mempool (GenTx)
 import           Ouroboros.Consensus.Block.Abstract
+import           Ouroboros.Consensus.Byron.Ledger.Mempool (GenTx)
 import qualified Ouroboros.Consensus.Cardano as Consensus (CardanoBlock)
 import           Ouroboros.Consensus.Ledger.SupportsMempool (GenTxId)
 import           Ouroboros.Consensus.Network.NodeToNode (Codecs (..), defaultCodecs)
@@ -37,19 +37,18 @@ import           Ouroboros.Network.DeltaQ (defaultGSV)
 import           Ouroboros.Network.Driver (runPeerWithLimits)
 import           Ouroboros.Network.KeepAlive
 import           Ouroboros.Network.Magic
-import           Ouroboros.Network.Mux (MuxPeer (..), OuroborosApplication (..),
-                                        OuroborosBundle, RunMiniProtocol (..),
-                                        continueForever)
-import           Ouroboros.Network.NodeToClient (chainSyncPeerNull, IOManager)
+import           Ouroboros.Network.Mux (MuxPeer (..), OuroborosApplication (..), OuroborosBundle,
+                   RunMiniProtocol (..), continueForever)
+import           Ouroboros.Network.NodeToClient (IOManager, chainSyncPeerNull)
 import           Ouroboros.Network.NodeToNode (NetworkConnectTracers (..))
 import qualified Ouroboros.Network.NodeToNode as NtN
 import           Ouroboros.Network.Protocol.BlockFetch.Client (BlockFetchClient (..),
-                                                               blockFetchClientPeer)
+                   blockFetchClientPeer)
 import           Ouroboros.Network.Protocol.Handshake.Version (simpleSingletonVersions)
-import           Ouroboros.Network.Protocol.KeepAlive.Codec
 import           Ouroboros.Network.Protocol.KeepAlive.Client
+import           Ouroboros.Network.Protocol.KeepAlive.Codec
 import           Ouroboros.Network.Protocol.TxSubmission2.Client (TxSubmissionClient,
-                                                                  txSubmissionClientPeer)
+                   txSubmissionClientPeer)
 
 import           Ouroboros.Network.Snocket (socketSnocket)
 

cardano-api/src/Cardano/Api/Fees.hs

@@ -71,8 +71,8 @@ import           Cardano.Slotting.EpochInfo (EpochInfo, hoistEpochInfo)
 import qualified Cardano.Chain.Common as Byron
 
 import qualified Cardano.Ledger.Coin as Ledger
+import           Cardano.Ledger.Core (EraTx (sizeTxF))
 import qualified Cardano.Ledger.Core as Ledger
-import           Cardano.Ledger.Core (EraTx(sizeTxF))
 import qualified Cardano.Ledger.Crypto as Ledger
 import qualified Cardano.Ledger.Era as Ledger.Era (Crypto)
 import qualified Cardano.Ledger.Keys as Ledger
@@ -663,15 +663,15 @@ evaluateTransactionBalance _ _ _ (ByronTxBody _) =
 
 evaluateTransactionBalance pparams poolids utxo
                            (ShelleyTxBody era txbody _ _ _ _) =
-    withLedgerConstraints 
-      era 
+    withLedgerConstraints
+      era
       (getShelleyEraTxBodyConstraint era evalAdaOnly)
       (getShelleyEraTxBodyConstraint era evalMultiAsset)
   where
-    getShelleyEraTxBodyConstraint 
-      :: forall era' a. 
+    getShelleyEraTxBodyConstraint
+      :: forall era' a.
          ShelleyBasedEra era'
-      -> (ShelleyEraTxBody (ShelleyLedgerEra era') => a) 
+      -> (ShelleyEraTxBody (ShelleyLedgerEra era') => a)
       -> a
     getShelleyEraTxBodyConstraint ShelleyBasedEraShelley x = x
     getShelleyEraTxBodyConstraint ShelleyBasedEraMary x = x

cardano-api/src/Cardano/Api/LedgerEvent.hs

@@ -29,20 +29,20 @@ import           Cardano.Ledger.Era (Crypto)
 import qualified Cardano.Ledger.Keys as Ledger
 import           Cardano.Ledger.Shelley.API (InstantaneousRewards (InstantaneousRewards))
 import           Cardano.Ledger.Shelley.Rewards
-import           Cardano.Ledger.Shelley.Rules.Tick (ShelleyTickEvent (NewEpochEvent))
-import           Cardano.Ledger.Shelley.Rules.NewEpoch (ShelleyNewEpochEvent (..))
 import           Cardano.Ledger.Shelley.Rules.Epoch (ShelleyEpochEvent (..))
-import           Cardano.Ledger.Shelley.Rules.PoolReap (ShelleyPoolreapEvent (..))
 import           Cardano.Ledger.Shelley.Rules.Mir (ShelleyMirEvent (..))
+import           Cardano.Ledger.Shelley.Rules.NewEpoch (ShelleyNewEpochEvent (..))
+import           Cardano.Ledger.Shelley.Rules.PoolReap (ShelleyPoolreapEvent (..))
 import           Cardano.Ledger.Shelley.Rules.Rupd (RupdEvent (..))
+import           Cardano.Ledger.Shelley.Rules.Tick (ShelleyTickEvent (NewEpochEvent))
 import           Control.State.Transition (Event)
 import           Data.Function (($), (.))
 import           Data.Functor (fmap)
 import           Data.Map.Strict (Map)
 import qualified Data.Map.Strict as Map
 import           Data.Maybe (Maybe (Just, Nothing))
-import           Data.SOP.Strict
 import           Data.Set (Set)
+import           Data.SOP.Strict
 import           Ouroboros.Consensus.Byron.Ledger.Block (ByronBlock)
 import           Ouroboros.Consensus.Cardano.Block (HardForkBlock)
 import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (getOneEraLedgerEvent)

cardano-api/src/Cardano/Api/LedgerState.hs

@@ -129,6 +129,7 @@ import qualified Cardano.Ledger.Era as Ledger
 import qualified Cardano.Ledger.Keys as Shelley.Spec
 import qualified Cardano.Ledger.Keys as SL
 import qualified Cardano.Ledger.PoolDistr as SL
+import           Cardano.Ledger.SafeHash (HashAnnotated)
 import qualified Cardano.Ledger.Shelley.API as ShelleyAPI
 import qualified Cardano.Ledger.Shelley.Genesis as Shelley.Spec
 import qualified Cardano.Protocol.TPraos.API as TPraos
@@ -168,7 +169,6 @@ import qualified Ouroboros.Network.Block
 import qualified Ouroboros.Network.Protocol.ChainSync.Client as CS
 import qualified Ouroboros.Network.Protocol.ChainSync.ClientPipelined as CSP
 import           Ouroboros.Network.Protocol.ChainSync.PipelineDecision
-import Cardano.Ledger.SafeHash (HashAnnotated)
 
 data InitialLedgerStateError
   = ILSEConfigFile Text
@@ -1485,9 +1485,9 @@ obtainDecodeEpochStateConstraints
       , FromCBOR (State (Core.EraRule "PPUP" ledgerera))
       , FromCBOR (Core.Value ledgerera)
       , FromSharedCBOR (Core.TxOut ledgerera)
-      , HashAnnotated 
-          (Core.TxBody ledgerera) 
-          Core.EraIndependentTxBody 
+      , HashAnnotated
+          (Core.TxBody ledgerera)
+          Core.EraIndependentTxBody
           (Ledger.Crypto (ShelleyLedgerEra era))
       ) => a) -> a
 obtainDecodeEpochStateConstraints ShelleyBasedEraShelley f = f

cardano-api/src/Cardano/Api/Orphans.hs

@@ -47,27 +47,27 @@ import           Cardano.Api.Script
 import qualified Cardano.Binary as CBOR
 import qualified Cardano.Crypto.Hash.Class as Crypto
 import qualified Cardano.Ledger.Alonzo.Data as Alonzo
+import           Cardano.Ledger.Alonzo.Scripts (AlonzoScript)
+import           Cardano.Ledger.Babbage.PParams (BabbagePParams, BabbagePParamsUpdate)
 import qualified Cardano.Ledger.Babbage.PParams as Babbage
-import           Cardano.Ledger.Babbage.PParams (BabbagePParamsUpdate, BabbagePParams)
+import           Cardano.Ledger.Babbage.TxBody (BabbageTxOut (..))
 import qualified Cardano.Ledger.Babbage.TxBody as Babbage
 import qualified Cardano.Ledger.Coin as Shelley
-import qualified Cardano.Ledger.Core as Core
 import           Cardano.Ledger.Core (EraTxOut)
+import qualified Cardano.Ledger.Core as Core
 import qualified Cardano.Ledger.Crypto as Crypto
+import           Cardano.Ledger.Mary.Value (MaryValue (..))
+import qualified Cardano.Ledger.Mary.Value as Mary
 import qualified Cardano.Ledger.PoolDistr as Ledger
 import qualified Cardano.Ledger.SafeHash as SafeHash
-import           Cardano.Ledger.Val (Val)
+import           Cardano.Ledger.Shelley.API (ShelleyTxOut (..))
 import qualified Cardano.Ledger.Shelley.API as Shelley
-import qualified Cardano.Ledger.Mary.Value as Mary
-import           Cardano.Ledger.Mary.Value (MaryValue(..))
-import           Cardano.Ledger.Alonzo.Scripts (AlonzoScript)
-import           Cardano.Ledger.Shelley.API (ShelleyTxOut(..))
 import qualified Cardano.Ledger.Shelley.EpochBoundary as ShelleyEpoch
 import qualified Cardano.Ledger.Shelley.LedgerState as ShelleyLedger
 import           Cardano.Ledger.Shelley.PParams (ShelleyPParamsUpdate)
 import qualified Cardano.Ledger.Shelley.Rewards as Shelley
 import qualified Cardano.Ledger.Shelley.RewardUpdate as Shelley
-import           Cardano.Ledger.Babbage.TxBody (BabbageTxOut(..))
+import           Cardano.Ledger.Val (Val)
 import qualified Ouroboros.Consensus.Shelley.Eras as Consensus
 
 -- Orphan instances involved in the JSON output of the API queries.

cardano-api/src/Cardano/Api/Tx.hs

@@ -92,8 +92,8 @@ import           Cardano.Ledger.Crypto (StandardCrypto)
 
 import qualified Cardano.Ledger.Core as Ledger
 import qualified Cardano.Ledger.Keys as Shelley
-import qualified Cardano.Ledger.SafeHash as Ledger
 import qualified Cardano.Ledger.Keys.Bootstrap as Shelley
+import qualified Cardano.Ledger.SafeHash as Ledger
 import qualified Cardano.Ledger.Shelley.Tx as Shelley
 
 import qualified Cardano.Ledger.Alonzo as Alonzo
@@ -111,10 +111,10 @@ import           Cardano.Api.NetworkId
 import           Cardano.Api.SerialiseCBOR
 import           Cardano.Api.SerialiseTextEnvelope
 import           Cardano.Api.TxBody
-import Cardano.Ledger.Alonzo.Tx (AlonzoTx (AlonzoTx))
-import Cardano.Ledger.Alonzo.TxWitness (TxWitness(TxWitness))
+import           Cardano.Ledger.Alonzo (AlonzoScript)
+import           Cardano.Ledger.Alonzo.Tx (AlonzoTx (AlonzoTx))
+import           Cardano.Ledger.Alonzo.TxWitness (TxWitness (TxWitness))
 import qualified Cardano.Ledger.Shelley.API as Ledger (ShelleyTx (..))
-import Cardano.Ledger.Alonzo (AlonzoScript)
 
 -- ----------------------------------------------------------------------------
 -- Signed transactions
@@ -805,8 +805,7 @@ data ShelleyWitnessSigningKey =
 
 
 makeShelleyKeyWitness :: forall era
-                      .  ( IsShelleyBasedEra era
-                         )
+                      .  IsShelleyBasedEra era
                       => TxBody era
                       -> ShelleyWitnessSigningKey
                       -> KeyWitness era
@@ -934,8 +933,7 @@ signByronTransaction nw txbody sks =
     witnesses = map (makeByronKeyWitness nw txbody) sks
 
 -- signing keys is a set
-signShelleyTransaction :: ( IsShelleyBasedEra era
-                          )
+signShelleyTransaction :: IsShelleyBasedEra era
                        => TxBody era
                        -> [ShelleyWitnessSigningKey]
                        -> Tx era

cardano-api/src/Cardano/Api/Value.hs

@@ -85,7 +85,7 @@ import           Cardano.Api.SerialiseCBOR
 import           Cardano.Api.SerialiseRaw
 import           Cardano.Api.SerialiseUsing
 import           Cardano.Api.Utils (failEitherWith)
-import Cardano.Ledger.Mary.Value (MaryValue (..))
+import           Cardano.Ledger.Mary.Value (MaryValue (..))
 import qualified Cardano.Ledger.Mary.Value as Mary
 import qualified Cardano.Ledger.ShelleyMA.Rules as Shelley
 

cardano-cli/src/Cardano/CLI/Shelley/Run/Query.hs

@@ -100,9 +100,9 @@ import qualified Ouroboros.Consensus.HardFork.History as Consensus
 import qualified Ouroboros.Consensus.Protocol.Abstract as Consensus
 import qualified Ouroboros.Consensus.Protocol.Praos.Common as Consensus
 
+import           Cardano.Ledger.SafeHash (HashAnnotated)
 import qualified Ouroboros.Consensus.HardFork.History.Qry as Qry
 import qualified Ouroboros.Network.Protocol.LocalStateQuery.Type as LocalStateQuery
-import Cardano.Ledger.SafeHash (HashAnnotated)
 
 {- HLINT ignore "Reduce duplication" -}
 {- HLINT ignore "Use const" -}

cardano-node/src/Cardano/Node/Tracing.hs

@@ -1,33 +1,33 @@
 {-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE PackageImports #-}
 {-# LANGUAGE ImportQualifiedPost #-}
+{-# LANGUAGE PackageImports #-}
 module Cardano.Node.Tracing
   ( Tracers (..)
   , ConsensusStartupException (..)
   ) where
 
-import Prelude (IO)
+import           Prelude (IO)
 
-import Codec.CBOR.Read (DeserialiseFailure)
-import "contra-tracer" Control.Tracer (Tracer)
+import           Codec.CBOR.Read (DeserialiseFailure)
+import           "contra-tracer" Control.Tracer (Tracer)
 
-import Ouroboros.Consensus.Network.NodeToClient qualified as NodeToClient
-import Ouroboros.Consensus.Network.NodeToNode   qualified as NodeToNode
-import Ouroboros.Consensus.Node.Tracers         qualified as Consensus
-import Ouroboros.Consensus.Storage.ChainDB      qualified as ChainDB
-import Ouroboros.Network.Diffusion              qualified as Diffusion
+import qualified Ouroboros.Consensus.Network.NodeToClient as NodeToClient
+import qualified Ouroboros.Consensus.Network.NodeToNode as NodeToNode
+import qualified Ouroboros.Consensus.Node.Tracers as Consensus
+import qualified Ouroboros.Consensus.Storage.ChainDB as ChainDB
+import qualified Ouroboros.Network.Diffusion as Diffusion
 
-import Ouroboros.Network.NodeToNode   (NodeToNodeVersion, RemoteAddress)
-import Ouroboros.Network.NodeToClient (LocalAddress, NodeToClientVersion)
+import           Ouroboros.Network.NodeToClient (LocalAddress, NodeToClientVersion)
+import           Ouroboros.Network.NodeToNode (NodeToNodeVersion, RemoteAddress)
 
-import Cardano.Node.Handlers.Shutdown (ShutdownTrace)
-import Cardano.Node.Startup           (NodeInfo, NodeStartupInfo, StartupTrace)
+import           Cardano.Node.Handlers.Shutdown (ShutdownTrace)
+import           Cardano.Node.Startup (NodeInfo, NodeStartupInfo, StartupTrace)
 
-import Cardano.Logging.Resources
-import Cardano.Node.Tracing.StateRep (NodeState)
-import Cardano.Node.Tracing.Tracers.Peer (PeerT)
-import Cardano.Node.Tracing.Tracers.ConsensusStartupException
+import           Cardano.Logging.Resources
+import           Cardano.Node.Tracing.StateRep (NodeState)
+import           Cardano.Node.Tracing.Tracers.ConsensusStartupException
+import           Cardano.Node.Tracing.Tracers.Peer (PeerT)
 
 data Tracers peer localPeer blk p2p = Tracers
   { -- | Trace the ChainDB

cardano-node/src/Cardano/Node/Tracing/Documentation.hs

@@ -35,8 +35,7 @@ import           Cardano.Node.Tracing.Tracers.BlockReplayProgress
 import           Cardano.Node.Tracing.Tracers.ChainDB
 import           Cardano.Node.Tracing.Tracers.Consensus
 import           Cardano.Node.Tracing.Tracers.Diffusion
-import           Cardano.Node.Tracing.Tracers.ForgingThreadStats (
-                   docForgeStats, forgeThreadStats)
+import           Cardano.Node.Tracing.Tracers.ForgingThreadStats (docForgeStats, forgeThreadStats)
 import           Cardano.Node.Tracing.Tracers.KESInfo
 import           Cardano.Node.Tracing.Tracers.NodeToClient
 import           Cardano.Node.Tracing.Tracers.NodeToNode

cardano-node/src/Cardano/Node/Tracing/Tracers/Consensus.hs

@@ -97,9 +97,9 @@ import           Cardano.Node.Tracing.Era.Byron ()
 import           Cardano.Node.Tracing.Era.Shelley ()
 import           Cardano.Node.Tracing.Formatting ()
 import           Cardano.Node.Tracing.Render
-import           Cardano.Node.Tracing.Tracers.StartLeadershipCheck
-import           Cardano.Node.Tracing.Tracers.ForgingThreadStats(ForgingStats)
 import           Cardano.Node.Tracing.Tracers.ConsensusStartupException
+import           Cardano.Node.Tracing.Tracers.ForgingThreadStats (ForgingStats)
+import           Cardano.Node.Tracing.Tracers.StartLeadershipCheck
 import           Cardano.Prelude hiding (All, Show, show)
 
 import           Cardano.Protocol.TPraos.OCert (KESPeriod (..))

cardano-node/src/Cardano/Node/Tracing/Tracers/Diffusion.hs

@@ -46,8 +46,8 @@ import qualified Ouroboros.Network.Diffusion as ND
 import           Ouroboros.Network.Driver.Simple (TraceSendRecv (..))
 import qualified Ouroboros.Network.NodeToClient as NtC
 import qualified Ouroboros.Network.NodeToNode as NtN
-import           Ouroboros.Network.PeerSelection.LedgerPeers (NumberOfPeers (..),
-                   PoolStake (..), TraceLedgerPeers (..))
+import           Ouroboros.Network.PeerSelection.LedgerPeers (NumberOfPeers (..), PoolStake (..),
+                   TraceLedgerPeers (..))
 import           Ouroboros.Network.Protocol.BlockFetch.Type (Message (..))
 import qualified Ouroboros.Network.Protocol.Handshake.Type as HS
 import           Ouroboros.Network.Snocket (LocalAddress (..))

cardano-node/src/Cardano/Tracing/OrphanInstances/Consensus.hs

@@ -32,7 +32,8 @@ import           Cardano.Tracing.Render (renderChainHash, renderChunkNo, renderH
                    renderPointForVerbosity, renderRealPoint, renderRealPointAsPhrase,
                    renderTipBlockNo, renderTipHash, renderWithOrigin)
 
-import           Cardano.Node.Tracing.Tracers.ConsensusStartupException (ConsensusStartupException (..))
+import           Cardano.Node.Tracing.Tracers.ConsensusStartupException
+                   (ConsensusStartupException (..))
 
 import           Ouroboros.Consensus.Block (BlockProtocol, BlockSupportsProtocol, CannotForge,
                    ConvertRawHash (..), ForgeStateUpdateError, Header, RealPoint, blockNo,

cardano-node/src/Cardano/Tracing/Tracers.hs

@@ -79,8 +79,8 @@ import qualified Ouroboros.Consensus.Protocol.Ledger.HotKey as HotKey
 import           Ouroboros.Consensus.Util.Enclose
 
 import qualified Ouroboros.Network.AnchoredFragment as AF
-import           Ouroboros.Network.Block (BlockNo (..), ChainUpdate (..),
-                   HasHeader (..), Point, StandardHash, blockNo, pointSlot, unBlockNo)
+import           Ouroboros.Network.Block (BlockNo (..), ChainUpdate (..), HasHeader (..), Point,
+                   StandardHash, blockNo, pointSlot, unBlockNo)
 import           Ouroboros.Network.BlockFetch.ClientState (TraceFetchClientState (..),
                    TraceLabelPeer (..))
 import           Ouroboros.Network.BlockFetch.Decision (FetchDecision, FetchDecline (..))

cardano-tracer/src/Cardano/Tracer/Acceptors/Client.hs

@@ -12,21 +12,21 @@ import           Data.Word (Word32)
 import           Cardano.Logging (TraceObject)
 import           Cardano.Logging.Version (ForwardingVersion (..), ForwardingVersionData (..),
                    forwardingCodecCBORTerm, forwardingVersionCodec)
-import           Ouroboros.Network.Mux (MiniProtocol (..), MiniProtocolLimits (..),
-                   MiniProtocolNum (..), MuxMode (..), OuroborosApplication (..),
-                   RunMiniProtocol (..), miniProtocolLimits, miniProtocolNum, miniProtocolRun)
 import           Ouroboros.Network.Driver.Limits (ProtocolTimeLimits)
 import           Ouroboros.Network.IOManager (withIOManager)
 import           Ouroboros.Network.Magic (NetworkMagic (..))
-import           Ouroboros.Network.Snocket (LocalAddress, LocalSocket, Snocket,
-                   localAddressFromPath, localSnocket)
-import           Ouroboros.Network.Socket (ConnectionId (..), connectToNode,
-                   nullNetworkConnectTracers)
+import           Ouroboros.Network.Mux (MiniProtocol (..), MiniProtocolLimits (..),
+                   MiniProtocolNum (..), MuxMode (..), OuroborosApplication (..),
+                   RunMiniProtocol (..), miniProtocolLimits, miniProtocolNum, miniProtocolRun)
 import           Ouroboros.Network.Protocol.Handshake.Codec (cborTermVersionDataCodec,
                    codecHandshake, noTimeLimitsHandshake)
 import           Ouroboros.Network.Protocol.Handshake.Type (Handshake)
 import           Ouroboros.Network.Protocol.Handshake.Version (acceptableVersion,
                    simpleSingletonVersions)
+import           Ouroboros.Network.Snocket (LocalAddress, LocalSocket, Snocket,
+                   localAddressFromPath, localSnocket)
+import           Ouroboros.Network.Socket (ConnectionId (..), connectToNode,
+                   nullNetworkConnectTracers)
 import qualified System.Metrics.Configuration as EKGF
 import           System.Metrics.Network.Acceptor (acceptEKGMetricsInit)