[CDEC-509] Remove HasGenesisBlockVersionData

auxx/src/Command/Tx.hs

@@ -39,11 +39,10 @@ import           Pos.Client.Txp.Balances (getOwnUtxoForPk)
 import           Pos.Client.Txp.Network (prepareMTx, submitTxRaw)
 import           Pos.Client.Txp.Util (createTx)
 import           Pos.Core as Core (Config (..), IsBootstrapEraAddr (..),
-                     Timestamp (..), configEpochSlots, deriveFirstHDAddress,
-                     makePubKeyAddress, mkCoin)
+                     Timestamp (..), configBlockVersionData, configEpochSlots,
+                     deriveFirstHDAddress, makePubKeyAddress, mkCoin)
 import           Pos.Core.Conc (concurrently, currentTime, delay,
                      forConcurrently, modifySharedAtomic, newSharedAtomic)
-import           Pos.Core.Configuration (genesisBlockVersionData)
 import           Pos.Core.Txp (TxAux (..), TxIn (TxInUtxo), TxOut (..),
                      TxOutAux (..), txaF)
 import           Pos.Core.Update (BlockVersionData (..))
@@ -93,7 +92,7 @@ sendToAllGenesis
     -> SendToAllGenesisParams
     -> m ()
 sendToAllGenesis coreConfig keysToSend diffusion (SendToAllGenesisParams genesisTxsPerThread txsPerThread conc delay_ tpsSentFile) = do
-    let genesisSlotDuration = fromIntegral (toMicroseconds $ bvdSlotDuration genesisBlockVersionData) `div` 1000000 :: Int
+    let genesisSlotDuration = fromIntegral (toMicroseconds $ bvdSlotDuration (configBlockVersionData coreConfig)) `div` 1000000 :: Int
     tpsMVar <- newSharedAtomic $ TxCount 0 conc
     startTime <- show . toInteger . getTimestamp . Timestamp <$> currentTime
     bracket (openFile tpsSentFile WriteMode) (liftIO . hClose) $ \h -> do

chain/src/Pos/Chain/Update/Poll/Class.hs

@@ -77,9 +77,9 @@ class (Monad m, WithLogger m) => MonadPollRead m where
     -- ^ Get active proposals for the specified application.
     getConfirmedProposals :: m [ConfirmedProposalState]
     -- ^ Get all known confirmed proposals.
-    getEpochTotalStake :: EpochIndex -> m (Maybe Coin)
+    getEpochTotalStake :: BlockVersionData -> EpochIndex -> m (Maybe Coin)
     -- ^ Get total stake from distribution corresponding to given epoch
-    getRichmanStake :: EpochIndex -> StakeholderId -> m (Maybe Coin)
+    getRichmanStake :: BlockVersionData -> EpochIndex -> StakeholderId -> m (Maybe Coin)
     -- ^ Get stake of ricmhan corresponding to given epoch (if she is
     -- really rich)
     getOldProposals :: SlotId -> m [UndecidedProposalState]
@@ -115,8 +115,8 @@ instance {-# OVERLAPPABLE #-}
     getProposal = lift . getProposal
     getProposalsByApp = lift . getProposalsByApp
     getConfirmedProposals = lift getConfirmedProposals
-    getEpochTotalStake = lift . getEpochTotalStake
-    getRichmanStake e = lift . getRichmanStake e
+    getEpochTotalStake genesisBvd = lift . getEpochTotalStake genesisBvd
+    getRichmanStake genesisBvd e = lift . getRichmanStake genesisBvd e
     getOldProposals = lift . getOldProposals
     getDeepProposals = lift . getDeepProposals
     getBlockIssuerStake e = lift . getBlockIssuerStake e
@@ -309,8 +309,8 @@ instance (MonadPollRead m) =>
         MM.valuesM
             (map (first cpsSoftwareVersion . join (,)) <$> getConfirmedProposals) =<<
         use pmConfirmedPropsL
-    getEpochTotalStake = lift . getEpochTotalStake
-    getRichmanStake e = lift . getRichmanStake e
+    getEpochTotalStake genesisBvd = lift . getEpochTotalStake genesisBvd
+    getRichmanStake genesisBvd e = lift . getRichmanStake genesisBvd e
     getOldProposals sl = ether $
         map snd <$>
         (MM.mapMaybeM getOldProposalPairs extractOld =<< use pmActivePropsL)

chain/test/Test/Pos/Chain/Lrc/Arbitrary.hs

@@ -16,11 +16,10 @@ import           Test.QuickCheck.Arbitrary.Generic (genericShrink)
 import           Pos.Chain.Lrc (RichmenStakes)
 import           Pos.Core.Common (Coin, CoinPortion, coinPortionToDouble,
                      mkCoin, unsafeAddCoin, unsafeGetCoin, unsafeSubCoin)
-import           Pos.Core.Configuration (HasGenesisBlockVersionData,
-                     genesisBlockVersionData)
 import           Pos.Core.Update (BlockVersionData (bvdMpcThd))
 
 import           Test.Pos.Core.Arbitrary ()
+import           Test.Pos.Core.Dummy (dummyBlockVersionData)
 
 -- | Wrapper over 'RichmenStakes'. Its 'Arbitrary' instance enforces that the
 -- stake distribution inside must be valid with respect to the threshold
@@ -76,5 +75,5 @@ genRichmenStakes thd = do
 
 data GenesisMpcThd
 
-instance HasGenesisBlockVersionData => Reifies GenesisMpcThd CoinPortion where
-    reflect _ = bvdMpcThd genesisBlockVersionData
+instance Reifies GenesisMpcThd CoinPortion where
+    reflect _ = bvdMpcThd dummyBlockVersionData

client/test/Test/Pos/Client/Txp/Mode.hs

@@ -22,12 +22,12 @@ import           Pos.Chain.Update (HasUpdateConfiguration)
 import           Pos.Client.Txp.Addresses (MonadAddresses (..))
 import           Pos.Configuration (HasNodeConfiguration)
 import           Pos.Core (Address, HasConfiguration, makePubKeyAddressBoot)
-import           Pos.Core.Configuration (HasGenesisBlockVersionData,
-                     genesisBlockVersionData)
 import           Pos.Core.Update (BlockVersionData)
 import           Pos.Crypto (deterministicKeyGen)
 import           Pos.DB (MonadGState (..))
 
+import           Test.Pos.Core.Dummy (dummyBlockVersionData)
+
 ----------------------------------------------------------------------------
 -- Configuration propagation
 ----------------------------------------------------------------------------
@@ -37,7 +37,6 @@ type HasTxpConfigurations =
        , HasSscConfiguration
        , HasConfiguration
        , HasUpdateConfiguration
-       , HasGenesisBlockVersionData
        )
 
 ----------------------------------------------------------------------------
@@ -86,5 +85,5 @@ instance MonadAddresses TxpTestProperty where
     getNewAddress epochSlots = lift . getNewAddress epochSlots
     getFakeChangeAddress = lift . getFakeChangeAddress
 
-instance (HasTxpConfigurations, Testable a) => Testable (TxpTestProperty a) where
-    property = monadic (ioProperty . flip runReaderT genesisBlockVersionData)
+instance Testable a => Testable (TxpTestProperty a) where
+    property = monadic (ioProperty . flip runReaderT dummyBlockVersionData)

core/cardano-sl-core.cabal

@@ -94,7 +94,6 @@ library
                        Pos.Core.Common.TxSizeLinear
 
                        -- Configuration
-                       Pos.Core.Configuration.BlockVersionData
                        Pos.Core.Configuration.Core
                        Pos.Core.Configuration.GenesisHash
 

core/src/Pos/Core/Configuration.hs

@@ -46,7 +46,6 @@ import qualified Text.JSON.Canonical as Canonical
 
 import           Pos.Binary.Class (Raw)
 import           Pos.Core.Common (BlockCount, SharedSeed)
-import           Pos.Core.Configuration.BlockVersionData as E
 import           Pos.Core.Configuration.Core as E
 import           Pos.Core.Configuration.GenesisHash as E
 import           Pos.Core.Genesis (GeneratedSecrets, GenesisAvvmBalances,
@@ -136,10 +135,7 @@ configFtsSeed :: Config -> SharedSeed
 configFtsSeed = gdFtsSeed . configGenesisData
 
 -- | Coarse catch-all configuration constraint for use by depending modules.
-type HasConfiguration =
-    ( HasCoreConfiguration
-    , HasGenesisBlockVersionData
-    )
+type HasConfiguration = HasCoreConfiguration
 
 canonicalGenesisJson :: GenesisData -> (BSL.ByteString, Hash Raw)
 canonicalGenesisJson theGenesisData = (canonicalJsonBytes, jsonHash)
@@ -210,7 +206,6 @@ withCoreConfigurations conf@CoreConfiguration{..} fn confDir mSystemStart mSeed
                      (show theGenesisHash) (show expectedHash)
 
         withCoreConfiguration conf $
-            withGenesisBlockVersionData (gdBlockVersionData theGenesisData) $
             act $
             Config
                 { configProtocolMagic     = pm
@@ -252,7 +247,6 @@ withGenesisSpec
 withGenesisSpec theSystemStart conf@CoreConfiguration{..} fn val = case ccGenesis of
     GCSrc {} -> error "withGenesisSpec called with GCSrc"
     GCSpec spec ->
-        withGenesisBlockVersionData (gsBlockVersionData spec) $
             let
                 -- Generate
                 GeneratedGenesisData {..} =
@@ -272,7 +266,7 @@ withGenesisSpec theSystemStart conf@CoreConfiguration{..} fn val = case ccGenesi
                       , gdStartTime        = theSystemStart
                       , gdVssCerts         = ggdVssCerts
                       , gdNonAvvmBalances  = ggdNonAvvm
-                      , gdBlockVersionData = genesisBlockVersionData
+                      , gdBlockVersionData = gsBlockVersionData spec
                       , gdProtocolConsts   = gsProtocolConstants spec
                       , gdAvvmDistr        = ggdAvvm
                       , gdFtsSeed          = gsFtsSeed spec

core/test/Test/Pos/Core/Arbitrary.hs

@@ -52,7 +52,6 @@ import           Pos.Core (AddrAttributes (..), AddrSpendingData (..),
                      mkMultiKeyDistr, unsafeCoinPortionFromDouble,
                      unsafeGetCoin, unsafeSubCoin)
 import           Pos.Core.Attributes (Attributes (..), UnparsedFields (..))
-import           Pos.Core.Configuration (HasGenesisBlockVersionData)
 import           Pos.Core.Constants (sharedSeedLength)
 import           Pos.Core.Delegation (HeavyDlgIndex (..), LightDlgIndices (..))
 import qualified Pos.Core.Genesis as G
@@ -511,7 +510,7 @@ instance Arbitrary TxFeePolicy where
 -- Arbitrary types from 'Pos.Core.Genesis'
 ----------------------------------------------------------------------------
 
-instance HasGenesisBlockVersionData => Arbitrary G.TestnetBalanceOptions where
+instance Arbitrary G.TestnetBalanceOptions where
     arbitrary = do
         -- We have at least 2 owned addresses in system so we can send
         -- transactions in block-gen/tests.

core/test/Test/Pos/Core/Dummy.hs

@@ -18,6 +18,7 @@ module Test.Pos.Core.Dummy
        , dummyGenesisSecretsPoor
        , dummyCoreConfiguration
        , dummyGenesisSpec
+       , dummyBlockVersionData
        , dummyGenesisData
        , dummyGenesisDataStartTime
        , dummyGenesisHash

db/src/Pos/DB/Block/Logic/Creation.hs

@@ -35,9 +35,9 @@ import           Pos.Chain.Update (HasUpdateConfiguration, curSoftwareVersion,
                      lastKnownBlockVersion)
 import           Pos.Core as Core (BlockCount, Config (..), EpochIndex,
                      EpochOrSlot (..), SlotId (..), configBlkSecurityParam,
-                     configEpochSlots, epochIndexL, flattenSlotId,
-                     getEpochOrSlot, kChainQualityThreshold, kEpochSlots,
-                     localSlotIndexMinBound)
+                     configBlockVersionData, configEpochSlots, epochIndexL,
+                     flattenSlotId, getEpochOrSlot, kChainQualityThreshold,
+                     kEpochSlots, localSlotIndexMinBound)
 import           Pos.Core.Context (HasPrimaryKey, getOurSecretKey)
 import           Pos.Core.Exception (assertionFailed, reportFatalError)
 import           Pos.Core.JsonLog (CanJsonLog (..))
@@ -273,7 +273,7 @@ createMainBlockInternal coreConfig sId pske = do
     msgFmt = "We are trying to create main block, our tip header is\n"%build
     createMainBlockFinish :: BlockHeader -> ExceptT Text m MainBlock
     createMainBlockFinish prevHeader = do
-        rawPay <- lift $ getRawPayload k (headerHash prevHeader) sId
+        rawPay <- lift $ getRawPayload coreConfig (headerHash prevHeader) sId
         sk <- getOurSecretKey
         -- 100 bytes is substracted to account for different unexpected
         -- overhead.  You can see that in bitcoin blocks are 1-2kB less
@@ -426,14 +426,14 @@ data RawPayload = RawPayload
     }
 
 getRawPayload :: MonadCreateBlock ctx m
-    => BlockCount
+    => Core.Config
     -> HeaderHash
     -> SlotId
     -> m RawPayload
-getRawPayload k tip slotId = do
+getRawPayload coreConfig tip slotId = do
     localTxs <- txGetPayload tip -- result is topsorted
-    sscData <- sscGetLocalPayload k slotId
-    usPayload <- usPreparePayload tip slotId
+    sscData <- sscGetLocalPayload (configBlkSecurityParam coreConfig) slotId
+    usPayload <- usPreparePayload (configBlockVersionData coreConfig) tip slotId
     dlgPayload <- getDlgMempool
     let rawPayload =
             RawPayload

db/src/Pos/DB/Block/Logic/Internal.hs

@@ -43,7 +43,7 @@ import           Pos.Chain.Ssc (HasSscConfiguration, MonadSscMem, SscBlock)
 import           Pos.Chain.Txp (TxpConfiguration)
 import           Pos.Chain.Update (PollModifier)
 import           Pos.Core as Core (Config (..), configBlkSecurityParam,
-                     configEpochSlots, epochIndexL)
+                     configBlockVersionData, configEpochSlots, epochIndexL)
 import           Pos.Core.Chrono (NE, NewestFirst (..), OldestFirst (..))
 import           Pos.Core.Exception (assertionFailed)
 import           Pos.Core.Reporting (MonadReporting)
@@ -133,7 +133,7 @@ normalizeMempool coreConfig txpConfig = do
     -- within block application.
     sscNormalize coreConfig
     txpNormalize coreConfig txpConfig
-    usNormalize
+    usNormalize (configBlockVersionData coreConfig)
 
 -- | Applies a definitely valid prefix of blocks. This function is unsafe,
 -- use it only if you understand what you're doing. That means you can break
@@ -236,7 +236,7 @@ rollbackBlocksUnsafe coreConfig bsc scb toRollback = do
     -- We don't normalize other mempools, because they are normalized
     -- in 'applyBlocksUnsafe' and we always ensure that some blocks
     -- are applied after rollback.
-    dlgNormalizeOnRollback $ configProtocolMagic coreConfig
+    dlgNormalizeOnRollback coreConfig
     sanityCheckDB $ configGenesisData coreConfig
 
 

db/src/Pos/DB/Block/Logic/VAR.hs

@@ -100,8 +100,7 @@ verifyBlocksPrefix coreConfig currentSlot blocks = runExceptT $ do
     TxpGlobalSettings {..} <- view (lensOf @TxpGlobalSettings)
     txUndo <- withExceptT (VerifyBlocksError . pretty) $
         ExceptT $ tgsVerifyBlocks dataMustBeKnown $ map toTxpBlock blocks
-    pskUndo <- withExceptT VerifyBlocksError
-        $ dlgVerifyBlocks (configProtocolMagic coreConfig) blocks
+    pskUndo <- withExceptT VerifyBlocksError $ dlgVerifyBlocks coreConfig blocks
     (pModifier, usUndos) <- withExceptT (VerifyBlocksError . pretty) $
         ExceptT $ usVerifyBlocks coreConfig dataMustBeKnown (map toUpdateBlock blocks)
 

db/src/Pos/DB/Block/Lrc.hs

@@ -30,8 +30,9 @@ import           Pos.Chain.Ssc (MonadSscMem, noReportNoSecretsForEpoch1)
 import           Pos.Chain.Update (BlockVersionState (..))
 import           Pos.Core as Core (Coin, Config (..), EpochIndex,
                      EpochOrSlot (..), SharedSeed, SlotCount, StakeholderId,
-                     configBlkSecurityParam, configEpochSlots, configK,
-                     crucialSlot, epochIndexL, getEpochOrSlot)
+                     configBlkSecurityParam, configBlockVersionData,
+                     configEpochSlots, configK, crucialSlot, epochIndexL,
+                     getEpochOrSlot)
 import           Pos.Core.Chrono (NE, NewestFirst (..), toOldestFirst)
 import           Pos.Core.Conc (forConcurrently)
 import           Pos.Core.Reporting (HasMisbehaviorMetrics (..),
@@ -87,7 +88,7 @@ lrcSingleShot coreConfig epoch = do
          %build) epoch
     tryAcquireExclusiveLock epoch lock onAcquiredLock
   where
-    consumers = allLrcConsumers @ctx @m
+    consumers = allLrcConsumers @ctx @m (configBlockVersionData coreConfig)
     for_thEpochMsg = sformat (" for "%ords%" epoch") epoch
     onAcquiredLock = do
         logDebug "lrcSingleShot has acquired LRC lock"
@@ -153,7 +154,7 @@ lrcDo coreConfig epoch consumers = do
     blundsToRollback <- DB.loadBlundsFromTipWhile genesisHash whileAfterCrucial
     blundsToRollbackNE <-
         maybeThrow UnknownBlocksForLrc (atLeastKNewestFirst blundsToRollback)
-    seed <- sscCalculateSeed epoch >>= \case
+    seed <- sscCalculateSeed (configBlockVersionData coreConfig) epoch >>= \case
         Right s -> do
             logInfo $ sformat
                 ("Calculated seed for epoch "%build%" successfully") epoch

db/src/Pos/DB/Delegation/Logic/Mempool.hs

@@ -30,11 +30,12 @@ import           Pos.Chain.Delegation (DlgMemPool, DlgPayload (..),
                      MonadDelegation, cmPskMods, dwMessageCache, dwPoolSize,
                      dwProxySKPool, dwTip, emptyCedeModifier, isRevokePsk,
                      pskToDlgEdgeAction)
-import           Pos.Core (addressHash, epochIndexL)
+import           Pos.Core as Core (Config (..), addressHash,
+                     configBlockVersionData, epochIndexL)
 import           Pos.Core.Conc (currentTime)
 import           Pos.Core.Delegation (ProxySKHeavy)
 import           Pos.Core.Update (bvdMaxBlockSize)
-import           Pos.Crypto (ProtocolMagic, ProxySecretKey (..), PublicKey)
+import           Pos.Crypto (ProxySecretKey (..), PublicKey)
 import           Pos.DB (MonadDBRead, MonadGState)
 import qualified Pos.DB as DB
 import           Pos.DB.Delegation.Cede.Holders (evalMapCede)
@@ -128,25 +129,27 @@ processProxySKHeavy
        , HasLens' ctx StateLock
        , MonadMask m
        )
-    => ProtocolMagic -> ProxySKHeavy -> m PskHeavyVerdict
-processProxySKHeavy pm psk =
+    => Core.Config -> ProxySKHeavy -> m PskHeavyVerdict
+processProxySKHeavy coreConfig psk =
     withStateLockNoMetrics LowPriority $ \_stateLockHeader ->
-        processProxySKHeavyInternal pm psk
+        processProxySKHeavyInternal coreConfig psk
 
 -- | Main logic of heavy psk processing, doesn't have
 -- synchronization. Should be called __only__ if you are sure that
 -- 'StateLock' is taken already.
 processProxySKHeavyInternal ::
        forall ctx m. (ProcessHeavyConstraint ctx m)
-    => ProtocolMagic
+    => Core.Config
     -> ProxySKHeavy
     -> m PskHeavyVerdict
-processProxySKHeavyInternal pm psk = do
+processProxySKHeavyInternal coreConfig psk = do
     curTime <- microsecondsToUTC <$> currentTime
     dbTip <- DB.getTipHeader
     let dbTipHash = headerHash dbTip
     let headEpoch = dbTip ^. epochIndexL
-    richmen <- getDlgRichmen "Delegation.Logic#processProxySKHeavy" headEpoch
+    richmen <- getDlgRichmen (configBlockVersionData coreConfig)
+                             "Delegation.Logic#processProxySKHeavy"
+                             headEpoch
     maxBlockSize <- bvdMaxBlockSize <$> DB.gsAdoptedBVData
     let iPk = pskIssuerPk psk
 
@@ -169,7 +172,11 @@ processProxySKHeavyInternal pm psk = do
                      (const (error "processProxySKHeavyInternal:can't happen",True))) $
         evalMapCede cedeModifier $
         runExceptT $
-        dlgVerifyPskHeavy pm richmen (CheckForCycle True) headEpoch psk
+        dlgVerifyPskHeavy (configProtocolMagic coreConfig)
+                          richmen
+                          (CheckForCycle True)
+                          headEpoch
+                          psk
 
     -- Here the memory state is the same.
     runDelegationStateAction $ do