{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric  #-}
{-# LANGUAGE LambdaCase     #-}
{-# LANGUAGE NamedFieldPuns #-}

module Cardano.Network.NodeToNode.Version
  ( NodeToNodeVersion (..)
  , NodeToNodeVersionData (..)
  , DiffusionMode (..)
  , ConnectionMode (..)
  , PerasSupport (..)
    -- * Codecs
  , nodeToNodeVersionCodec
  , nodeToNodeCodecCBORTerm
    -- * Feature predicates
  , isValidNtnVersionDataForVersion
  , getLocalPerasSupport
  ) where

import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as T

import Codec.CBOR.Term qualified as CBOR

import Cardano.Base.FeatureFlags
import Control.DeepSeq
import GHC.Generics
import NoThunks.Class (NoThunks)
import Ouroboros.Network.CodecCBORTerm
import Ouroboros.Network.DiffusionMode
import Ouroboros.Network.Handshake.Acceptable (Accept (..), Acceptable (..))
import Ouroboros.Network.Handshake.Queryable (Queryable (..))
import Ouroboros.Network.Magic
import Ouroboros.Network.PeerSelection.PeerSharing (PeerSharing (..))
import Ouroboros.Network.PerasSupport

-- | Enumeration of node to node protocol versions.
--
-- Historical versions:
--
-- @
-- NodeToNodeV_7
-- -- ^ Changes:
-- --
-- -- * new 'KeepAlive' codec
-- -- * Enable @CardanoNodeToNodeVersion5@, i.e., Alonzo
-- | NodeToNodeV_8
-- -- ^ Changes:
-- --
-- -- * Enable block diffusion pipelining in ChainSync and BlockFetch logic.
-- | NodeToNodeV_9
-- -- ^ Changes:
-- --
-- -- * Enable @CardanoNodeToNodeVersion6@, i.e., Babbage
-- | NodeToNodeV_10
-- -- ^ Changes:
-- --
-- -- * Enable full duplex connections.
-- | NodeToNodeV_11
-- -- ^ Changes:
-- --
-- -- * Adds a new extra parameter to handshake: PeerSharing
-- --   This version is needed to support the new  Peer Sharing miniprotocol
-- --   older versions that are negotiated will appear as not participating
-- --   in Peer Sharing to newer versions.
-- -- * Adds `query` to NodeToClientVersionData.
-- | NodeToNodeV_12
-- -- ^ No changes.
-- --
-- -- (In the past, this enabled Conway, but the negotiated 'NodeToNodeVersion'
-- -- no longer en-/disables eras.)
-- | NodeToNodeV_13
-- -- ^ Changes:
-- -- * Removed PeerSharingPrivate constructor
-- -- * Fixed Codec to disable PeerSharing with buggy versions 11 and 12.
-- -- * Disable PeerSharing with InitiatorOnly nodes, since they do not run
-- --   peer sharing server side and can not reply to requests.
-- @
--
data NodeToNodeVersion =
    NodeToNodeV_14
    -- ^ Plomin HF, mandatory on mainnet as of 2025.01.29
  | NodeToNodeV_15
    -- ^ SRV support
  | NodeToNodeV_16
    -- ^ Experimental.
    --
    -- Adds support for Peras mini-protocols (if 'PerasFlag' is set).
  deriving (NodeToNodeVersion -> NodeToNodeVersion -> Bool
(NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> Eq NodeToNodeVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
== :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c/= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
/= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
Eq, Eq NodeToNodeVersion
Eq NodeToNodeVersion =>
(NodeToNodeVersion -> NodeToNodeVersion -> Ordering)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> Bool)
-> (NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion)
-> (NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion)
-> Ord NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> Bool
NodeToNodeVersion -> NodeToNodeVersion -> Ordering
NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NodeToNodeVersion -> NodeToNodeVersion -> Ordering
compare :: NodeToNodeVersion -> NodeToNodeVersion -> Ordering
$c< :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
< :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c<= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
<= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c> :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
> :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$c>= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
>= :: NodeToNodeVersion -> NodeToNodeVersion -> Bool
$cmax :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
max :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
$cmin :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
min :: NodeToNodeVersion -> NodeToNodeVersion -> NodeToNodeVersion
Ord, Int -> NodeToNodeVersion
NodeToNodeVersion -> Int
NodeToNodeVersion -> [NodeToNodeVersion]
NodeToNodeVersion -> NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
(NodeToNodeVersion -> NodeToNodeVersion)
-> (NodeToNodeVersion -> NodeToNodeVersion)
-> (Int -> NodeToNodeVersion)
-> (NodeToNodeVersion -> Int)
-> (NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> (NodeToNodeVersion
    -> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion])
-> Enum NodeToNodeVersion
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NodeToNodeVersion -> NodeToNodeVersion
succ :: NodeToNodeVersion -> NodeToNodeVersion
$cpred :: NodeToNodeVersion -> NodeToNodeVersion
pred :: NodeToNodeVersion -> NodeToNodeVersion
$ctoEnum :: Int -> NodeToNodeVersion
toEnum :: Int -> NodeToNodeVersion
$cfromEnum :: NodeToNodeVersion -> Int
fromEnum :: NodeToNodeVersion -> Int
$cenumFrom :: NodeToNodeVersion -> [NodeToNodeVersion]
enumFrom :: NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromThen :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromThen :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromTo :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromTo :: NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
$cenumFromThenTo :: NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
enumFromThenTo :: NodeToNodeVersion
-> NodeToNodeVersion -> NodeToNodeVersion -> [NodeToNodeVersion]
Enum, NodeToNodeVersion
NodeToNodeVersion -> NodeToNodeVersion -> Bounded NodeToNodeVersion
forall a. a -> a -> Bounded a
$cminBound :: NodeToNodeVersion
minBound :: NodeToNodeVersion
$cmaxBound :: NodeToNodeVersion
maxBound :: NodeToNodeVersion
Bounded, Int -> NodeToNodeVersion -> ShowS
[NodeToNodeVersion] -> ShowS
NodeToNodeVersion -> String
(Int -> NodeToNodeVersion -> ShowS)
-> (NodeToNodeVersion -> String)
-> ([NodeToNodeVersion] -> ShowS)
-> Show NodeToNodeVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodeToNodeVersion -> ShowS
showsPrec :: Int -> NodeToNodeVersion -> ShowS
$cshow :: NodeToNodeVersion -> String
show :: NodeToNodeVersion -> String
$cshowList :: [NodeToNodeVersion] -> ShowS
showList :: [NodeToNodeVersion] -> ShowS
Show, (forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x)
-> (forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion)
-> Generic NodeToNodeVersion
forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
from :: forall x. NodeToNodeVersion -> Rep NodeToNodeVersion x
$cto :: forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
to :: forall x. Rep NodeToNodeVersion x -> NodeToNodeVersion
Generic, NodeToNodeVersion -> ()
(NodeToNodeVersion -> ()) -> NFData NodeToNodeVersion
forall a. (a -> ()) -> NFData a
$crnf :: NodeToNodeVersion -> ()
rnf :: NodeToNodeVersion -> ()
NFData, Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo)
Proxy NodeToNodeVersion -> String
(Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo))
-> (Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo))
-> (Proxy NodeToNodeVersion -> String)
-> NoThunks NodeToNodeVersion
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo)
noThunks :: Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> NodeToNodeVersion -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy NodeToNodeVersion -> String
showTypeOf :: Proxy NodeToNodeVersion -> String
NoThunks)

nodeToNodeVersionCodec :: CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec :: CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec = CodecCBORTerm { NodeToNodeVersion -> Term
encodeTerm :: NodeToNodeVersion -> Term
encodeTerm :: NodeToNodeVersion -> Term
encodeTerm, Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm }
  where
    encodeTerm :: NodeToNodeVersion -> Term
encodeTerm NodeToNodeVersion
NodeToNodeV_14 = Int -> Term
CBOR.TInt Int
14
    encodeTerm NodeToNodeVersion
NodeToNodeV_15 = Int -> Term
CBOR.TInt Int
15
    encodeTerm NodeToNodeVersion
NodeToNodeV_16 = Int -> Term
CBOR.TInt Int
16

    decodeTerm :: Term -> Either (Text, Maybe Int) NodeToNodeVersion
decodeTerm (CBOR.TInt Int
14) = NodeToNodeVersion -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. b -> Either a b
Right NodeToNodeVersion
NodeToNodeV_14
    decodeTerm (CBOR.TInt Int
15) = NodeToNodeVersion -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. b -> Either a b
Right NodeToNodeVersion
NodeToNodeV_15
    decodeTerm (CBOR.TInt Int
16) = NodeToNodeVersion -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. b -> Either a b
Right NodeToNodeVersion
NodeToNodeV_16
    decodeTerm (CBOR.TInt Int
n) = (Text, Maybe Int) -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. a -> Either a b
Left ( String -> Text
T.pack String
"decode NodeToNodeVersion: unknown tag: "
                                        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack (Int -> String
forall a. Show a => a -> String
show Int
n)
                                    , Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
                                    )
    decodeTerm Term
_ = (Text, Maybe Int) -> Either (Text, Maybe Int) NodeToNodeVersion
forall a b. a -> Either a b
Left ( String -> Text
T.pack String
"decode NodeToNodeVersion: unexpected term"
                        , Maybe Int
forall a. Maybe a
Nothing)


-- | Version data for NodeToNode protocol
--
data NodeToNodeVersionData = NodeToNodeVersionData
  { NodeToNodeVersionData -> NetworkMagic
networkMagic  :: !NetworkMagic
  , NodeToNodeVersionData -> DiffusionMode
diffusionMode :: !DiffusionMode
  , NodeToNodeVersionData -> PeerSharing
peerSharing   :: !PeerSharing
  , NodeToNodeVersionData -> Bool
query         :: !Bool
  , NodeToNodeVersionData -> PerasSupport
perasSupport  :: !PerasSupport
  }
  deriving (Int -> NodeToNodeVersionData -> ShowS
[NodeToNodeVersionData] -> ShowS
NodeToNodeVersionData -> String
(Int -> NodeToNodeVersionData -> ShowS)
-> (NodeToNodeVersionData -> String)
-> ([NodeToNodeVersionData] -> ShowS)
-> Show NodeToNodeVersionData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NodeToNodeVersionData -> ShowS
showsPrec :: Int -> NodeToNodeVersionData -> ShowS
$cshow :: NodeToNodeVersionData -> String
show :: NodeToNodeVersionData -> String
$cshowList :: [NodeToNodeVersionData] -> ShowS
showList :: [NodeToNodeVersionData] -> ShowS
Show, NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
(NodeToNodeVersionData -> NodeToNodeVersionData -> Bool)
-> (NodeToNodeVersionData -> NodeToNodeVersionData -> Bool)
-> Eq NodeToNodeVersionData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
== :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
$c/= :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
/= :: NodeToNodeVersionData -> NodeToNodeVersionData -> Bool
Eq, (forall x. NodeToNodeVersionData -> Rep NodeToNodeVersionData x)
-> (forall x. Rep NodeToNodeVersionData x -> NodeToNodeVersionData)
-> Generic NodeToNodeVersionData
forall x. Rep NodeToNodeVersionData x -> NodeToNodeVersionData
forall x. NodeToNodeVersionData -> Rep NodeToNodeVersionData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NodeToNodeVersionData -> Rep NodeToNodeVersionData x
from :: forall x. NodeToNodeVersionData -> Rep NodeToNodeVersionData x
$cto :: forall x. Rep NodeToNodeVersionData x -> NodeToNodeVersionData
to :: forall x. Rep NodeToNodeVersionData x -> NodeToNodeVersionData
Generic, NodeToNodeVersionData -> ()
(NodeToNodeVersionData -> ()) -> NFData NodeToNodeVersionData
forall a. (a -> ()) -> NFData a
$crnf :: NodeToNodeVersionData -> ()
rnf :: NodeToNodeVersionData -> ()
NFData)
  -- 'Eq' instance is not provided, it is not what we need in version
  -- negotiation (see 'Acceptable' instance below).

instance Acceptable NodeToNodeVersionData where
    -- | Check that both side use the same 'networkMagic'.  Choose smaller one
    -- from both 'diffusionMode's, e.g. if one is running in 'InitiatorOnlyMode'
    -- agree on it. Agree on the same 'PeerSharing' value.
    -- Also agree on whether or not Peras should be used.
    acceptableVersion :: NodeToNodeVersionData
-> NodeToNodeVersionData -> Accept NodeToNodeVersionData
acceptableVersion NodeToNodeVersionData
local NodeToNodeVersionData
remote
      | NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
local NetworkMagic -> NetworkMagic -> Bool
forall a. Eq a => a -> a -> Bool
== NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
remote
      = let acceptedDiffusionMode :: DiffusionMode
acceptedDiffusionMode = NodeToNodeVersionData -> DiffusionMode
diffusionMode NodeToNodeVersionData
local DiffusionMode -> DiffusionMode -> DiffusionMode
forall a. Ord a => a -> a -> a
`min` NodeToNodeVersionData -> DiffusionMode
diffusionMode NodeToNodeVersionData
remote
            acceptedPerasSupport :: PerasSupport
acceptedPerasSupport = NodeToNodeVersionData -> PerasSupport
perasSupport NodeToNodeVersionData
local PerasSupport -> PerasSupport -> PerasSupport
forall a. Ord a => a -> a -> a
`min` NodeToNodeVersionData -> PerasSupport
perasSupport NodeToNodeVersionData
remote
         in NodeToNodeVersionData -> Accept NodeToNodeVersionData
forall vData. vData -> Accept vData
Accept NodeToNodeVersionData
              { networkMagic :: NetworkMagic
networkMagic       = NodeToNodeVersionData -> NetworkMagic
networkMagic NodeToNodeVersionData
local
              , diffusionMode :: DiffusionMode
diffusionMode      = DiffusionMode
acceptedDiffusionMode
              , peerSharing :: PeerSharing
peerSharing        = NodeToNodeVersionData -> PeerSharing
peerSharing NodeToNodeVersionData
local PeerSharing -> PeerSharing -> PeerSharing
forall a. Semigroup a => a -> a -> a
<> NodeToNodeVersionData -> PeerSharing
peerSharing NodeToNodeVersionData
remote
              , query :: Bool
query              = NodeToNodeVersionData -> Bool
query NodeToNodeVersionData
local Bool -> Bool -> Bool
|| NodeToNodeVersionData -> Bool
query NodeToNodeVersionData
remote
              , perasSupport :: PerasSupport
perasSupport       = PerasSupport
acceptedPerasSupport
              }
      | Bool
otherwise
      = Text -> Accept NodeToNodeVersionData
forall vData. Text -> Accept vData
Refuse (Text -> Accept NodeToNodeVersionData)
-> Text -> Accept NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"version data mismatch: "
                       String -> ShowS
forall a. [a] -> [a] -> [a]
++ NodeToNodeVersionData -> String
forall a. Show a => a -> String
show NodeToNodeVersionData
local
                       String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" /= " String -> ShowS
forall a. [a] -> [a] -> [a]
++ NodeToNodeVersionData -> String
forall a. Show a => a -> String
show NodeToNodeVersionData
remote

instance Queryable NodeToNodeVersionData where
    queryVersion :: NodeToNodeVersionData -> Bool
queryVersion = NodeToNodeVersionData -> Bool
query

-- | `perasSupport` field is introduced with `NodeToNodeV_16`, and thus should be
-- set to `PerasUnsupported` (and not be serialized) for versions before that.
isValidNtnVersionDataForVersion :: NodeToNodeVersion -> NodeToNodeVersionData -> Bool
isValidNtnVersionDataForVersion :: NodeToNodeVersion -> NodeToNodeVersionData -> Bool
isValidNtnVersionDataForVersion NodeToNodeVersion
version NodeToNodeVersionData
ntnData =
  NodeToNodeVersion
version NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= NodeToNodeVersion
NodeToNodeV_16 Bool -> Bool -> Bool
|| NodeToNodeVersionData -> PerasSupport
perasSupport NodeToNodeVersionData
ntnData PerasSupport -> PerasSupport -> Bool
forall a. Eq a => a -> a -> Bool
== PerasSupport
PerasUnsupported


-- | Determine the local node's Peras support status based on feature flags and version.
getLocalPerasSupport :: Set CardanoFeatureFlag -> NodeToNodeVersion -> PerasSupport
getLocalPerasSupport :: Set CardanoFeatureFlag -> NodeToNodeVersion -> PerasSupport
getLocalPerasSupport Set CardanoFeatureFlag
featureFlags NodeToNodeVersion
v =
  if CardanoFeatureFlag -> Set CardanoFeatureFlag -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member CardanoFeatureFlag
PerasFlag Set CardanoFeatureFlag
featureFlags Bool -> Bool -> Bool
&& NodeToNodeVersion
v NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= NodeToNodeVersion
NodeToNodeV_16
    then PerasSupport
PerasSupported
    else PerasSupport
PerasUnsupported

-- | Beware, encoding an invalid NodeToNodeVersionData (see `isValidNtnVersionDataForVersion`) for
-- a given version will fail if a future field is set to a value other than its default forwards
-- compatibility one. This way `encodeTerm` and `decodeTerm` are only inverses for valid data.
nodeToNodeCodecCBORTerm :: NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm :: NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm NodeToNodeVersion
version = CodecCBORTerm { encodeTerm :: NodeToNodeVersionData -> Term
encodeTerm = NodeToNodeVersionData -> Term
encodeTerm, decodeTerm :: Term -> Either Text NodeToNodeVersionData
decodeTerm = Term -> Either Text NodeToNodeVersionData
decodeTerm }
  where
    encodeTerm :: NodeToNodeVersionData -> CBOR.Term
    encodeTerm :: NodeToNodeVersionData -> Term
encodeTerm ntnData :: NodeToNodeVersionData
ntnData@NodeToNodeVersionData{ NetworkMagic
networkMagic :: NodeToNodeVersionData -> NetworkMagic
networkMagic :: NetworkMagic
networkMagic, DiffusionMode
diffusionMode :: NodeToNodeVersionData -> DiffusionMode
diffusionMode :: DiffusionMode
diffusionMode, PeerSharing
peerSharing :: NodeToNodeVersionData -> PeerSharing
peerSharing :: PeerSharing
peerSharing, Bool
query :: NodeToNodeVersionData -> Bool
query :: Bool
query, PerasSupport
perasSupport :: NodeToNodeVersionData -> PerasSupport
perasSupport :: PerasSupport
perasSupport }
      | Bool -> Bool
not (NodeToNodeVersion -> NodeToNodeVersionData -> Bool
isValidNtnVersionDataForVersion NodeToNodeVersion
version NodeToNodeVersionData
ntnData) = String -> Term
forall a. HasCallStack => String -> a
error String
"perasSupport should be PerasUnsupported for versions strictly before NodeToNodeV_16"
      | Bool
otherwise =
        [Term] -> Term
CBOR.TList ([Term] -> Term) -> [Term] -> Term
forall a b. (a -> b) -> a -> b
$
             [ Int -> Term
CBOR.TInt (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int) -> Word32 -> Int
forall a b. (a -> b) -> a -> b
$ NetworkMagic -> Word32
unNetworkMagic NetworkMagic
networkMagic)
             , Bool -> Term
CBOR.TBool (case DiffusionMode
diffusionMode of
                           DiffusionMode
InitiatorOnlyDiffusionMode         -> Bool
True
                           DiffusionMode
InitiatorAndResponderDiffusionMode -> Bool
False)
             , Int -> Term
CBOR.TInt (case PeerSharing
peerSharing of
                           PeerSharing
PeerSharingDisabled -> Int
0
                           PeerSharing
PeerSharingEnabled  -> Int
1)
             , Bool -> Term
CBOR.TBool Bool
query
             ]
          [Term] -> [Term] -> [Term]
forall a. [a] -> [a] -> [a]
++ [Bool -> Term
CBOR.TBool (PerasSupport -> Bool
perasSupportToBool PerasSupport
perasSupport)
             | NodeToNodeVersion
version NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= NodeToNodeVersion
NodeToNodeV_16
             ]

    decodeTerm :: CBOR.Term -> Either Text NodeToNodeVersionData
    decodeTerm :: Term -> Either Text NodeToNodeVersionData
decodeTerm = \case
      (CBOR.TList (CBOR.TInt Int
networkMagic : CBOR.TBool Bool
diffusionMode : CBOR.TInt Int
peerSharing : CBOR.TBool Bool
query : [Term]
perasSupportOptional)) ->
            NetworkMagic
-> DiffusionMode
-> PeerSharing
-> Bool
-> PerasSupport
-> NodeToNodeVersionData
NodeToNodeVersionData
        (NetworkMagic
 -> DiffusionMode
 -> PeerSharing
 -> Bool
 -> PerasSupport
 -> NodeToNodeVersionData)
-> Either Text NetworkMagic
-> Either
     Text
     (DiffusionMode
      -> PeerSharing -> Bool -> PerasSupport -> NodeToNodeVersionData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Either Text NetworkMagic
forall {a}. (Integral a, Show a) => a -> Either Text NetworkMagic
decodeNetworkMagic Int
networkMagic
        Either
  Text
  (DiffusionMode
   -> PeerSharing -> Bool -> PerasSupport -> NodeToNodeVersionData)
-> Either Text DiffusionMode
-> Either
     Text (PeerSharing -> Bool -> PerasSupport -> NodeToNodeVersionData)
forall a b. Either Text (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Either Text DiffusionMode
forall {f :: * -> *}. Applicative f => Bool -> f DiffusionMode
decodeDiffusionMode Bool
diffusionMode
        Either
  Text (PeerSharing -> Bool -> PerasSupport -> NodeToNodeVersionData)
-> Either Text PeerSharing
-> Either Text (Bool -> PerasSupport -> NodeToNodeVersionData)
forall a b. Either Text (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Either Text PeerSharing
forall {a}. (Eq a, Num a, Show a) => a -> Either Text PeerSharing
decodePeerSharing Int
peerSharing
        Either Text (Bool -> PerasSupport -> NodeToNodeVersionData)
-> Either Text Bool
-> Either Text (PerasSupport -> NodeToNodeVersionData)
forall a b. Either Text (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Either Text Bool
forall {a}. a -> Either Text a
decodeQuery Bool
query
        Either Text (PerasSupport -> NodeToNodeVersionData)
-> Either Text PerasSupport -> Either Text NodeToNodeVersionData
forall a b. Either Text (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Term] -> Either Text PerasSupport
decodePerasSupportOptional [Term]
perasSupportOptional
          where
            decodeNetworkMagic :: a -> Either Text NetworkMagic
decodeNetworkMagic a
x
              | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
0 , a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
0xffffffff = NetworkMagic -> Either Text NetworkMagic
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NetworkMagic -> Either Text NetworkMagic)
-> NetworkMagic -> Either Text NetworkMagic
forall a b. (a -> b) -> a -> b
$ Word32 -> NetworkMagic
NetworkMagic (a -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x)
              | Bool
otherwise                = String -> Either Text NetworkMagic
forall {b}. String -> Either Text b
err (String -> Either Text NetworkMagic)
-> String -> Either Text NetworkMagic
forall a b. (a -> b) -> a -> b
$ String
"networkMagic out of bound: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
forall a. Show a => a -> String
show a
x

            decodeDiffusionMode :: Bool -> f DiffusionMode
decodeDiffusionMode Bool
dm = DiffusionMode -> f DiffusionMode
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DiffusionMode -> f DiffusionMode)
-> DiffusionMode -> f DiffusionMode
forall a b. (a -> b) -> a -> b
$
              if Bool
dm
                then DiffusionMode
InitiatorOnlyDiffusionMode
                else DiffusionMode
InitiatorAndResponderDiffusionMode

            decodePeerSharing :: a -> Either Text PeerSharing
decodePeerSharing a
ps
              | a
ps a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0   = PeerSharing -> Either Text PeerSharing
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PeerSharing
PeerSharingDisabled
              | a
ps a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
1   = PeerSharing -> Either Text PeerSharing
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PeerSharing
PeerSharingEnabled
              | Bool
otherwise = String -> Either Text PeerSharing
forall {b}. String -> Either Text b
err (String -> Either Text PeerSharing)
-> String -> Either Text PeerSharing
forall a b. (a -> b) -> a -> b
$ String
"peerSharing is out of bound: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
forall a. Show a => a -> String
show a
ps

            decodeQuery :: a -> Either Text a
decodeQuery = a -> Either Text a
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

            decodePerasSupportOptional :: [Term] -> Either Text PerasSupport
decodePerasSupportOptional = \case
              []                        | NodeToNodeVersion
version NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
<  NodeToNodeVersion
NodeToNodeV_16 -> PerasSupport -> Either Text PerasSupport
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PerasSupport
PerasUnsupported
              [CBOR.TBool Bool
perasSupport] | NodeToNodeVersion
version NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= NodeToNodeVersion
NodeToNodeV_16 -> PerasSupport -> Either Text PerasSupport
forall {a}. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PerasSupport -> Either Text PerasSupport)
-> PerasSupport -> Either Text PerasSupport
forall a b. (a -> b) -> a -> b
$
                if Bool
perasSupport
                  then PerasSupport
PerasSupported
                  else PerasSupport
PerasUnsupported
              [Term]
l -> String -> Either Text PerasSupport
forall {b}. String -> Either Text b
err (String -> Either Text PerasSupport)
-> String -> Either Text PerasSupport
forall a b. (a -> b) -> a -> b
$ String
"invalid encoding for perasSupport given the version " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> NodeToNodeVersion -> String
forall a. Show a => a -> String
show NodeToNodeVersion
version String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
": " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Term] -> String
forall a. Show a => a -> String
show [Term]
l

      Term
other -> String -> Either Text NodeToNodeVersionData
forall {b}. String -> Either Text b
err (String -> Either Text NodeToNodeVersionData)
-> String -> Either Text NodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$ String
"unexpected encoding when decoding NodeToNodeVersionData: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Term -> String
forall a. Show a => a -> String
show Term
other

    err :: String -> Either Text b
err = Text -> Either Text b
forall a b. a -> Either a b
Left (Text -> Either Text b)
-> (String -> Text) -> String -> Either Text b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

data ConnectionMode = UnidirectionalMode | DuplexMode