remove deadcode from project using weeder

Author: Cmdv

cardano-db-sync/cardano-db-sync.cabal

@@ -199,7 +199,6 @@ library
                       , ouroboros-network-framework
                       , ouroboros-network-protocols
                       , plutus-ledger-api
-                      , pretty-show
                       , prometheus
                       , psqueues
                       , random-shuffle
@@ -217,7 +216,6 @@ library
                       , transformers
                       , transformers-except
                       , typed-protocols
-                      , unix
                       , vector
                       , wide-word
                       , yaml

cardano-db-sync/src/Cardano/DbSync/Api.hs

@@ -12,7 +12,6 @@ module Cardano.DbSync.Api (
   setConsistentLevel,
   getConsistentLevel,
   isConsistent,
-  getIsConsumedFixed,
   getDisableInOutState,
   getRanIndexes,
   runIndexesMigrations,
@@ -110,16 +109,6 @@ isConsistent env = do
     Consistent -> pure True
     _otherwise -> pure False
 
-getIsConsumedFixed :: SyncEnv -> IO (Maybe Word64)
-getIsConsumedFixed env =
-  case (DB.pcmPruneTxOut pcm, DB.pcmConsumedTxOut pcm) of
-    (False, True) -> Just <$> DB.runDbIohkNoLogging backend (DB.queryWrongConsumedBy txOutVariantType)
-    _otherwise -> pure Nothing
-  where
-    txOutVariantType = getTxOutVariantType env
-    pcm = soptPruneConsumeMigration $ envOptions env
-    backend = envDbEnv env
-
 getDisableInOutState :: SyncEnv -> IO Bool
 getDisableInOutState syncEnv = do
   bst <- readTVarIO $ envBootstrap syncEnv

cardano-db-sync/src/Cardano/DbSync/Cache/Epoch.hs

@@ -2,7 +2,6 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module Cardano.DbSync.Cache.Epoch (
-  readCacheEpoch,
   readEpochBlockDiffFromCache,
   readLastMapEpochFromCache,
   rollbackMapEpochInCache,
@@ -25,14 +24,6 @@ import Data.Map.Strict (deleteMin, insert, lookupMax, size, split)
 -------------------------------------------------------------------------------------
 -- Epoch Cache
 -------------------------------------------------------------------------------------
-readCacheEpoch :: MonadIO m => CacheStatus -> m (Maybe CacheEpoch)
-readCacheEpoch cache =
-  case cache of
-    NoCache -> pure Nothing
-    ActiveCache ci -> do
-      cacheEpoch <- liftIO $ readTVarIO (cEpoch ci)
-      pure $ Just cacheEpoch
-
 readEpochBlockDiffFromCache :: MonadIO m => CacheStatus -> m (Maybe EpochBlockDiff)
 readEpochBlockDiffFromCache cache =
   case cache of

cardano-db-sync/src/Cardano/DbSync/Cache/LRU.hs

@@ -8,8 +8,6 @@ module Cardano.DbSync.Cache.LRU (
   optimise,
   trim,
   insert,
-  fromList,
-  delete,
   lookup,
   getSize,
   getCapacity,
@@ -76,14 +74,6 @@ insert k v cache =
   where
     (_mbOldVal, queue) = OrdPSQ.insertView k (cTick cache) v (cQueue cache) -- Insert the new entry
 
--- fromList inserts into a cache from a list of key-value pairs.
-fromList :: Ord k => [(k, v)] -> LRUCache k v -> LRUCache k v
-fromList kvs cache = foldl' (\c (k, v) -> insert k v c) cache kvs
-
-delete :: Ord k => k -> LRUCache k v -> LRUCache k v
-delete key cache =
-  cache {cQueue = OrdPSQ.delete key (cQueue cache)}
-
 -- lookup retrieves a value from the cache by its key, updating the access order.
 -- It returns the value and the updated cache.
 lookup :: Ord k => k -> LRUCache k v -> Maybe (v, LRUCache k v)

cardano-db-sync/src/Cardano/DbSync/Config.hs

@@ -15,7 +15,6 @@ module Cardano.DbSync.Config (
   SyncProtocol (..),
   SyncNodeConfig (..),
   SyncNodeParams (..),
-  cardanoLedgerConfig,
   genesisProtocolMagicId,
   readCardanoGenesisConfig,
   readSyncNodeConfig,

cardano-db-sync/src/Cardano/DbSync/Config/Cardano.hs

@@ -7,7 +7,6 @@
 
 module Cardano.DbSync.Config.Cardano (
   GenesisConfig (..),
-  cardanoLedgerConfig,
   genesisProtocolMagicId,
   mkTopLevelConfig,
   mkProtocolInfoCardano,
@@ -36,7 +35,6 @@ import qualified Ouroboros.Consensus.Cardano as Consensus
 import Ouroboros.Consensus.Cardano.Block (StandardCrypto)
 import Ouroboros.Consensus.Cardano.Node
 import Ouroboros.Consensus.Config (TopLevelConfig (..), emptyCheckpointsMap)
-import Ouroboros.Consensus.Ledger.Basics (LedgerConfig)
 import Ouroboros.Consensus.Node.ProtocolInfo (ProtocolInfo)
 import qualified Ouroboros.Consensus.Node.ProtocolInfo as Consensus
 import Ouroboros.Consensus.Shelley.Node (ShelleyGenesis (..))
@@ -72,9 +70,6 @@ readCardanoGenesisConfig enc =
 
 -- -------------------------------------------------------------------------------------------------
 
-cardanoLedgerConfig :: GenesisConfig -> LedgerConfig CardanoBlock
-cardanoLedgerConfig = topLevelConfigLedger . mkTopLevelConfig
-
 mkTopLevelConfig :: GenesisConfig -> TopLevelConfig CardanoBlock
 mkTopLevelConfig cfg = Consensus.pInfoConfig $ fst $ mkProtocolInfoCardano cfg []
 

cardano-db-sync/src/Cardano/DbSync/DbEvent.hs

@@ -14,15 +14,13 @@ module Cardano.DbSync.DbEvent (
   writeDbEventQueue,
   waitRollback,
   waitRestartState,
-  waitDoneInit,
-  runAndSetDone,
 ) where
 
 import qualified Cardano.Db as DB
 import Cardano.DbSync.Error (SyncNodeError (..))
 import Cardano.DbSync.Types
 import Cardano.Prelude
-import Control.Concurrent.Class.MonadSTM.Strict (StrictTMVar, StrictTVar, newEmptyTMVarIO, newTVarIO, readTVar, readTVarIO, takeTMVar, writeTVar)
+import Control.Concurrent.Class.MonadSTM.Strict (StrictTMVar, StrictTVar, newEmptyTMVarIO, newTVarIO, takeTMVar)
 import qualified Control.Concurrent.STM as STM
 import Control.Concurrent.STM.TBQueue (TBQueue)
 import qualified Control.Concurrent.STM.TBQueue as TBQ
@@ -82,21 +80,6 @@ waitRestartState tc = do
     writeDbEventQueue tc $ DbRestartState resultVar
   atomically $ takeTMVar resultVar
 
-waitDoneInit :: ThreadChannels -> IO ()
-waitDoneInit tc = atomically $ do
-  isDone <- readTVar (tcDoneInit tc)
-  unless isDone retry
-
-runAndSetDone :: ThreadChannels -> IO Bool -> IO Bool
-runAndSetDone tc action = do
-  isDone <- readTVarIO (tcDoneInit tc)
-  if isDone
-    then pure True
-    else do
-      fl <- action
-      atomically $ writeTVar (tcDoneInit tc) fl
-      pure fl
-
 lengthDbEventQueue :: ThreadChannels -> STM Natural
 lengthDbEventQueue = STM.lengthTBQueue . tcQueue
 

cardano-db-sync/src/Cardano/DbSync/Era/Byron/Util.hs

@@ -4,20 +4,14 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 
 module Cardano.DbSync.Era.Byron.Util (
-  boundaryEpochNumber,
-  configSlotDuration,
   mkSlotLeader,
   slotLeaderHash,
   unAbstractHash,
-  unAddressHash,
-  unCryptoHash,
   blockHash,
   blockNumber,
   blockPayload,
   blockPreviousHash,
   ebbPrevHash,
-  prevHash,
-  epochNumber,
   genesisToHeaderHash,
   protocolVersion,
   renderAbstractHash,
@@ -45,14 +39,6 @@ import qualified Data.ByteString.Base16 as Base16
 import qualified Data.ByteString.Char8 as BS
 import qualified Data.ByteString.Lazy.Char8 as LBS
 import qualified Data.Text.Encoding as Text
-import qualified Ouroboros.Consensus.Byron.Ledger.Block as Byron
-
-boundaryEpochNumber :: Byron.ABoundaryBlock ByteString -> Word64
-boundaryEpochNumber = Byron.boundaryEpoch . Byron.boundaryHeader
-
-configSlotDuration :: Byron.Config -> Word64
-configSlotDuration =
-  fromIntegral . Byron.ppSlotDuration . Byron.gdProtocolParameters . Byron.configGenesisData
 
 mkSlotLeader :: Byron.ABlock ByteString -> DB.SlotLeader
 mkSlotLeader blk =
@@ -75,12 +61,6 @@ slotLeaderHash =
 unAbstractHash :: Crypto.Hash Raw -> ByteString
 unAbstractHash = Crypto.abstractHashToBytes
 
-unAddressHash :: Byron.AddressHash Byron.Address' -> ByteString
-unAddressHash = Crypto.abstractHashToBytes
-
-unCryptoHash :: Crypto.Hash Raw -> ByteString
-unCryptoHash = Crypto.abstractHashToBytes
-
 blockHash :: Byron.ABlock ByteString -> ByteString
 blockHash = unHeaderHash . Byron.blockHashAnnotated
 
@@ -101,15 +81,6 @@ ebbPrevHash bblock =
     Left gh -> genesisToHeaderHash gh
     Right hh -> unHeaderHash hh
 
-prevHash :: Byron.ByronBlock -> ByteString
-prevHash blk = case Byron.byronBlockRaw blk of
-  Byron.ABOBBlock ablk -> blockPreviousHash ablk
-  Byron.ABOBBoundary abblk -> ebbPrevHash abblk
-
-epochNumber :: Byron.ABlock ByteString -> Word64 -> Word64
-epochNumber blk slotsPerEpoch =
-  slotNumber blk `div` slotsPerEpoch
-
 genesisToHeaderHash :: Byron.GenesisHash -> ByteString
 genesisToHeaderHash = unAbstractHash . Byron.unGenesisHash
 

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/Metadata.hs

@@ -15,9 +15,7 @@ module Cardano.DbSync.Era.Shelley.Generic.Metadata (
   fromShelleyMetadata,
   fromMaryMetadata,
   metadataValueToJsonNoSchema,
-  txMetadataValueToText,
   fromMetadatum,
-  toMetadatum,
 ) where
 
 import qualified Cardano.Ledger.Allegra.TxAuxData as Allegra
@@ -93,14 +91,6 @@ metadataValueToJsonNoSchema = conv
         . Aeson.Text.encodeToLazyText
         $ conv v
 
-txMetadataValueToText :: TxMetadataValue -> Text
-txMetadataValueToText val
-  | (TxMetaMap pairs) <- val = Text.intercalate ", " $ map (\(k, v) -> txMetadataValueToText k <> ": " <> txMetadataValueToText v) pairs
-  | (TxMetaList values) <- val = "[" <> Text.intercalate ", " (map txMetadataValueToText values) <> "]"
-  | (TxMetaNumber num) <- val = Text.pack (show num)
-  | (TxMetaBytes bytes) <- val = Text.decodeUtf8 bytes
-  | (TxMetaText text) <- val = text
-
 -- -------------------------------------------------------------------------------------------------
 
 -- | JSON strings that are base16 encoded and prefixed with 'bytesPrefix' will
@@ -115,11 +105,3 @@ fromMetadatum = \case
   Shelley.S x -> TxMetaText x
   Shelley.List xs -> TxMetaList $ map fromMetadatum xs
   Shelley.Map xs -> TxMetaMap $ map (both fromMetadatum) xs
-
-toMetadatum :: TxMetadataValue -> Shelley.Metadatum
-toMetadatum = \case
-  TxMetaNumber n -> Shelley.I n
-  TxMetaBytes b -> Shelley.B b
-  TxMetaText s -> Shelley.S s
-  TxMetaList xs -> Shelley.List $ map toMetadatum xs
-  TxMetaMap ms -> Shelley.Map $ map (both toMetadatum) ms

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/Rewards.hs

@@ -9,10 +9,9 @@ module Cardano.DbSync.Era.Shelley.Generic.Rewards (
   RewardRest (..),
   RewardRests (..),
   rewardsCount,
-  rewardsTotalAda,
 ) where
 
-import Cardano.Db (Ada, RewardSource (..), word64ToAda)
+import Cardano.Db (RewardSource (..))
 import Cardano.DbSync.Types
 import Cardano.Ledger.Coin (Coin (..))
 import Cardano.Prelude
@@ -45,11 +44,3 @@ newtype RewardRests = RewardRests
 
 rewardsCount :: Rewards -> Int
 rewardsCount = sum . map Set.size . Map.elems . unRewards
-
-rewardsTotalAda :: Rewards -> Ada
-rewardsTotalAda rwds =
-  word64ToAda
-    . fromIntegral
-    . sum
-    . concatMap (map (unCoin . rewardAmount) . Set.toList)
-    $ Map.elems (unRewards rwds)