[release/1.3.1] [CO-354] Introduce NetworkMagic

auxx/src/Command/Proc.hs

@@ -22,6 +22,7 @@ import           Pos.Core (AddrStakeDistribution (..), Address, HeavyDlgIndex (.
                            unsafeGetCoin)
 import           Pos.Core.Common (AddrAttributes (..), AddrSpendingData (..), makeAddress)
 import           Pos.Core.Configuration (genesisSecretKeys)
+import           Pos.Core.NetworkMagic (NetworkMagic (..))
 import           Pos.Core.Txp (TxOut (..))
 import           Pos.Crypto (ProtocolMagic, PublicKey, emptyPassphrase, encToPublic, fullPublicKeyF,
                              hashHexF, noPassEncrypt, safeCreatePsk, unsafeCheatingHashCoerce,
@@ -103,9 +104,9 @@ createCommandProcs mpm hasAuxxMode printAction mDiffusion = rights . fix $ \comm
     , cpExec = \(pk', mDistr) -> do
         pk <- toLeft pk'
         addr <- case mDistr of
-            Nothing -> makePubKeyAddressAuxx pk
+            Nothing -> makePubKeyAddressAuxx fixedNM pk
             Just distr -> return $
-                makeAddress (PubKeyASD pk) (AddrAttributes Nothing distr)
+                makeAddress (PubKeyASD pk) (AddrAttributes Nothing distr fixedNM)
         return $ ValueAddress addr
     , cpHelp = "address for the specified public key. a stake distribution \
              \ can be specified manually (by default it uses the current epoch \
@@ -123,7 +124,7 @@ createCommandProcs mpm hasAuxxMode printAction mDiffusion = rights . fix $ \comm
         sk <- evaluateWHNF (sks !! i) -- WHNF is sufficient to force possible errors
                                       -- from using (!!). I'd use NF but there's no
                                       -- NFData instance for secret keys.
-        addrHD <- deriveHDAddressAuxx sk
+        addrHD <- deriveHDAddressAuxx fixedNM sk
         return $ ValueAddress addrHD
     , cpHelp = "address of the HD wallet for the specified public key"
     },
@@ -474,8 +475,8 @@ createCommandProcs mpm hasAuxxMode printAction mDiffusion = rights . fix $ \comm
         printAction "Available addresses:"
         for_ (zip [0 :: Int ..] sks) $ \(i, sk) -> do
             let pk = encToPublic sk
-            addr <- makePubKeyAddressAuxx pk
-            addrHD <- deriveHDAddressAuxx sk
+            addr <- makePubKeyAddressAuxx fixedNM pk
+            addrHD <- deriveHDAddressAuxx fixedNM sk
             printAction $
                 sformat ("    #"%int%":   addr:      "%build%"\n"%
                          "          pk:        "%fullPublicKeyF%"\n"%
@@ -484,7 +485,7 @@ createCommandProcs mpm hasAuxxMode printAction mDiffusion = rights . fix $ \comm
                     i addr pk (addressHash pk) addrHD
         walletMB <- (^. usWallet) <$> (view userSecret >>= atomically . readTVar)
         whenJust walletMB $ \wallet -> do
-            addrHD <- deriveHDAddressAuxx (_wusRootKey wallet)
+            addrHD <- deriveHDAddressAuxx fixedNM (_wusRootKey wallet)
             printAction $
                 sformat ("    Wallet address:\n"%
                          "          HD addr:   "%build)
@@ -536,11 +537,15 @@ instance MonadAuxxMode m => ToLeft m StakeholderId PublicKey where
     toLeft = return . either identity addressHash
 
 instance MonadAuxxMode m => ToLeft m Address PublicKey where
-    toLeft = either return makePubKeyAddressAuxx
+    toLeft = either return (makePubKeyAddressAuxx fixedNM)
 
 getPublicKeyFromIndex :: MonadAuxxMode m => Int -> m PublicKey
 getPublicKeyFromIndex i = do
     sks <- getSecretKeysPlain
     let sk = sks !! i
         pk = encToPublic sk
     evaluateNF pk
+
+
+fixedNM :: NetworkMagic
+fixedNM = NMNothing

auxx/src/Command/Tx.hs

@@ -40,6 +40,7 @@ import           Pos.Client.Txp.Util (createTx)
 import           Pos.Core (BlockVersionData (bvdSlotDuration), IsBootstrapEraAddr (..),
                            Timestamp (..), deriveFirstHDAddress, makePubKeyAddress, mkCoin)
 import           Pos.Core.Configuration (genesisBlockVersionData, genesisSecretKeys)
+import           Pos.Core.NetworkMagic (NetworkMagic (..))
 import           Pos.Core.Txp (TxAux (..), TxIn (TxInUtxo), TxOut (..), TxOutAux (..), txaF)
 import           Pos.Crypto (EncryptedSecretKey, ProtocolMagic, emptyPassphrase, encToPublic,
                              fakeSigner, hash, safeToPublic, toPublic, withSafeSigners)
@@ -108,13 +109,13 @@ sendToAllGenesis pm diffusion (SendToAllGenesisParams genesisTxsPerThread txsPer
                 let signer = fakeSigner secretKey
                     publicKey = toPublic secretKey
                 -- construct transaction output
-                outAddr <- makePubKeyAddressAuxx publicKey
+                outAddr <- makePubKeyAddressAuxx fixedNM publicKey
                 let txOut1 = TxOut {
                     txOutAddress = outAddr,
                     txOutValue = mkCoin 1
                     }
                     txOuts = TxOutAux txOut1 :| []
-                utxo <- getOwnUtxoForPk $ safeToPublic signer
+                utxo <- getOwnUtxoForPk fixedNM $ safeToPublic signer
                 etx <- createTx pm mempty utxo signer txOuts publicKey
                 case etx of
                     Left err -> logError (sformat ("Error: "%build%" while trying to contruct tx") err)
@@ -221,10 +222,10 @@ send
 send pm diffusion idx outputs = do
     skey <- takeSecret
     let curPk = encToPublic skey
-    let plainAddresses = map (flip makePubKeyAddress curPk . IsBootstrapEraAddr) [False, True]
+    let plainAddresses = map (flip (makePubKeyAddress fixedNM) curPk . IsBootstrapEraAddr) [False, True]
     let (hdAddresses, hdSecrets) = unzip $ map
             (\ibea -> fromMaybe (error "send: pass mismatch") $
-                    deriveFirstHDAddress (IsBootstrapEraAddr ibea) emptyPassphrase skey) [False, True]
+                    deriveFirstHDAddress fixedNM (IsBootstrapEraAddr ibea) emptyPassphrase skey) [False, True]
     let allAddresses = hdAddresses ++ plainAddresses
     let allSecrets = hdSecrets ++ [skey, skey]
     etx <- withSafeSigners allSecrets (pure emptyPassphrase) $ \signers -> runExceptT @AuxxException $ do
@@ -272,3 +273,6 @@ sendTxsFromFile diffusion txsFile = do
                 (topsortTxAuxes txAuxes)
         let submitOne = submitTxRaw diffusion
         mapM_ submitOne sortedTxAuxes
+
+fixedNM :: NetworkMagic
+fixedNM = NMNothing

auxx/src/Mode.hs

@@ -43,6 +43,7 @@ import           Pos.Context (HasNodeContext (..))
 import           Pos.Core (Address, HasConfiguration, HasPrimaryKey (..), IsBootstrapEraAddr (..),
                            deriveFirstHDAddress, largestPubKeyAddressBoot,
                            largestPubKeyAddressSingleKey, makePubKeyAddress, siEpoch)
+import           Pos.Core.NetworkMagic (NetworkMagic)
 import           Pos.Crypto (EncryptedSecretKey, PublicKey, emptyPassphrase)
 import           Pos.DB (DBSum (..), MonadGState (..), NodeDBs, gsIsBootstrapEra)
 import           Pos.DB.Class (MonadDB (..), MonadDBRead (..))
@@ -211,11 +212,11 @@ instance (HasConfigurations, HasCompileInfo) =>
          MonadAddresses AuxxMode where
     type AddrData AuxxMode = PublicKey
     getNewAddress = makePubKeyAddressAuxx
-    getFakeChangeAddress = do
+    getFakeChangeAddress nm = do
         epochIndex <- siEpoch <$> getCurrentSlotInaccurate
         gsIsBootstrapEra epochIndex <&> \case
-            False -> largestPubKeyAddressBoot
-            True -> largestPubKeyAddressSingleKey
+            False -> largestPubKeyAddressBoot nm
+            True -> largestPubKeyAddressSingleKey nm
 
 instance MonadKeysRead AuxxMode where
     getSecret = getSecretDefault
@@ -242,20 +243,22 @@ instance (HasConfigurations) =>
 -- whether we are currently in bootstrap era.
 makePubKeyAddressAuxx ::
        MonadAuxxMode m
-    => PublicKey
+    => NetworkMagic
+    -> PublicKey
     -> m Address
-makePubKeyAddressAuxx pk = do
+makePubKeyAddressAuxx nm pk = do
     epochIndex <- siEpoch <$> getCurrentSlotInaccurate
     ibea <- IsBootstrapEraAddr <$> gsIsBootstrapEra epochIndex
-    pure $ makePubKeyAddress ibea pk
+    pure $ makePubKeyAddress nm ibea pk
 
 -- | Similar to @makePubKeyAddressAuxx@ but create HD address.
 deriveHDAddressAuxx ::
        MonadAuxxMode m
-    => EncryptedSecretKey
+    => NetworkMagic
+    -> EncryptedSecretKey
     -> m Address
-deriveHDAddressAuxx hdwSk = do
+deriveHDAddressAuxx nm hdwSk = do
     epochIndex <- siEpoch <$> getCurrentSlotInaccurate
     ibea <- IsBootstrapEraAddr <$> gsIsBootstrapEra epochIndex
     pure $ fst $ fromMaybe (error "makePubKeyHDAddressAuxx: pass mismatch") $
-        deriveFirstHDAddress ibea emptyPassphrase hdwSk
+        deriveFirstHDAddress nm ibea emptyPassphrase hdwSk

block/src/Pos/Block/BListener.hs

@@ -16,32 +16,33 @@ import           Control.Monad.Trans (MonadTrans (..))
 import           Mockable (SharedAtomicT)
 
 import           Pos.Block.Types (Blund)
-import           Pos.DB.BatchOp (SomeBatchOp)
 import           Pos.Core.Chrono (NE, NewestFirst (..), OldestFirst (..))
+import           Pos.Core.NetworkMagic (NetworkMagic)
+import           Pos.DB.BatchOp (SomeBatchOp)
 
 class Monad m => MonadBListener m where
     -- Callback will be called after putting blocks into BlocksDB
     -- and before changing of GStateDB.
     -- Callback action will be performed under block lock.
-    onApplyBlocks :: OldestFirst NE Blund -> m SomeBatchOp
+    onApplyBlocks :: NetworkMagic -> OldestFirst NE Blund -> m SomeBatchOp
     -- Callback will be called before changing of GStateDB.
     -- Callback action will be performed under block lock.
-    onRollbackBlocks :: NewestFirst NE Blund -> m SomeBatchOp
+    onRollbackBlocks :: NetworkMagic -> NewestFirst NE Blund -> m SomeBatchOp
 
 instance {-# OVERLAPPABLE #-}
     ( MonadBListener m, Monad m, MonadTrans t, Monad (t m)
     , SharedAtomicT m ~ SharedAtomicT (t m) ) =>
         MonadBListener (t m)
   where
-    onApplyBlocks = lift . onApplyBlocks
-    onRollbackBlocks = lift . onRollbackBlocks
+    onApplyBlocks nm = lift . onApplyBlocks nm
+    onRollbackBlocks nm = lift . onRollbackBlocks nm
 
 onApplyBlocksStub
     :: Monad m
-    => OldestFirst NE Blund -> m SomeBatchOp
-onApplyBlocksStub _ = pure mempty
+    => NetworkMagic -> OldestFirst NE Blund -> m SomeBatchOp
+onApplyBlocksStub _ _ = pure mempty
 
 onRollbackBlocksStub
     :: Monad m
-    => NewestFirst NE Blund -> m SomeBatchOp
-onRollbackBlocksStub _ = pure mempty
+    => NetworkMagic -> NewestFirst NE Blund -> m SomeBatchOp
+onRollbackBlocksStub _ _ = pure mempty

block/src/Pos/Block/Slog/Logic.hs

@@ -42,6 +42,7 @@ import           Pos.Core (BlockVersion (..), FlatSlotId, blkSecurityParam, diff
 import           Pos.Core.Block (Block, genBlockLeaders, mainBlockSlot)
 import           Pos.Core.Chrono (NE, NewestFirst (getNewestFirst), OldestFirst (..), toOldestFirst,
                                   _OldestFirst)
+import           Pos.Core.NetworkMagic (NetworkMagic (..))
 import           Pos.Crypto (ProtocolMagic)
 import           Pos.DB (SomeBatchOp (..))
 import           Pos.DB.Block (putBlunds)
@@ -226,7 +227,7 @@ slogApplyBlocks (ShouldCallBListener callBListener) blunds = do
     -- If the program is interrupted at this point (after putting blunds
     -- in BlockDB), we will have garbage blunds in BlockDB, but it's not a
     -- problem.
-    bListenerBatch <- if callBListener then onApplyBlocks blunds
+    bListenerBatch <- if callBListener then onApplyBlocks fixedNM blunds
                       else pure mempty
 
     let newestBlock = NE.last $ getOldestFirst blunds
@@ -305,7 +306,7 @@ slogRollbackBlocks (BypassSecurityCheck bypassSecurity) (ShouldCallBListener cal
         reportFatalError "slogRollbackBlocks: the attempted rollback would \
                          \lead to a more than 'k' distance between tip and \
                          \last seen block, which is a security risk. Aborting."
-    bListenerBatch <- if callBListener then onRollbackBlocks blunds
+    bListenerBatch <- if callBListener then onRollbackBlocks fixedNM blunds
                       else pure mempty
     let putTip =
             SomeBatchOp $ GS.PutTip $
@@ -344,3 +345,7 @@ slogRollbackBlocks (BypassSecurityCheck bypassSecurity) (ShouldCallBListener cal
     blockExtraBatch lastSlots =
         GS.SetLastSlots (newLastSlots lastSlots) :
         mconcat [forwardLinksBatch, inMainBatch]
+
+
+fixedNM :: NetworkMagic
+fixedNM = NMNothing

client/src/Pos/Client/Txp/Addresses.hs

@@ -7,16 +7,17 @@ module Pos.Client.Txp.Addresses
 import           Universum
 
 import           Pos.Core (Address)
+import           Pos.Core.NetworkMagic (NetworkMagic)
 
 -- | A class which have the method to generate a new address
 class Monad m => MonadAddresses m where
     type AddrData m :: *
 
     -- | Generate new address using given 'AddrData' (e.g. password +
     -- account id).
-    getNewAddress :: AddrData m -> m Address
+    getNewAddress :: NetworkMagic -> AddrData m -> m Address
 
     -- | Generate a “fake” change address. Its size must be greater
     -- than or equal to the maximal possible size of address generated
     -- by 'getNewAddress'.
-    getFakeChangeAddress :: m Address
+    getFakeChangeAddress :: NetworkMagic -> m Address

client/src/Pos/Client/Txp/Balances.hs

@@ -14,6 +14,7 @@ import           Control.Monad.Trans (MonadTrans)
 
 import           Pos.Core (Address (..), Coin, HasConfiguration, IsBootstrapEraAddr (..),
                            makePubKeyAddress)
+import           Pos.Core.NetworkMagic (NetworkMagic)
 import           Pos.Crypto (PublicKey)
 import           Pos.Txp (Utxo, filterUtxoByAddrs, genesisUtxo, unGenesisUtxo)
 import           Pos.Txp.Toil.Utxo (getTotalCoinsInUtxo)
@@ -47,9 +48,10 @@ getOwnUtxo = getOwnUtxos . one
 -- from an address. And we can't enumerate all possible addresses for
 -- a public key. So we only consider two addresses: one with bootstrap
 -- era distribution and another one with single key distribution.
-getOwnUtxoForPk :: MonadBalances m => PublicKey -> m Utxo
-getOwnUtxoForPk ourPk = getOwnUtxos ourAddresses
+getOwnUtxoForPk :: MonadBalances m
+                => NetworkMagic -> PublicKey -> m Utxo
+getOwnUtxoForPk nm ourPk = getOwnUtxos ourAddresses
   where
     ourAddresses :: [Address]
     ourAddresses =
-        map (flip makePubKeyAddress ourPk . IsBootstrapEraAddr) [False, True]
+        map (flip (makePubKeyAddress nm) ourPk . IsBootstrapEraAddr) [False, True]

client/src/Pos/Client/Txp/Network.hs

@@ -25,6 +25,7 @@ import           Pos.Client.Txp.Util (InputSelectionPolicy, PendingAddresses (..
 import           Pos.Communication.Message ()
 import           Pos.Communication.Types (InvOrDataTK)
 import           Pos.Core (Address, Coin, makeRedeemAddress, mkCoin, unsafeAddCoin)
+import           Pos.Core.NetworkMagic (NetworkMagic (..))
 import           Pos.Core.Txp (TxAux (..), TxId, TxOut (..), TxOutAux (..), txaF)
 import           Pos.Crypto (ProtocolMagic, RedeemSecretKey, SafeSigner, hash, redeemToPublic)
 import           Pos.Infra.Communication.Protocol (OutSpecs)
@@ -67,7 +68,7 @@ prepareRedemptionTx
     -> Address
     -> m (TxAux, Address, Coin)
 prepareRedemptionTx pm rsk output = do
-    let redeemAddress = makeRedeemAddress $ redeemToPublic rsk
+    let redeemAddress = makeRedeemAddress fixedNM $ redeemToPublic rsk
     utxo <- getOwnUtxo redeemAddress
     let addCoin c = unsafeAddCoin c . txOutValue . toaOut
         redeemBalance = foldl' addCoin (mkCoin 0) utxo
@@ -89,3 +90,7 @@ submitTxRaw diffusion txAux@TxAux {..} = do
 
 sendTxOuts :: OutSpecs
 sendTxOuts = createOutSpecs (Proxy :: Proxy (InvOrDataTK TxId TxMsgContents))
+
+
+fixedNM :: NetworkMagic
+fixedNM = NMNothing

client/src/Pos/Client/Txp/Util.hs

@@ -66,6 +66,7 @@ import           Pos.Core (Address, Coin, StakeholderId, TxFeePolicy (..), TxSiz
                            isRedeemAddress, mkCoin, sumCoins, txSizeLinearMinValue,
                            unsafeIntegerToCoin, unsafeSubCoin)
 import           Pos.Core.Configuration (HasConfiguration)
+import           Pos.Core.NetworkMagic (NetworkMagic (..))
 import           Pos.Crypto (ProtocolMagic, RedeemSecretKey, SafeSigner,
                              SignTag (SignRedeemTx, SignTx), deterministicKeyGen, fakeSigner, hash,
                              redeemSign, redeemToPublic, safeSign, safeToPublic)
@@ -494,13 +495,14 @@ prepareTxRaw pendingTx utxo outputs fee = do
 -- Returns set of tx outputs including change output (if it's necessary)
 mkOutputsWithRem
     :: TxCreateMode m
-    => AddrData m
+    => NetworkMagic
+    -> AddrData m
     -> TxRaw
     -> TxCreator m TxOutputs
-mkOutputsWithRem addrData TxRaw {..}
+mkOutputsWithRem nm addrData TxRaw {..}
     | trRemainingMoney == mkCoin 0 = pure trOutputs
     | otherwise = do
-        changeAddr <- lift . lift $ getNewAddress addrData
+        changeAddr <- lift . lift $ getNewAddress nm addrData
         let txOut = TxOut changeAddr trRemainingMoney
         pure $ TxOutAux txOut :| toList trOutputs
 
@@ -514,7 +516,7 @@ prepareInpsOuts
     -> TxCreator m (TxOwnedInputs TxOut, TxOutputs)
 prepareInpsOuts pm pendingTx utxo outputs addrData = do
     txRaw@TxRaw {..} <- prepareTxWithFee pm pendingTx utxo outputs
-    outputsWithRem <- mkOutputsWithRem addrData txRaw
+    outputsWithRem <- mkOutputsWithRem fixedNM addrData txRaw
     pure (trInputs, outputsWithRem)
 
 createGenericTx
@@ -727,7 +729,7 @@ stabilizeTxFee pm pendingTx linearPolicy utxo outputs = do
     stabilizeTxFeeDo (_, 0) _ = pure Nothing
     stabilizeTxFeeDo (isSecondStage, attempt) expectedFee = do
         txRaw <- prepareTxRaw pendingTx utxo outputs expectedFee
-        fakeChangeAddr <- lift . lift $ getFakeChangeAddress
+        fakeChangeAddr <- lift . lift $ getFakeChangeAddress fixedNM
         txMinFee <- txToLinearFee linearPolicy $
                     createFakeTxFromRawTx pm fakeChangeAddr txRaw
 
@@ -772,3 +774,7 @@ createFakeTxFromRawTx pm fakeAddr TxRaw{..} =
            (\_ -> Right $ fakeSigner fakeSK)
            trInputs
            txOutsWithRem
+
+
+fixedNM :: NetworkMagic
+fixedNM = NMNothing