{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- | 'Arbitrary' instances intended for serialisation roundtrip tests for
-- 'CardanoBlock' and its related types.
--
-- Because the generated values are only used in serialisation roundtrip tests,
-- they don't need to be valid blocks, transactions, etc.
--
-- We combine the Byron and Shelley-based instances defined elsewhere into
-- Cardano instances by picking randomly from one of the eras.
module Test.Consensus.Cardano.Generators () where

import qualified Data.Map.Strict as Map
import Data.Maybe (catMaybes, fromMaybe)
import Data.Proxy
import Data.SOP.BasicFunctors
import Data.SOP.Constraint
import Data.SOP.Counting (Exactly (..))
import Data.SOP.Index
import Data.SOP.NonEmpty
import Data.SOP.Sing
import Data.SOP.Strict
import Ouroboros.Consensus.Block
import Ouroboros.Consensus.Byron.ByronHFC
import Ouroboros.Consensus.Byron.Ledger
import Ouroboros.Consensus.Cardano.Block
import Ouroboros.Consensus.Cardano.CanHardFork
import Ouroboros.Consensus.Cardano.Node ()
import Ouroboros.Consensus.HardFork.Combinator
import Ouroboros.Consensus.HardFork.Combinator.Serialisation
import qualified Ouroboros.Consensus.HardFork.History as History
import Ouroboros.Consensus.HeaderValidation
import Ouroboros.Consensus.Ledger.Query
import Ouroboros.Consensus.Node.NetworkProtocolVersion
import Ouroboros.Consensus.Node.Serialisation (Some (..))
import Ouroboros.Consensus.Protocol.TPraos (TPraos)
import Ouroboros.Consensus.Shelley.HFEras ()
import Ouroboros.Consensus.Shelley.Ledger
import Ouroboros.Consensus.Shelley.Ledger.Block ()
import Ouroboros.Consensus.Shelley.Ledger.SupportsProtocol ()
import Ouroboros.Consensus.TypeFamilyWrappers
import Test.Cardano.Ledger.Alonzo.Arbitrary ()
import Test.Cardano.Ledger.Alonzo.Binary.Twiddle ()
import Test.Cardano.Ledger.Conway.Arbitrary ()
import Test.Cardano.Ledger.Dijkstra.Arbitrary ()
import Test.Consensus.Byron.Generators ()
import Test.Consensus.Protocol.Serialisation.Generators ()
import Test.Consensus.Shelley.Generators
import Test.Consensus.Shelley.MockCrypto (CanMock)
import Test.QuickCheck hiding (Some (..))
import Test.Util.Orphans.Arbitrary ()
import Test.Util.Serialisation.Roundtrip
  ( Coherent (..)
  , WithVersion (..)
  )

{-------------------------------------------------------------------------------
  Disk
-------------------------------------------------------------------------------}

instance Arbitrary (CardanoBlock StandardCrypto) where
  arbitrary :: Gen (CardanoBlock StandardCrypto)
arbitrary =
    [Gen (CardanoBlock StandardCrypto)]
-> Gen (CardanoBlock StandardCrypto)
forall a. HasCallStack => [Gen a] -> Gen a
oneof ([Gen (CardanoBlock StandardCrypto)]
 -> Gen (CardanoBlock StandardCrypto))
-> [Gen (CardanoBlock StandardCrypto)]
-> Gen (CardanoBlock StandardCrypto)
forall a b. (a -> b) -> a -> b
$ [Maybe (Gen (CardanoBlock StandardCrypto))]
-> [Gen (CardanoBlock StandardCrypto)]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (Gen (CardanoBlock StandardCrypto))]
 -> [Gen (CardanoBlock StandardCrypto)])
-> [Maybe (Gen (CardanoBlock StandardCrypto))]
-> [Gen (CardanoBlock StandardCrypto)]
forall a b. (a -> b) -> a -> b
$ NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
-> CollapseTo NP (Maybe (Gen (CardanoBlock StandardCrypto)))
forall (xs :: [*]) a.
SListIN NP xs =>
NP (K a) xs -> CollapseTo NP a
forall k l (h :: (k -> *) -> l -> *) (xs :: l) a.
(HCollapse h, SListIN h xs) =>
h (K a) xs -> CollapseTo h a
hcollapse NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
generators
   where
    generators ::
      NP
        (K (Maybe (Gen (CardanoBlock StandardCrypto))))
        (CardanoEras StandardCrypto)
    generators :: NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
generators =
      (ByronBlock -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) ByronBlock
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ByronBlock -> CardanoBlock StandardCrypto
forall c. ByronBlock -> CardanoBlock c
BlockByron
        K (Maybe (Gen (CardanoBlock StandardCrypto))) ByronBlock
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) ShelleyEra,
       ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     (CardanoEras StandardCrypto)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) ShelleyEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) ShelleyEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) ShelleyEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
BlockShelley
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) ShelleyEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) ShelleyEra,
       ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) AllegraEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) AllegraEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) AllegraEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
BlockAllegra
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) AllegraEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) MaryEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) MaryEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) MaryEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
BlockMary
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) MaryEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) AlonzoEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) AlonzoEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) AlonzoEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
BlockAlonzo
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) AlonzoEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) BabbageEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) BabbageEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) BabbageEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
BlockBabbage
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) BabbageEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) ConwayEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) ConwayEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) ConwayEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
BlockConway
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) ConwayEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) DijkstraEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) DijkstraEra)
forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) DijkstraEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
BlockDijkstra
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) DijkstraEra)
-> NP (K (Maybe (Gen (CardanoBlock StandardCrypto)))) '[]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP (K (Maybe (Gen (CardanoBlock StandardCrypto)))) '[]
forall {k} (f :: k -> *). NP f '[]
Nil

    mk ::
      forall a x.
      Arbitrary a =>
      (a -> CardanoBlock StandardCrypto) ->
      K (Maybe (Gen (CardanoBlock StandardCrypto))) x
    mk :: forall a x.
Arbitrary a =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk a -> CardanoBlock StandardCrypto
f = Maybe (Gen (CardanoBlock StandardCrypto))
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
forall k a (b :: k). a -> K a b
K (Maybe (Gen (CardanoBlock StandardCrypto))
 -> K (Maybe (Gen (CardanoBlock StandardCrypto))) x)
-> Maybe (Gen (CardanoBlock StandardCrypto))
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
forall a b. (a -> b) -> a -> b
$ Gen (CardanoBlock StandardCrypto)
-> Maybe (Gen (CardanoBlock StandardCrypto))
forall a. a -> Maybe a
Just (Gen (CardanoBlock StandardCrypto)
 -> Maybe (Gen (CardanoBlock StandardCrypto)))
-> Gen (CardanoBlock StandardCrypto)
-> Maybe (Gen (CardanoBlock StandardCrypto))
forall a b. (a -> b) -> a -> b
$ a -> CardanoBlock StandardCrypto
f (a -> CardanoBlock StandardCrypto)
-> Gen a -> Gen (CardanoBlock StandardCrypto)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary (Coherent (CardanoBlock StandardCrypto)) where
  arbitrary :: Gen (Coherent (CardanoBlock StandardCrypto))
arbitrary =
    (CardanoBlock StandardCrypto
 -> Coherent (CardanoBlock StandardCrypto))
-> Gen (CardanoBlock StandardCrypto)
-> Gen (Coherent (CardanoBlock StandardCrypto))
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CardanoBlock StandardCrypto
-> Coherent (CardanoBlock StandardCrypto)
forall a. a -> Coherent a
Coherent (Gen (CardanoBlock StandardCrypto)
 -> Gen (Coherent (CardanoBlock StandardCrypto)))
-> Gen (CardanoBlock StandardCrypto)
-> Gen (Coherent (CardanoBlock StandardCrypto))
forall a b. (a -> b) -> a -> b
$ [Gen (CardanoBlock StandardCrypto)]
-> Gen (CardanoBlock StandardCrypto)
forall a. HasCallStack => [Gen a] -> Gen a
oneof ([Gen (CardanoBlock StandardCrypto)]
 -> Gen (CardanoBlock StandardCrypto))
-> [Gen (CardanoBlock StandardCrypto)]
-> Gen (CardanoBlock StandardCrypto)
forall a b. (a -> b) -> a -> b
$ [Maybe (Gen (CardanoBlock StandardCrypto))]
-> [Gen (CardanoBlock StandardCrypto)]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (Gen (CardanoBlock StandardCrypto))]
 -> [Gen (CardanoBlock StandardCrypto)])
-> [Maybe (Gen (CardanoBlock StandardCrypto))]
-> [Gen (CardanoBlock StandardCrypto)]
forall a b. (a -> b) -> a -> b
$ NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
-> CollapseTo NP (Maybe (Gen (CardanoBlock StandardCrypto)))
forall (xs :: [*]) a.
SListIN NP xs =>
NP (K a) xs -> CollapseTo NP a
forall k l (h :: (k -> *) -> l -> *) (xs :: l) a.
(HCollapse h, SListIN h xs) =>
h (K a) xs -> CollapseTo h a
hcollapse NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
generators
   where
    generators ::
      NP
        (K (Maybe (Gen (CardanoBlock StandardCrypto))))
        (CardanoEras StandardCrypto)
    generators :: NP
  (K (Maybe (Gen (CardanoBlock StandardCrypto))))
  (CardanoEras StandardCrypto)
generators =
      (ByronBlock -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) ByronBlock
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ByronBlock -> CardanoBlock StandardCrypto
forall c. ByronBlock -> CardanoBlock c
BlockByron
        K (Maybe (Gen (CardanoBlock StandardCrypto))) ByronBlock
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) ShelleyEra,
       ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     (CardanoEras StandardCrypto)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) ShelleyEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) ShelleyEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) ShelleyEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
BlockShelley
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) ShelleyEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) ShelleyEra,
       ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) AllegraEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) AllegraEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) AllegraEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
BlockAllegra
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) AllegraEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AllegraEra,
       ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) MaryEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) MaryEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) MaryEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
BlockMary
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) MaryEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) MaryEra,
       ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (TPraos StandardCrypto) AlonzoEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (TPraos StandardCrypto) AlonzoEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (TPraos StandardCrypto) AlonzoEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
BlockAlonzo
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (TPraos StandardCrypto) AlonzoEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (TPraos StandardCrypto) AlonzoEra,
       ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) BabbageEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) BabbageEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) BabbageEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
BlockBabbage
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) BabbageEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) BabbageEra,
       ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) ConwayEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) ConwayEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) ConwayEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
BlockConway
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) ConwayEra)
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) DijkstraEra]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) ConwayEra,
       ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* (ShelleyBlock (Praos StandardCrypto) DijkstraEra
 -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto)))
     (ShelleyBlock (Praos StandardCrypto) DijkstraEra)
forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk ShelleyBlock (Praos StandardCrypto) DijkstraEra
-> CardanoBlock StandardCrypto
forall c. ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
BlockDijkstra
        K (Maybe (Gen (CardanoBlock StandardCrypto)))
  (ShelleyBlock (Praos StandardCrypto) DijkstraEra)
-> NP (K (Maybe (Gen (CardanoBlock StandardCrypto)))) '[]
-> NP
     (K (Maybe (Gen (CardanoBlock StandardCrypto))))
     '[ShelleyBlock (Praos StandardCrypto) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP (K (Maybe (Gen (CardanoBlock StandardCrypto)))) '[]
forall {k} (f :: k -> *). NP f '[]
Nil

    mk ::
      forall a x.
      Arbitrary (Coherent a) =>
      (a -> CardanoBlock StandardCrypto) ->
      K (Maybe (Gen (CardanoBlock StandardCrypto))) x
    mk :: forall a x.
Arbitrary (Coherent a) =>
(a -> CardanoBlock StandardCrypto)
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
mk a -> CardanoBlock StandardCrypto
f = Maybe (Gen (CardanoBlock StandardCrypto))
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
forall k a (b :: k). a -> K a b
K (Maybe (Gen (CardanoBlock StandardCrypto))
 -> K (Maybe (Gen (CardanoBlock StandardCrypto))) x)
-> Maybe (Gen (CardanoBlock StandardCrypto))
-> K (Maybe (Gen (CardanoBlock StandardCrypto))) x
forall a b. (a -> b) -> a -> b
$ Gen (CardanoBlock StandardCrypto)
-> Maybe (Gen (CardanoBlock StandardCrypto))
forall a. a -> Maybe a
Just (Gen (CardanoBlock StandardCrypto)
 -> Maybe (Gen (CardanoBlock StandardCrypto)))
-> Gen (CardanoBlock StandardCrypto)
-> Maybe (Gen (CardanoBlock StandardCrypto))
forall a b. (a -> b) -> a -> b
$ a -> CardanoBlock StandardCrypto
f (a -> CardanoBlock StandardCrypto)
-> (Coherent a -> a) -> Coherent a -> CardanoBlock StandardCrypto
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coherent a -> a
forall a. Coherent a -> a
getCoherent (Coherent a -> CardanoBlock StandardCrypto)
-> Gen (Coherent a) -> Gen (CardanoBlock StandardCrypto)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Coherent a)
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary (CardanoHeader StandardCrypto) where
  arbitrary :: Gen (CardanoHeader StandardCrypto)
arbitrary = CardanoBlock StandardCrypto -> CardanoHeader StandardCrypto
forall blk. GetHeader blk => blk -> Header blk
getHeader (CardanoBlock StandardCrypto -> CardanoHeader StandardCrypto)
-> Gen (CardanoBlock StandardCrypto)
-> Gen (CardanoHeader StandardCrypto)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (CardanoBlock StandardCrypto)
forall a. Arbitrary a => Gen a
arbitrary

instance
  (CanMock (TPraos c) ShelleyEra, CardanoHardForkConstraints c) =>
  Arbitrary (OneEraHash (CardanoEras c))
  where
  arbitrary :: Gen (OneEraHash (CardanoEras c))
arbitrary = NS WrapHeaderHash (CardanoEras c) -> OneEraHash (CardanoEras c)
inj (NS WrapHeaderHash (CardanoEras c) -> OneEraHash (CardanoEras c))
-> Gen (NS WrapHeaderHash (CardanoEras c))
-> Gen (OneEraHash (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NS WrapHeaderHash (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary
   where
    inj :: NS WrapHeaderHash (CardanoEras c) -> OneEraHash (CardanoEras c)
    inj :: NS WrapHeaderHash (CardanoEras c) -> OneEraHash (CardanoEras c)
inj = NS (K (OneEraHash (CardanoEras c))) (CardanoEras c)
-> CollapseTo NS (OneEraHash (CardanoEras c))
NS (K (OneEraHash (CardanoEras c))) (CardanoEras c)
-> OneEraHash (CardanoEras c)
forall (xs :: [*]) a.
SListIN NS xs =>
NS (K a) xs -> CollapseTo NS a
forall k l (h :: (k -> *) -> l -> *) (xs :: l) a.
(HCollapse h, SListIN h xs) =>
h (K a) xs -> CollapseTo h a
hcollapse (NS (K (OneEraHash (CardanoEras c))) (CardanoEras c)
 -> OneEraHash (CardanoEras c))
-> (NS WrapHeaderHash (CardanoEras c)
    -> NS (K (OneEraHash (CardanoEras c))) (CardanoEras c))
-> NS WrapHeaderHash (CardanoEras c)
-> OneEraHash (CardanoEras c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy SingleEraBlock
-> (forall a.
    SingleEraBlock a =>
    WrapHeaderHash a -> K (OneEraHash (CardanoEras c)) a)
-> NS WrapHeaderHash (CardanoEras c)
-> NS (K (OneEraHash (CardanoEras c))) (CardanoEras c)
forall {k} {l} (h :: (k -> *) -> l -> *) (c :: k -> Constraint)
       (xs :: l) (proxy :: (k -> Constraint) -> *) (f :: k -> *)
       (f' :: k -> *).
(AllN (Prod h) c xs, HAp h) =>
proxy c
-> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs
hcmap Proxy SingleEraBlock
proxySingle WrapHeaderHash a -> K (OneEraHash (CardanoEras c)) a
forall a.
SingleEraBlock a =>
WrapHeaderHash a -> K (OneEraHash (CardanoEras c)) a
aux

    aux ::
      forall blk.
      SingleEraBlock blk =>
      WrapHeaderHash blk -> K (OneEraHash (CardanoEras c)) blk
    aux :: forall a.
SingleEraBlock a =>
WrapHeaderHash a -> K (OneEraHash (CardanoEras c)) a
aux = OneEraHash (CardanoEras c) -> K (OneEraHash (CardanoEras c)) blk
forall k a (b :: k). a -> K a b
K (OneEraHash (CardanoEras c) -> K (OneEraHash (CardanoEras c)) blk)
-> (WrapHeaderHash blk -> OneEraHash (CardanoEras c))
-> WrapHeaderHash blk
-> K (OneEraHash (CardanoEras c)) blk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> OneEraHash (CardanoEras c)
forall k (xs :: [k]). ShortByteString -> OneEraHash xs
OneEraHash (ShortByteString -> OneEraHash (CardanoEras c))
-> (WrapHeaderHash blk -> ShortByteString)
-> WrapHeaderHash blk
-> OneEraHash (CardanoEras c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy blk -> HeaderHash blk -> ShortByteString
forall blk (proxy :: * -> *).
ConvertRawHash blk =>
proxy blk -> HeaderHash blk -> ShortByteString
forall (proxy :: * -> *).
proxy blk -> HeaderHash blk -> ShortByteString
toShortRawHash (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @blk) (HeaderHash blk -> ShortByteString)
-> (WrapHeaderHash blk -> HeaderHash blk)
-> WrapHeaderHash blk
-> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapHeaderHash blk -> HeaderHash blk
forall blk. WrapHeaderHash blk -> HeaderHash blk
unwrapHeaderHash

instance
  (c ~ StandardCrypto, ShelleyBasedEra ShelleyEra) =>
  Arbitrary (AnnTip (CardanoBlock c))
  where
  arbitrary :: Gen (AnnTip (CardanoBlock c))
arbitrary =
    SlotNo
-> BlockNo -> TipInfo (CardanoBlock c) -> AnnTip (CardanoBlock c)
SlotNo
-> BlockNo
-> OneEraTipInfo (CardanoEras StandardCrypto)
-> AnnTip (CardanoBlock c)
forall blk. SlotNo -> BlockNo -> TipInfo blk -> AnnTip blk
AnnTip
      (SlotNo
 -> BlockNo
 -> OneEraTipInfo (CardanoEras StandardCrypto)
 -> AnnTip (CardanoBlock c))
-> Gen SlotNo
-> Gen
     (BlockNo
      -> OneEraTipInfo (CardanoEras StandardCrypto)
      -> AnnTip (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word64 -> SlotNo
SlotNo (Word64 -> SlotNo) -> Gen Word64 -> Gen SlotNo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word64
forall a. Arbitrary a => Gen a
arbitrary)
      Gen
  (BlockNo
   -> OneEraTipInfo (CardanoEras StandardCrypto)
   -> AnnTip (CardanoBlock c))
-> Gen BlockNo
-> Gen
     (OneEraTipInfo (CardanoEras StandardCrypto)
      -> AnnTip (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen BlockNo
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (OneEraTipInfo (CardanoEras StandardCrypto)
   -> AnnTip (CardanoBlock c))
-> Gen (OneEraTipInfo (CardanoEras StandardCrypto))
-> Gen (AnnTip (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (NS WrapTipInfo (CardanoEras StandardCrypto)
-> OneEraTipInfo (CardanoEras StandardCrypto)
forall (xs :: [*]). NS WrapTipInfo xs -> OneEraTipInfo xs
OneEraTipInfo (NS WrapTipInfo (CardanoEras StandardCrypto)
 -> OneEraTipInfo (CardanoEras StandardCrypto))
-> Gen (NS WrapTipInfo (CardanoEras StandardCrypto))
-> Gen (OneEraTipInfo (CardanoEras StandardCrypto))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NS WrapTipInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary)

{-------------------------------------------------------------------------------
  NodeToNode
-------------------------------------------------------------------------------}

instance
  CardanoHardForkConstraints c =>
  Arbitrary (HardForkNodeToNodeVersion (CardanoEras c))
  where
  arbitrary :: Gen (HardForkNodeToNodeVersion (CardanoEras c))
arbitrary =
    [HardForkNodeToNodeVersion (CardanoEras c)]
-> Gen (HardForkNodeToNodeVersion (CardanoEras c))
forall a. HasCallStack => [a] -> Gen a
elements ([HardForkNodeToNodeVersion (CardanoEras c)]
 -> Gen (HardForkNodeToNodeVersion (CardanoEras c)))
-> [HardForkNodeToNodeVersion (CardanoEras c)]
-> Gen (HardForkNodeToNodeVersion (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ Map NodeToNodeVersion (HardForkNodeToNodeVersion (CardanoEras c))
-> [HardForkNodeToNodeVersion (CardanoEras c)]
forall k a. Map k a -> [a]
Map.elems (Map NodeToNodeVersion (HardForkNodeToNodeVersion (CardanoEras c))
 -> [HardForkNodeToNodeVersion (CardanoEras c)])
-> Map
     NodeToNodeVersion (HardForkNodeToNodeVersion (CardanoEras c))
-> [HardForkNodeToNodeVersion (CardanoEras c)]
forall a b. (a -> b) -> a -> b
$ Proxy (CardanoBlock c)
-> Map NodeToNodeVersion (BlockNodeToNodeVersion (CardanoBlock c))
forall blk.
SupportedNetworkProtocolVersion blk =>
Proxy blk -> Map NodeToNodeVersion (BlockNodeToNodeVersion blk)
supportedNodeToNodeVersions (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoBlock c))

deriving instance
  Arbitrary (BlockNodeToNodeVersion blk) =>
  Arbitrary (WrapNodeToNodeVersion blk)

arbitraryNodeToNode ::
  ( Arbitrary (WithVersion ByronNodeToNodeVersion byron)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion mary)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion conway)
  , Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)
  ) =>
  (byron -> cardano) ->
  (shelley -> cardano) ->
  (allegra -> cardano) ->
  (mary -> cardano) ->
  (alonzo -> cardano) ->
  (babbage -> cardano) ->
  (conway -> cardano) ->
  (dijkstra -> cardano) ->
  Gen (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode :: forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode byron -> cardano
injByron shelley -> cardano
injShelley allegra -> cardano
injAllegra mary -> cardano
injMary alonzo -> cardano
injAlonzo babbage -> cardano
injBabbage conway -> cardano
injConway dijkstra -> cardano
injDijkstra =
  [Gen
   (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)]
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a. HasCallStack => [Gen a] -> Gen a
oneof
    [ -- Byron before HFC
      ( \(WithVersion ByronNodeToNodeVersion
versionByron byron
b) ->
          HardForkNodeToNodeVersion (CardanoEras c)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            (BlockNodeToNodeVersion ByronBlock
-> HardForkNodeToNodeVersion (CardanoEras c)
forall x (xs1 :: [*]).
BlockNodeToNodeVersion x -> HardForkNodeToNodeVersion (x : xs1)
HardForkNodeToNodeDisabled BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron)
            (byron -> cardano
injByron byron
b)
      )
        (WithVersion ByronNodeToNodeVersion byron
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ByronNodeToNodeVersion byron)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (WithVersion ByronNodeToNodeVersion byron)
forall a. Arbitrary a => Gen a
arbitrary
    , -- Note that any value generated by the V1 Byron generator is also fine
      -- when using Byron V2.
      ( \(WithVersion ByronNodeToNodeVersion
versionByron byron
x) ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (byron -> cardano
injByron byron
x)
      )
        (WithVersion ByronNodeToNodeVersion byron
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ByronNodeToNodeVersion byron)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (WithVersion ByronNodeToNodeVersion byron)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron (WithVersion ShelleyNodeToNodeVersion
versionShelley shelley
x) ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (shelley -> cardano
injShelley shelley
x)
      )
        (ByronNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion shelley
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion shelley
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion shelley
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion shelley)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion shelley)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley (WithVersion ShelleyNodeToNodeVersion
versionAllegra allegra
x) ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (allegra -> cardano
injAllegra allegra
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion allegra
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion allegra
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion allegra
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion allegra
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion allegra
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion allegra)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion allegra)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra (WithVersion ShelleyNodeToNodeVersion
versionMary mary
x) ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (mary -> cardano
injMary mary
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion mary
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion mary
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion mary
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion mary
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion mary
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion mary
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion mary
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion mary)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion mary)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary (WithVersion ShelleyNodeToNodeVersion
versionAlonzo alonzo
x) ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (alonzo -> cardano
injAlonzo alonzo
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion alonzo
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion alonzo
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion alonzo
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion alonzo
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion alonzo
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion alonzo
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion alonzo
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion alonzo
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion alonzo
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion alonzo)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion alonzo)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo (WithVersion ShelleyNodeToNodeVersion
versionBabbage babbage
x) ShelleyNodeToNodeVersion
versionConway ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (babbage -> cardano
injBabbage babbage
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion babbage
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion babbage
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion babbage
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion babbage
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion babbage
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion babbage
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion babbage
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion babbage
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion babbage
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion babbage
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion babbage
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion babbage)
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion babbage)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage (WithVersion ShelleyNodeToNodeVersion
versionConway conway
x) ShelleyNodeToNodeVersion
versionDijkstra ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (conway -> cardano
injConway conway
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion conway
 -> ShelleyNodeToNodeVersion
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion conway
      -> ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion conway
   -> ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion conway)
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion conway)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
    , ( \ByronNodeToNodeVersion
versionByron ShelleyNodeToNodeVersion
versionShelley ShelleyNodeToNodeVersion
versionAllegra ShelleyNodeToNodeVersion
versionMary ShelleyNodeToNodeVersion
versionAlonzo ShelleyNodeToNodeVersion
versionBabbage ShelleyNodeToNodeVersion
versionConway (WithVersion ShelleyNodeToNodeVersion
versionDijkstra dijkstra
x) ->
          BlockNodeToNodeVersion ByronBlock
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
-> BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
-> BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
-> cardano
-> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano
forall {x} {x} {x} {x} {x} {x} {x} {x} {a}.
BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
            BlockNodeToNodeVersion ByronBlock
ByronNodeToNodeVersion
versionByron
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToNodeVersion
versionShelley
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToNodeVersion
versionAllegra
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToNodeVersion
versionMary
            BlockNodeToNodeVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToNodeVersion
versionAlonzo
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToNodeVersion
versionBabbage
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToNodeVersion
versionConway
            BlockNodeToNodeVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToNodeVersion
versionDijkstra
            (dijkstra -> cardano
injDijkstra dijkstra
x)
      )
        (ByronNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> ShelleyNodeToNodeVersion
 -> WithVersion ShelleyNodeToNodeVersion dijkstra
 -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (ShelleyNodeToNodeVersion
      -> WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToNodeVersion
   -> WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToNodeVersion
-> Gen
     (WithVersion ShelleyNodeToNodeVersion dijkstra
      -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToNodeVersion dijkstra
   -> WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToNodeVersion dijkstra)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToNodeVersion dijkstra)
forall a. Arbitrary a => Gen a
arbitrary
    ]
 where
  distrib :: BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> BlockNodeToNodeVersion x
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
distrib
    BlockNodeToNodeVersion x
versionByron
    BlockNodeToNodeVersion x
versionShelley
    BlockNodeToNodeVersion x
versionAllegra
    BlockNodeToNodeVersion x
versionMary
    BlockNodeToNodeVersion x
versionAlonzo
    BlockNodeToNodeVersion x
versionBabbage
    BlockNodeToNodeVersion x
versionConway
    BlockNodeToNodeVersion x
versionDijkstra
    a
x =
      HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]
-> a
-> WithVersion
     (HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]) a
forall v a. v -> a -> WithVersion v a
WithVersion
        ( HardForkSpecificNodeToNodeVersion
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x, x, x]
-> HardForkNodeToNodeVersion '[x, x, x, x, x, x, x, x]
forall (xs :: [*]).
HardForkSpecificNodeToNodeVersion
-> NP WrapNodeToNodeVersion xs -> HardForkNodeToNodeVersion xs
HardForkNodeToNodeEnabled
            HardForkSpecificNodeToNodeVersion
forall a. Bounded a => a
maxBound
            ( BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionByron
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x, x]
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionShelley
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x]
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionAllegra
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x, x, x, x]
-> NP WrapNodeToNodeVersion '[x, x, x, x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionMary
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x, x, x]
-> NP WrapNodeToNodeVersion '[x, x, x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionAlonzo
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x, x]
-> NP WrapNodeToNodeVersion '[x, x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionBabbage
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x, x]
-> NP WrapNodeToNodeVersion '[x, x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionConway
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[x]
-> NP WrapNodeToNodeVersion '[x, x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToNodeVersion x -> WrapNodeToNodeVersion x
forall blk. BlockNodeToNodeVersion blk -> WrapNodeToNodeVersion blk
WrapNodeToNodeVersion BlockNodeToNodeVersion x
versionDijkstra
                WrapNodeToNodeVersion x
-> NP WrapNodeToNodeVersion '[] -> NP WrapNodeToNodeVersion '[x]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP WrapNodeToNodeVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
            )
        )
        a
x

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (SomeSecond (NestedCtxt Header) (CardanoBlock c))
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToNodeVersion (CardanoEras c))
     (SomeSecond (NestedCtxt Header) (CardanoBlock c)))
arbitrary =
    (SomeSecond (NestedCtxt Header) ByronBlock
 -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (TPraos c) ShelleyEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (TPraos c) AllegraEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (TPraos c) MaryEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (TPraos c) AlonzoEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (Praos c) BabbageEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (Praos c) ConwayEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> (SomeSecond
      (NestedCtxt Header) (ShelleyBlock (Praos c) DijkstraEra)
    -> SomeSecond (NestedCtxt Header) (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (SomeSecond (NestedCtxt Header) (CardanoBlock c)))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode
      SomeSecond (NestedCtxt Header) ByronBlock
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (blk : xs1))
injByron
      SomeSecond (NestedCtxt Header) (ShelleyBlock (TPraos c) ShelleyEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : blk : xs1))
injShelley
      SomeSecond (NestedCtxt Header) (ShelleyBlock (TPraos c) AllegraEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : x : blk : xs1))
injAllegra
      SomeSecond (NestedCtxt Header) (ShelleyBlock (TPraos c) MaryEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : blk : xs1))
injMary
      SomeSecond (NestedCtxt Header) (ShelleyBlock (TPraos c) AlonzoEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {x} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : blk : xs1))
injAlonzo
      SomeSecond (NestedCtxt Header) (ShelleyBlock (Praos c) BabbageEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {x} {x} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : blk : xs1))
injBabbage
      SomeSecond (NestedCtxt Header) (ShelleyBlock (Praos c) ConwayEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {x} {x} {x} {x} {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : x : blk : xs1))
injConway
      SomeSecond (NestedCtxt Header) (ShelleyBlock (Praos c) DijkstraEra)
-> SomeSecond (NestedCtxt Header) (CardanoBlock c)
forall {f' :: * -> *} {blk} {x} {x} {x} {x} {x} {x} {x}
       {xs1 :: [*]}.
SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f')
     (HardForkBlock (x : x : x : x : x : x : x : blk : xs1))
injDijkstra
   where
    injByron :: SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (blk : xs1))
injByron = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall a.
NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ
    injShelley :: SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : blk : xs1))
injShelley = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injAllegra :: SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : x : blk : xs1))
injAllegra = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond (NestedCtxt f') (HardForkBlock (x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injMary :: SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : blk : xs1))
injMary = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injAlonzo :: SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : blk : xs1))
injAlonzo = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injBabbage :: SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : blk : xs1))
injBabbage = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injConway :: SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : x : blk : xs1))
injConway = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f') (HardForkBlock (x : x : x : x : x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_
         (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)
    injDijkstra :: SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f')
     (HardForkBlock (x : x : x : x : x : x : x : blk : xs1))
injDijkstra = (forall a.
 NestedCtxt_ blk f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : x : x : blk : xs1)) f' a)
-> SomeSecond (NestedCtxt f') blk
-> SomeSecond
     (NestedCtxt f')
     (HardForkBlock (x : x : x : x : x : x : x : blk : xs1))
forall blk (f :: * -> *) blk' (f' :: * -> *).
(forall a. NestedCtxt_ blk f a -> NestedCtxt_ blk' f' a)
-> SomeSecond (NestedCtxt f) blk -> SomeSecond (NestedCtxt f') blk'
mapSomeNestedCtxt (NestedCtxt_
  (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_
   (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_
         (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_
         (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_
     (HardForkBlock (x : x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
 -> NestedCtxt_
      (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall (xs1 :: [*]) (a :: * -> *) b x.
NestedCtxt_ (HardForkBlock xs1) a b
-> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCS (NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
 -> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a)
-> (NestedCtxt_ blk f' a
    -> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a)
-> NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (x : blk : xs1)) f' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedCtxt_ blk f' a
-> NestedCtxt_ (HardForkBlock (blk : xs1)) f' a
forall x (a :: * -> *) b (xs1 :: [*]).
NestedCtxt_ x a b -> NestedCtxt_ (HardForkBlock (x : xs1)) a b
NCZ)

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (CardanoBlock c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoBlock c))
arbitrary =
    (ByronBlock -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c)
-> Gen
     (WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoBlock c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode
      ByronBlock -> CardanoBlock c
forall c. ByronBlock -> CardanoBlock c
BlockByron
      ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
BlockShelley
      ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
BlockAllegra
      ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
BlockMary
      ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
BlockAlonzo
      ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
BlockBabbage
      ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
BlockConway
      ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
BlockDijkstra

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (CardanoHeader c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoHeader c))
arbitrary =
    (Header ByronBlock -> CardanoHeader c)
-> (Header (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (TPraos c) AllegraEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (TPraos c) MaryEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (Praos c) BabbageEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (Praos c) ConwayEra) -> CardanoHeader c)
-> (Header (ShelleyBlock (Praos c) DijkstraEra) -> CardanoHeader c)
-> Gen
     (WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoHeader c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode
      Header ByronBlock -> CardanoHeader c
forall c. Header ByronBlock -> CardanoHeader c
HeaderByron
      Header (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoHeader c
HeaderShelley
      Header (ShelleyBlock (TPraos c) AllegraEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (TPraos c) AllegraEra) -> CardanoHeader c
HeaderAllegra
      Header (ShelleyBlock (TPraos c) MaryEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (TPraos c) MaryEra) -> CardanoHeader c
HeaderMary
      Header (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoHeader c
HeaderAlonzo
      Header (ShelleyBlock (Praos c) BabbageEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (Praos c) BabbageEra) -> CardanoHeader c
HeaderBabbage
      Header (ShelleyBlock (Praos c) ConwayEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (Praos c) ConwayEra) -> CardanoHeader c
HeaderConway
      Header (ShelleyBlock (Praos c) DijkstraEra) -> CardanoHeader c
forall c.
Header (ShelleyBlock (Praos c) DijkstraEra) -> CardanoHeader c
HeaderDijkstra

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (CardanoGenTx c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoGenTx c))
arbitrary =
    (GenTx ByronBlock -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c)
-> Gen
     (WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoGenTx c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode
      GenTx ByronBlock -> CardanoGenTx c
forall c. GenTx ByronBlock -> CardanoGenTx c
GenTxByron
      GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c
GenTxShelley
      GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c
GenTxAllegra
      GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c
forall c. GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c
GenTxMary
      GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c
GenTxAlonzo
      GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c
GenTxBabbage
      GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c
GenTxConway
      GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c
GenTxDijkstra

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c))
        (CardanoGenTxId c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoGenTxId c))
arbitrary =
    (GenTxId ByronBlock -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (TPraos c) ShelleyEra)
    -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (TPraos c) AllegraEra)
    -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (TPraos c) AlonzoEra)
    -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (Praos c) BabbageEra)
    -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTxId c)
-> (GenTxId (ShelleyBlock (Praos c) DijkstraEra)
    -> CardanoGenTxId c)
-> Gen
     (WithVersion
        (HardForkNodeToNodeVersion (CardanoEras c)) (CardanoGenTxId c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToNodeVersion byron),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion mary),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion conway),
 Arbitrary (WithVersion ShelleyNodeToNodeVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToNodeVersion (CardanoEras c)) cardano)
arbitraryNodeToNode
      GenTxId ByronBlock -> CardanoGenTxId c
forall c. GenTxId ByronBlock -> CardanoGenTxId c
GenTxIdByron
      GenTxId (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTxId c
GenTxIdShelley
      GenTxId (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTxId c
GenTxIdAllegra
      GenTxId (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTxId c
GenTxIdMary
      GenTxId (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTxId c
GenTxIdAlonzo
      GenTxId (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTxId c
GenTxIdBabbage
      GenTxId (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTxId c
GenTxIdConway
      GenTxId (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTxId c
forall c.
GenTxId (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTxId c
GenTxIdDijkstra

{-------------------------------------------------------------------------------
  NodeToClient
-------------------------------------------------------------------------------}

instance
  CardanoHardForkConstraints c =>
  Arbitrary (HardForkNodeToClientVersion (CardanoEras c))
  where
  arbitrary :: Gen (HardForkNodeToClientVersion (CardanoEras c))
arbitrary =
    [HardForkNodeToClientVersion (CardanoEras c)]
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall a. HasCallStack => [a] -> Gen a
elements ([HardForkNodeToClientVersion (CardanoEras c)]
 -> Gen (HardForkNodeToClientVersion (CardanoEras c)))
-> [HardForkNodeToClientVersion (CardanoEras c)]
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ Map
  NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall k a. Map k a -> [a]
Map.elems (Map
   NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
 -> [HardForkNodeToClientVersion (CardanoEras c)])
-> Map
     NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall a b. (a -> b) -> a -> b
$ Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (BlockNodeToClientVersion (CardanoBlock c))
forall blk.
SupportedNetworkProtocolVersion blk =>
Proxy blk -> Map NodeToClientVersion (BlockNodeToClientVersion blk)
supportedNodeToClientVersions (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoBlock c))

newtype HardForkEnabledNodeToClientVersion c = HardForkEnabledNodeToClientVersion
  { forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion :: HardForkNodeToClientVersion (CardanoEras c)
  }

deriving newtype instance
  CardanoHardForkConstraints c =>
  Eq (HardForkEnabledNodeToClientVersion c)
deriving newtype instance
  CardanoHardForkConstraints c =>
  Show (HardForkEnabledNodeToClientVersion c)

instance
  CardanoHardForkConstraints c =>
  Arbitrary (HardForkEnabledNodeToClientVersion c)
  where
  arbitrary :: Gen (HardForkEnabledNodeToClientVersion c)
arbitrary =
    [HardForkEnabledNodeToClientVersion c]
-> Gen (HardForkEnabledNodeToClientVersion c)
forall a. HasCallStack => [a] -> Gen a
elements
      ([HardForkEnabledNodeToClientVersion c]
 -> Gen (HardForkEnabledNodeToClientVersion c))
-> (Proxy (CardanoBlock c)
    -> [HardForkEnabledNodeToClientVersion c])
-> Proxy (CardanoBlock c)
-> Gen (HardForkEnabledNodeToClientVersion c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HardForkNodeToClientVersion (CardanoEras c)
 -> HardForkEnabledNodeToClientVersion c)
-> [HardForkNodeToClientVersion (CardanoEras c)]
-> [HardForkEnabledNodeToClientVersion c]
forall a b. (a -> b) -> [a] -> [b]
map HardForkNodeToClientVersion (CardanoEras c)
-> HardForkEnabledNodeToClientVersion c
forall c.
HardForkNodeToClientVersion (CardanoEras c)
-> HardForkEnabledNodeToClientVersion c
HardForkEnabledNodeToClientVersion
      ([HardForkNodeToClientVersion (CardanoEras c)]
 -> [HardForkEnabledNodeToClientVersion c])
-> (Proxy (CardanoBlock c)
    -> [HardForkNodeToClientVersion (CardanoEras c)])
-> Proxy (CardanoBlock c)
-> [HardForkEnabledNodeToClientVersion c]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HardForkNodeToClientVersion (CardanoEras c) -> Bool)
-> [HardForkNodeToClientVersion (CardanoEras c)]
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall a. (a -> Bool) -> [a] -> [a]
filter HardForkNodeToClientVersion (CardanoEras c) -> Bool
forall (xs :: [*]). HardForkNodeToClientVersion xs -> Bool
isHardForkNodeToClientEnabled
      ([HardForkNodeToClientVersion (CardanoEras c)]
 -> [HardForkNodeToClientVersion (CardanoEras c)])
-> (Proxy (CardanoBlock c)
    -> [HardForkNodeToClientVersion (CardanoEras c)])
-> Proxy (CardanoBlock c)
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map
  NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall k a. Map k a -> [a]
Map.elems
      (Map
   NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
 -> [HardForkNodeToClientVersion (CardanoEras c)])
-> (Proxy (CardanoBlock c)
    -> Map
         NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c)))
-> Proxy (CardanoBlock c)
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (BlockNodeToClientVersion (CardanoBlock c))
Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
forall blk.
SupportedNetworkProtocolVersion blk =>
Proxy blk -> Map NodeToClientVersion (BlockNodeToClientVersion blk)
supportedNodeToClientVersions
      (Proxy (CardanoBlock c)
 -> Gen (HardForkEnabledNodeToClientVersion c))
-> Proxy (CardanoBlock c)
-> Gen (HardForkEnabledNodeToClientVersion c)
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoBlock c)

-- | Generate a supported 'HardForkNodeToClientVersion' of which the
-- 'HardForkSpecificNodeToClientVersion' satisfies the given predicate.
--
-- PRECONDITION: 'supportedNodeToClientVersions' must include a version that
-- satisfies this condition.
_genWithHardForkSpecificNodeToClientVersion ::
  forall c.
  CardanoHardForkConstraints c =>
  (HardForkSpecificNodeToClientVersion -> Bool) ->
  Gen (HardForkNodeToClientVersion (CardanoEras c))
_genWithHardForkSpecificNodeToClientVersion :: forall c.
CardanoHardForkConstraints c =>
(HardForkSpecificNodeToClientVersion -> Bool)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
_genWithHardForkSpecificNodeToClientVersion HardForkSpecificNodeToClientVersion -> Bool
p =
  [HardForkNodeToClientVersion (CardanoEras c)]
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall a. HasCallStack => [a] -> Gen a
elements
    ([HardForkNodeToClientVersion (CardanoEras c)]
 -> Gen (HardForkNodeToClientVersion (CardanoEras c)))
-> (Proxy (CardanoBlock c)
    -> [HardForkNodeToClientVersion (CardanoEras c)])
-> Proxy (CardanoBlock c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HardForkNodeToClientVersion (CardanoEras c) -> Bool)
-> [HardForkNodeToClientVersion (CardanoEras c)]
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall a. (a -> Bool) -> [a] -> [a]
filter HardForkNodeToClientVersion (CardanoEras c) -> Bool
p'
    ([HardForkNodeToClientVersion (CardanoEras c)]
 -> [HardForkNodeToClientVersion (CardanoEras c)])
-> (Proxy (CardanoBlock c)
    -> [HardForkNodeToClientVersion (CardanoEras c)])
-> Proxy (CardanoBlock c)
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map
  NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall k a. Map k a -> [a]
Map.elems
    (Map
   NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
 -> [HardForkNodeToClientVersion (CardanoEras c)])
-> (Proxy (CardanoBlock c)
    -> Map
         NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c)))
-> Proxy (CardanoBlock c)
-> [HardForkNodeToClientVersion (CardanoEras c)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (BlockNodeToClientVersion (CardanoBlock c))
Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
forall blk.
SupportedNetworkProtocolVersion blk =>
Proxy blk -> Map NodeToClientVersion (BlockNodeToClientVersion blk)
supportedNodeToClientVersions
    (Proxy (CardanoBlock c)
 -> Gen (HardForkNodeToClientVersion (CardanoEras c)))
-> Proxy (CardanoBlock c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoBlock c)
 where
  p' :: HardForkNodeToClientVersion (CardanoEras c) -> Bool
  p' :: HardForkNodeToClientVersion (CardanoEras c) -> Bool
p' (HardForkNodeToClientEnabled HardForkSpecificNodeToClientVersion
v NP EraNodeToClientVersion (CardanoEras c)
_) = HardForkSpecificNodeToClientVersion -> Bool
p HardForkSpecificNodeToClientVersion
v
  p' (HardForkNodeToClientDisabled{}) = Bool
False

instance
  Arbitrary (BlockNodeToClientVersion blk) =>
  Arbitrary (EraNodeToClientVersion blk)
  where
  arbitrary :: Gen (EraNodeToClientVersion blk)
arbitrary =
    [(Int, Gen (EraNodeToClientVersion blk))]
-> Gen (EraNodeToClientVersion blk)
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [ (Int
1, EraNodeToClientVersion blk -> Gen (EraNodeToClientVersion blk)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EraNodeToClientVersion blk
forall blk. EraNodeToClientVersion blk
EraNodeToClientDisabled)
      , (Int
9, BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled (BlockNodeToClientVersion blk -> EraNodeToClientVersion blk)
-> Gen (BlockNodeToClientVersion blk)
-> Gen (EraNodeToClientVersion blk)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (BlockNodeToClientVersion blk)
forall a. Arbitrary a => Gen a
arbitrary)
      ]

arbitraryNodeToClient ::
  ( Arbitrary (WithVersion ByronNodeToClientVersion byron)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion shelley)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion allegra)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion mary)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion babbage)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion conway)
  , Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)
  ) =>
  (byron -> cardano) ->
  (shelley -> cardano) ->
  (allegra -> cardano) ->
  (mary -> cardano) ->
  (alonzo -> cardano) ->
  (babbage -> cardano) ->
  (conway -> cardano) ->
  (dijkstra -> cardano) ->
  Gen (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient :: forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient byron -> cardano
injByron shelley -> cardano
injShelley allegra -> cardano
injAllegra mary -> cardano
injMary alonzo -> cardano
injAlonzo babbage -> cardano
injBabbage conway -> cardano
injConway dijkstra -> cardano
injDijkstra =
  [Gen
   (WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)]
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a. HasCallStack => [Gen a] -> Gen a
oneof
    -- Byron + HardFork disabled
    [ ( \(WithVersion ByronNodeToClientVersion
versionByron byron
b) ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            (BlockNodeToClientVersion ByronBlock
-> HardForkNodeToClientVersion (CardanoEras c)
forall x (xs1 :: [*]).
BlockNodeToClientVersion x -> HardForkNodeToClientVersion (x : xs1)
HardForkNodeToClientDisabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron)
            (byron -> cardano
injByron byron
b)
      )
        (WithVersion ByronNodeToClientVersion byron
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ByronNodeToClientVersion byron)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (WithVersion ByronNodeToClientVersion byron)
forall a. Arbitrary a => Gen a
arbitrary
    , -- Byron + HardFork enabled.
      ( \(WithVersion ByronNodeToClientVersion
versionByron byron
b) ShelleyNodeToClientVersion
versionShelley EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
versionAllegra EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (byron -> cardano
injByron byron
b)
      )
        (WithVersion ByronNodeToClientVersion byron
 -> ShelleyNodeToClientVersion
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ByronNodeToClientVersion byron)
-> Gen
     (ShelleyNodeToClientVersion
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (WithVersion ByronNodeToClientVersion byron)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Shelley + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron (WithVersion ShelleyNodeToClientVersion
versionShelley shelley
s) EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
versionAllegra EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (shelley -> cardano
injShelley shelley
s)
      )
        (ByronNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion shelley
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion shelley
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion shelley
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion shelley)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion shelley)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Allegra + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley (WithVersion ShelleyNodeToClientVersion
versionAllegra allegra
a) EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (allegra -> cardano
injAllegra allegra
a)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion allegra
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion allegra
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion allegra
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion allegra
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion allegra
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion allegra)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion allegra)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Mary + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley ShelleyNodeToClientVersion
versionAllegra (WithVersion ShelleyNodeToClientVersion
versionMary mary
m) EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToClientVersion
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (mary -> cardano
injMary mary
m)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion mary
 -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion mary
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion mary
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion mary
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion mary
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion mary
      -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion mary
   -> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion mary)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion mary)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Alonzo + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley ShelleyNodeToClientVersion
versionAllegra ShelleyNodeToClientVersion
versionMary (WithVersion ShelleyNodeToClientVersion
versionAlonzo alonzo
a) EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToClientVersion
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToClientVersion
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (alonzo -> cardano
injAlonzo alonzo
a)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion alonzo
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion alonzo
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion alonzo
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion alonzo
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion alonzo
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion alonzo
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion alonzo
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion alonzo
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion alonzo
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion alonzo)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion alonzo)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Babbage + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley ShelleyNodeToClientVersion
versionAllegra ShelleyNodeToClientVersion
versionMary ShelleyNodeToClientVersion
versionAlonzo (WithVersion ShelleyNodeToClientVersion
versionBabbage babbage
a) EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToClientVersion
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToClientVersion
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToClientVersion
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (babbage -> cardano
injBabbage babbage
a)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion babbage
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion babbage
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion babbage
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion babbage
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion babbage
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion babbage
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion babbage
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion babbage
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion babbage
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion babbage
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion babbage
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion babbage)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion babbage)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Conway + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley ShelleyNodeToClientVersion
versionAllegra ShelleyNodeToClientVersion
versionMary ShelleyNodeToClientVersion
versionAlonzo ShelleyNodeToClientVersion
versionBabbage (WithVersion ShelleyNodeToClientVersion
versionConway conway
a) EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToClientVersion
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToClientVersion
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToClientVersion
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToClientVersion
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (conway -> cardano
injConway conway
a)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion conway
 -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion conway
      -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion conway
   -> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion conway)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion conway)
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen
     (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
    , -- Dijkstra + HardFork enabled
      ( \ByronNodeToClientVersion
versionByron ShelleyNodeToClientVersion
versionShelley ShelleyNodeToClientVersion
versionAllegra ShelleyNodeToClientVersion
versionMary ShelleyNodeToClientVersion
versionAlonzo ShelleyNodeToClientVersion
versionBabbage ShelleyNodeToClientVersion
versionConway (WithVersion ShelleyNodeToClientVersion
versionDijkstra dijkstra
a) ->
          HardForkNodeToClientVersion (CardanoEras c)
-> cardano
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) cardano
forall v a. v -> a -> WithVersion v a
WithVersion
            ( HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion (CardanoEras c)
-> HardForkNodeToClientVersion (CardanoEras c)
forall (xs :: [*]).
HardForkSpecificNodeToClientVersion
-> NP EraNodeToClientVersion xs -> HardForkNodeToClientVersion xs
HardForkNodeToClientEnabled
                HardForkSpecificNodeToClientVersion
forall a. Bounded a => a
maxBound
                ( BlockNodeToClientVersion ByronBlock
-> EraNodeToClientVersion ByronBlock
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion ByronBlock
ByronNodeToClientVersion
versionByron
                    EraNodeToClientVersion ByronBlock
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
-> NP EraNodeToClientVersion (CardanoEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
ShelleyNodeToClientVersion
versionShelley
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) ShelleyEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP EraNodeToClientVersion (CardanoShelleyEras c)
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
ShelleyNodeToClientVersion
versionAllegra
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AllegraEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AllegraEra,
       ShelleyBlock (TPraos c) MaryEra, ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
ShelleyNodeToClientVersion
versionMary
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) MaryEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) MaryEra,
       ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
ShelleyNodeToClientVersion
versionAlonzo
                    EraNodeToClientVersion (ShelleyBlock (TPraos c) AlonzoEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (TPraos c) AlonzoEra,
       ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
ShelleyNodeToClientVersion
versionBabbage
                    EraNodeToClientVersion (ShelleyBlock (Praos c) BabbageEra)
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) BabbageEra,
       ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
ShelleyNodeToClientVersion
versionConway
                    EraNodeToClientVersion (ShelleyBlock (Praos c) ConwayEra)
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
-> NP
     EraNodeToClientVersion
     '[ShelleyBlock (Praos c) ConwayEra,
       ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* BlockNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
forall blk.
BlockNodeToClientVersion blk -> EraNodeToClientVersion blk
EraNodeToClientEnabled BlockNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
ShelleyNodeToClientVersion
versionDijkstra
                    EraNodeToClientVersion (ShelleyBlock (Praos c) DijkstraEra)
-> NP EraNodeToClientVersion '[]
-> NP EraNodeToClientVersion '[ShelleyBlock (Praos c) DijkstraEra]
forall {k} (f :: k -> *) (x :: k) (xs1 :: [k]).
f x -> NP f xs1 -> NP f (x : xs1)
:* NP EraNodeToClientVersion '[]
forall {k} (f :: k -> *). NP f '[]
Nil
                )
            )
            (dijkstra -> cardano
injDijkstra dijkstra
a)
      )
        (ByronNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> ShelleyNodeToClientVersion
 -> WithVersion ShelleyNodeToClientVersion dijkstra
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ByronNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByronNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (ShelleyNodeToClientVersion
      -> WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (ShelleyNodeToClientVersion
   -> WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen ShelleyNodeToClientVersion
-> Gen
     (WithVersion ShelleyNodeToClientVersion dijkstra
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ShelleyNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary
        Gen
  (WithVersion ShelleyNodeToClientVersion dijkstra
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) cardano)
-> Gen (WithVersion ShelleyNodeToClientVersion dijkstra)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (WithVersion ShelleyNodeToClientVersion dijkstra)
forall a. Arbitrary a => Gen a
arbitrary
    ]

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoBlock c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) (CardanoBlock c))
arbitrary =
    (ByronBlock -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c)
-> (ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c)
-> (ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c)
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) (CardanoBlock c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient
      ByronBlock -> CardanoBlock c
forall c. ByronBlock -> CardanoBlock c
BlockByron
      ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) ShelleyEra -> CardanoBlock c
BlockShelley
      ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) AllegraEra -> CardanoBlock c
BlockAllegra
      ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) MaryEra -> CardanoBlock c
BlockMary
      ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
forall c. ShelleyBlock (TPraos c) AlonzoEra -> CardanoBlock c
BlockAlonzo
      ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) BabbageEra -> CardanoBlock c
BlockBabbage
      ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) ConwayEra -> CardanoBlock c
BlockConway
      ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
forall c. ShelleyBlock (Praos c) DijkstraEra -> CardanoBlock c
BlockDijkstra

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoGenTx c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) (CardanoGenTx c))
arbitrary =
    (GenTx ByronBlock -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c)
-> (GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c)
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c)) (CardanoGenTx c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient
      GenTx ByronBlock -> CardanoGenTx c
forall c. GenTx ByronBlock -> CardanoGenTx c
GenTxByron
      GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) ShelleyEra) -> CardanoGenTx c
GenTxShelley
      GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) AllegraEra) -> CardanoGenTx c
GenTxAllegra
      GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c
forall c. GenTx (ShelleyBlock (TPraos c) MaryEra) -> CardanoGenTx c
GenTxMary
      GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (TPraos c) AlonzoEra) -> CardanoGenTx c
GenTxAlonzo
      GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) BabbageEra) -> CardanoGenTx c
GenTxBabbage
      GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) ConwayEra) -> CardanoGenTx c
GenTxConway
      GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c
forall c.
GenTx (ShelleyBlock (Praos c) DijkstraEra) -> CardanoGenTx c
GenTxDijkstra

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoApplyTxErr c)
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (CardanoApplyTxErr c))
arbitrary =
    [(Int,
  Gen
    (WithVersion
       (HardForkNodeToClientVersion (CardanoEras c))
       (CardanoApplyTxErr c)))]
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoApplyTxErr c))
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [
        ( Int
8
        , (ApplyMempoolPayloadErr -> CardanoApplyTxErr c)
-> (ApplyTxError ShelleyEra -> CardanoApplyTxErr c)
-> (ApplyTxError AllegraEra -> CardanoApplyTxErr c)
-> (ApplyTxError MaryEra -> CardanoApplyTxErr c)
-> (ApplyTxError AlonzoEra -> CardanoApplyTxErr c)
-> (ApplyTxError BabbageEra -> CardanoApplyTxErr c)
-> (ApplyTxError ConwayEra -> CardanoApplyTxErr c)
-> (ApplyTxError DijkstraEra -> CardanoApplyTxErr c)
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoApplyTxErr c))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient
            ApplyMempoolPayloadErr -> CardanoApplyTxErr c
ApplyTxErr ByronBlock -> CardanoApplyTxErr c
forall c. ApplyTxErr ByronBlock -> CardanoApplyTxErr c
ApplyTxErrByron
            ApplyTxError ShelleyEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (TPraos c) ShelleyEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (TPraos c) ShelleyEra)
-> CardanoApplyTxErr c
ApplyTxErrShelley
            ApplyTxError AllegraEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (TPraos c) AllegraEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (TPraos c) AllegraEra)
-> CardanoApplyTxErr c
ApplyTxErrAllegra
            ApplyTxError MaryEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (TPraos c) MaryEra) -> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (TPraos c) MaryEra) -> CardanoApplyTxErr c
ApplyTxErrMary
            ApplyTxError AlonzoEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (TPraos c) AlonzoEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (TPraos c) AlonzoEra)
-> CardanoApplyTxErr c
ApplyTxErrAlonzo
            ApplyTxError BabbageEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (Praos c) BabbageEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (Praos c) BabbageEra)
-> CardanoApplyTxErr c
ApplyTxErrBabbage
            ApplyTxError ConwayEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (Praos c) ConwayEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (Praos c) ConwayEra)
-> CardanoApplyTxErr c
ApplyTxErrConway
            ApplyTxError DijkstraEra -> CardanoApplyTxErr c
ApplyTxErr (ShelleyBlock (Praos c) DijkstraEra)
-> CardanoApplyTxErr c
forall c.
ApplyTxErr (ShelleyBlock (Praos c) DijkstraEra)
-> CardanoApplyTxErr c
ApplyTxErrDijkstra
        )
      ,
        ( Int
2
        , HardForkNodeToClientVersion (CardanoEras c)
-> CardanoApplyTxErr c
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) (CardanoApplyTxErr c)
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> CardanoApplyTxErr c
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (CardanoApplyTxErr c))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (CardanoApplyTxErr c
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (CardanoApplyTxErr c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (CardanoApplyTxErr c
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoApplyTxErr c))
-> Gen (CardanoApplyTxErr c)
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (CardanoApplyTxErr c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (MismatchEraInfo (CardanoEras c) -> CardanoApplyTxErr c
forall (xs :: [*]). MismatchEraInfo xs -> HardForkApplyTxErr xs
HardForkApplyTxErrWrongEra (MismatchEraInfo (CardanoEras c) -> CardanoApplyTxErr c)
-> Gen (MismatchEraInfo (CardanoEras c))
-> Gen (CardanoApplyTxErr c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (MismatchEraInfo (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ]
  shrink :: WithVersion
  (HardForkNodeToClientVersion (CardanoEras c)) (CardanoApplyTxErr c)
-> [WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (CardanoApplyTxErr c)]
shrink = (CardanoApplyTxErr c -> [CardanoApplyTxErr c])
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c)) (CardanoApplyTxErr c)
-> [WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (CardanoApplyTxErr c)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> WithVersion (HardForkNodeToClientVersion (CardanoEras c)) a
-> f (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) b)
traverse CardanoApplyTxErr c -> [CardanoApplyTxErr c]
CardanoApplyTxErr StandardCrypto
-> [CardanoApplyTxErr StandardCrypto]
aux
   where
    aux ::
      CardanoApplyTxErr StandardCrypto ->
      [CardanoApplyTxErr StandardCrypto]
    aux :: CardanoApplyTxErr StandardCrypto
-> [CardanoApplyTxErr StandardCrypto]
aux (HardForkApplyTxErrFromEra (OneEraApplyTxErr NS WrapApplyTxErr (CardanoEras StandardCrypto)
x)) =
      OneEraApplyTxErr (CardanoEras StandardCrypto)
-> CardanoApplyTxErr StandardCrypto
forall (xs :: [*]). OneEraApplyTxErr xs -> HardForkApplyTxErr xs
HardForkApplyTxErrFromEra (OneEraApplyTxErr (CardanoEras StandardCrypto)
 -> CardanoApplyTxErr StandardCrypto)
-> (NS WrapApplyTxErr (CardanoEras StandardCrypto)
    -> OneEraApplyTxErr (CardanoEras StandardCrypto))
-> NS WrapApplyTxErr (CardanoEras StandardCrypto)
-> CardanoApplyTxErr StandardCrypto
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NS WrapApplyTxErr (CardanoEras StandardCrypto)
-> OneEraApplyTxErr (CardanoEras StandardCrypto)
forall (xs :: [*]). NS WrapApplyTxErr xs -> OneEraApplyTxErr xs
OneEraApplyTxErr (NS WrapApplyTxErr (CardanoEras StandardCrypto)
 -> CardanoApplyTxErr StandardCrypto)
-> [NS WrapApplyTxErr (CardanoEras StandardCrypto)]
-> [CardanoApplyTxErr StandardCrypto]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NS WrapApplyTxErr (CardanoEras StandardCrypto)
-> [NS WrapApplyTxErr (CardanoEras StandardCrypto)]
forall a. Arbitrary a => a -> [a]
shrink NS WrapApplyTxErr (CardanoEras StandardCrypto)
x
    aux (HardForkApplyTxErrWrongEra MismatchEraInfo (CardanoEras StandardCrypto)
x) =
      MismatchEraInfo (CardanoEras StandardCrypto)
-> CardanoApplyTxErr StandardCrypto
forall (xs :: [*]). MismatchEraInfo xs -> HardForkApplyTxErr xs
HardForkApplyTxErrWrongEra (MismatchEraInfo (CardanoEras StandardCrypto)
 -> CardanoApplyTxErr StandardCrypto)
-> [MismatchEraInfo (CardanoEras StandardCrypto)]
-> [CardanoApplyTxErr StandardCrypto]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MismatchEraInfo (CardanoEras StandardCrypto)
-> [MismatchEraInfo (CardanoEras StandardCrypto)]
forall a. Arbitrary a => a -> [a]
shrink MismatchEraInfo (CardanoEras StandardCrypto)
x

instance Arbitrary (Some QueryAnytime) where
  arbitrary :: Gen (Some QueryAnytime)
arbitrary = Some QueryAnytime -> Gen (Some QueryAnytime)
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Some QueryAnytime -> Gen (Some QueryAnytime))
-> Some QueryAnytime -> Gen (Some QueryAnytime)
forall a b. (a -> b) -> a -> b
$ QueryAnytime (Maybe Bound) -> Some QueryAnytime
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some QueryAnytime (Maybe Bound)
GetEraStart

instance
  CardanoHardForkConstraints c =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (Some (QueryHardFork (CardanoEras c)))
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (Some (QueryHardFork (CardanoEras c))))
arbitrary =
    [(Int,
  Gen
    (WithVersion
       (HardForkNodeToClientVersion (CardanoEras c))
       (Some (QueryHardFork (CardanoEras c)))))]
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (Some (QueryHardFork (CardanoEras c))))
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [
        ( Int
1
        , do
            version <- HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary
            return $ WithVersion version (Some GetInterpreter)
        )
      ,
        ( Int
1
        , do
            version <- HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary
            return $ WithVersion version (Some GetCurrentEra)
        )
      ]

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c)))
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c))))
arbitrary =
    [(Int,
  Gen
    (WithVersion
       (HardForkNodeToClientVersion (CardanoEras c))
       (SomeBlockQuery (BlockQuery (CardanoBlock c)))))]
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [
        ( Int
1
        , (SomeBlockQuery (BlockQuery ByronBlock)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery
      (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery
      (BlockQuery (ShelleyBlock (TPraos c) AllegraEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) MaryEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) BabbageEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) ConwayEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> (SomeBlockQuery
      (BlockQuery (ShelleyBlock (Praos c) DijkstraEra))
    -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient
            SomeBlockQuery (BlockQuery ByronBlock)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery ByronBlock)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injByron
            SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injShelley
            SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AllegraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AllegraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAllegra
            SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) MaryEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) MaryEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injMary
            SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAlonzo
            SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) BabbageEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) BabbageEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injBabbage
            SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) ConwayEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) ConwayEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injConway
            SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) DijkstraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) DijkstraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injDijkstra
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeByron (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeShelley (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeAllegra (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeMary (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeAlonzo (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeBabbage (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeConway (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeBlockQuery (BlockQuery (CardanoBlock c))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeBlockQuery (BlockQuery (CardanoBlock c))
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeBlockQuery (BlockQuery (CardanoBlock c))
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {c}.
Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeDijkstra (Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> Gen (Some QueryAnytime)
-> Gen (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Some QueryAnytime)
forall a. Arbitrary a => Gen a
arbitrary)
        )
      , (Int
1, (Some (QueryHardFork (CardanoEras c))
 -> SomeBlockQuery (BlockQuery (CardanoBlock c)))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (Some (QueryHardFork (CardanoEras c)))
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeBlockQuery (BlockQuery (CardanoBlock c)))
forall a b.
(a -> b)
-> WithVersion (HardForkNodeToClientVersion (CardanoEras c)) a
-> WithVersion (HardForkNodeToClientVersion (CardanoEras c)) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Some (QueryHardFork (CardanoEras c))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall {xs1 :: [*]} {x}.
IsNonEmpty xs1 =>
Some (QueryHardFork (x : xs1))
-> SomeBlockQuery (BlockQuery (HardForkBlock (x : xs1)))
injHardFork (WithVersion
   (HardForkNodeToClientVersion (CardanoEras c))
   (Some (QueryHardFork (CardanoEras c)))
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeBlockQuery (BlockQuery (CardanoBlock c))))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (Some (QueryHardFork (CardanoEras c))))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeBlockQuery (BlockQuery (CardanoBlock c))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (Some (QueryHardFork (CardanoEras c))))
forall a. Arbitrary a => Gen a
arbitrary)
      ]
   where
    injByron :: SomeBlockQuery (BlockQuery ByronBlock)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injByron (SomeBlockQuery BlockQuery ByronBlock footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery ByronBlock footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery ByronBlock fp result -> CardanoQuery c fp a
QueryIfCurrentByron BlockQuery ByronBlock footprint result
query)
    injShelley :: SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injShelley (SomeBlockQuery BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentShelley BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) footprint result
query)
    injAllegra :: SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AllegraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAllegra (SomeBlockQuery BlockQuery (ShelleyBlock (TPraos c) AllegraEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AllegraEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAllegra BlockQuery (ShelleyBlock (TPraos c) AllegraEra) footprint result
query)
    injMary :: SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) MaryEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injMary (SomeBlockQuery BlockQuery (ShelleyBlock (TPraos c) MaryEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) MaryEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentMary BlockQuery (ShelleyBlock (TPraos c) MaryEra) footprint result
query)
    injAlonzo :: SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAlonzo (SomeBlockQuery BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAlonzo BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) footprint result
query)
    injBabbage :: SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) BabbageEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injBabbage (SomeBlockQuery BlockQuery (ShelleyBlock (Praos c) BabbageEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) BabbageEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentBabbage BlockQuery (ShelleyBlock (Praos c) BabbageEra) footprint result
query)
    injConway :: SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) ConwayEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injConway (SomeBlockQuery BlockQuery (ShelleyBlock (Praos c) ConwayEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) ConwayEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentConway BlockQuery (ShelleyBlock (Praos c) ConwayEra) footprint result
query)
    injDijkstra :: SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) DijkstraEra))
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
injDijkstra (SomeBlockQuery BlockQuery (ShelleyBlock (Praos c) DijkstraEra) footprint result
query) = BlockQuery (CardanoBlock c) footprint (CardanoQueryResult c result)
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (BlockQuery (ShelleyBlock (Praos c) DijkstraEra) footprint result
-> BlockQuery
     (CardanoBlock c) footprint (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentDijkstra BlockQuery (ShelleyBlock (Praos c) DijkstraEra) footprint result
query)
    injAnytimeByron :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeByron (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeByron QueryAnytime a
query)
    injAnytimeShelley :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeShelley (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeShelley QueryAnytime a
query)
    injAnytimeAllegra :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeAllegra (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeAllegra QueryAnytime a
query)
    injAnytimeMary :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeMary (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeMary QueryAnytime a
query)
    injAnytimeAlonzo :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeAlonzo (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeAlonzo QueryAnytime a
query)
    injAnytimeBabbage :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeBabbage (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeBabbage QueryAnytime a
query)
    injAnytimeConway :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeConway (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeConway QueryAnytime a
query)
    injAnytimeDijkstra :: Some QueryAnytime -> SomeBlockQuery (BlockQuery (CardanoBlock c))
injAnytimeDijkstra (Some QueryAnytime a
query) = BlockQuery (CardanoBlock c) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (CardanoBlock c))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryAnytime a -> BlockQuery (CardanoBlock c) 'QFNoTables a
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeDijkstra QueryAnytime a
query)
    injHardFork :: Some (QueryHardFork (x : xs1))
-> SomeBlockQuery (BlockQuery (HardForkBlock (x : xs1)))
injHardFork (Some QueryHardFork (x : xs1) a
query) = BlockQuery (HardForkBlock (x : xs1)) 'QFNoTables a
-> SomeBlockQuery (BlockQuery (HardForkBlock (x : xs1)))
forall (q :: QueryFootprint -> * -> *)
       (footprint :: QueryFootprint) result.
SingI footprint =>
q footprint result -> SomeBlockQuery q
SomeBlockQuery (QueryHardFork (x : xs1) a
-> BlockQuery (HardForkBlock (x : xs1)) 'QFNoTables a
forall (xs1 :: [*]) x result.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) result
-> BlockQuery (HardForkBlock (x : xs1)) 'QFNoTables result
QueryHardFork QueryHardFork (x : xs1) a
query)

instance Arbitrary History.EraEnd where
  arbitrary :: Gen EraEnd
arbitrary =
    [Gen EraEnd] -> Gen EraEnd
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ Bound -> EraEnd
History.EraEnd (Bound -> EraEnd) -> Gen Bound -> Gen EraEnd
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Bound
forall a. Arbitrary a => Gen a
arbitrary
      , EraEnd -> Gen EraEnd
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return EraEnd
History.EraUnbounded
      ]

instance Arbitrary History.EraSummary where
  arbitrary :: Gen EraSummary
arbitrary =
    Bound -> EraEnd -> EraParams -> EraSummary
History.EraSummary
      (Bound -> EraEnd -> EraParams -> EraSummary)
-> Gen Bound -> Gen (EraEnd -> EraParams -> EraSummary)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Bound
forall a. Arbitrary a => Gen a
arbitrary
      Gen (EraEnd -> EraParams -> EraSummary)
-> Gen EraEnd -> Gen (EraParams -> EraSummary)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen EraEnd
forall a. Arbitrary a => Gen a
arbitrary
      Gen (EraParams -> EraSummary) -> Gen EraParams -> Gen EraSummary
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen EraParams
forall a. Arbitrary a => Gen a
arbitrary

instance (Arbitrary a, SListI xs) => Arbitrary (NonEmpty xs a) where
  arbitrary :: Gen (NonEmpty xs a)
arbitrary = do
    let nbXs :: Int
nbXs = Proxy xs -> Int
forall k (xs :: [k]) (proxy :: [k] -> *).
SListI xs =>
proxy xs -> Int
lengthSList (forall (t :: [*]). Proxy t
forall {k} (t :: k). Proxy t
Proxy @xs)
    len <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int
nbXs)
    xs <- vectorOf len arbitrary
    return $ fromMaybe (error "nonEmptyFromList failed") $ nonEmptyFromList xs

instance Arbitrary (History.Interpreter (CardanoEras c)) where
  arbitrary :: Gen (Interpreter (CardanoEras c))
arbitrary =
    Summary (CardanoEras c) -> Interpreter (CardanoEras c)
forall (xs :: [*]). Summary xs -> Interpreter xs
History.mkInterpreter (Summary (CardanoEras c) -> Interpreter (CardanoEras c))
-> (NonEmpty (CardanoEras c) EraSummary -> Summary (CardanoEras c))
-> NonEmpty (CardanoEras c) EraSummary
-> Interpreter (CardanoEras c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (CardanoEras c) EraSummary -> Summary (CardanoEras c)
forall (xs :: [*]). NonEmpty xs EraSummary -> Summary xs
History.Summary (NonEmpty (CardanoEras c) EraSummary -> Summary (CardanoEras c))
-> (NonEmpty (CardanoEras c) EraSummary
    -> NonEmpty (CardanoEras c) EraSummary)
-> NonEmpty (CardanoEras c) EraSummary
-> Summary (CardanoEras c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (CardanoEras c) EraSummary
-> NonEmpty (CardanoEras c) EraSummary
enforceInvariant (NonEmpty (CardanoEras c) EraSummary
 -> Interpreter (CardanoEras c))
-> Gen (NonEmpty (CardanoEras c) EraSummary)
-> Gen (Interpreter (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NonEmpty (CardanoEras c) EraSummary)
forall a. Arbitrary a => Gen a
arbitrary
   where
    -- Enforce the invariant that when the last era in the summary is the
    -- final era, it is unbounded. The decoder relies on this.
    enforceInvariant :: NonEmpty (CardanoEras c) EraSummary
-> NonEmpty (CardanoEras c) EraSummary
enforceInvariant NonEmpty (CardanoEras c) EraSummary
xs
      | [EraSummary] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (NonEmpty (CardanoEras c) EraSummary -> [EraSummary]
forall (xs :: [*]) a. NonEmpty xs a -> [a]
nonEmptyToList NonEmpty (CardanoEras c) EraSummary
xs) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Proxy (CardanoEras c) -> Int
forall k (xs :: [k]) (proxy :: [k] -> *).
SListI xs =>
proxy xs -> Int
lengthSList (forall (t :: [*]). Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoEras c)) =
          NonEmpty (CardanoEras c) EraSummary
-> NonEmpty (CardanoEras c) EraSummary
forall (xs :: [*]).
NonEmpty xs EraSummary -> NonEmpty xs EraSummary
fixEndBound NonEmpty (CardanoEras c) EraSummary
xs
      | Bool
otherwise =
          NonEmpty (CardanoEras c) EraSummary
xs

    fixEndBound ::
      NonEmpty xs History.EraSummary ->
      NonEmpty xs History.EraSummary
    fixEndBound :: forall (xs :: [*]).
NonEmpty xs EraSummary -> NonEmpty xs EraSummary
fixEndBound (NonEmptyCons EraSummary
e NonEmpty xs1 EraSummary
es) = EraSummary
-> NonEmpty xs1 EraSummary -> NonEmpty (x : xs1) EraSummary
forall a (xs1 :: [*]) x.
a -> NonEmpty xs1 a -> NonEmpty (x : xs1) a
NonEmptyCons EraSummary
e (NonEmpty xs1 EraSummary -> NonEmpty xs1 EraSummary
forall (xs :: [*]).
NonEmpty xs EraSummary -> NonEmpty xs EraSummary
fixEndBound NonEmpty xs1 EraSummary
es)
    fixEndBound (NonEmptyOne EraSummary
e) =
      EraSummary -> NonEmpty (x : xs1) EraSummary
forall a x (xs1 :: [*]). a -> NonEmpty (x : xs1) a
NonEmptyOne EraSummary
e{History.eraEnd = History.EraUnbounded}

instance Arbitrary (EraIndex (CardanoEras c)) where
  arbitrary :: Gen (EraIndex (CardanoEras c))
arbitrary = do
    let nbEras :: Int
nbEras = Proxy (CardanoEras c) -> Int
forall k (xs :: [k]) (proxy :: [k] -> *).
SListI xs =>
proxy xs -> Int
lengthSList (forall (t :: [*]). Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoEras c))
    index <- (Word8, Word8) -> Gen Word8
forall a. Random a => (a, a) -> Gen a
choose (Word8
0, Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
nbEras Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
1)
    case nsFromIndex index of
      Maybe (NS (K ()) (CardanoEras c))
Nothing -> String -> Gen (EraIndex (CardanoEras c))
forall a. HasCallStack => String -> a
error (String -> Gen (EraIndex (CardanoEras c)))
-> String -> Gen (EraIndex (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ String
"nsFromIndex failed for " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Word8 -> String
forall a. Show a => a -> String
show Word8
index
      Just NS (K ()) (CardanoEras c)
ns -> EraIndex (CardanoEras c) -> Gen (EraIndex (CardanoEras c))
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (EraIndex (CardanoEras c) -> Gen (EraIndex (CardanoEras c)))
-> EraIndex (CardanoEras c) -> Gen (EraIndex (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ NS (K ()) (CardanoEras c) -> EraIndex (CardanoEras c)
forall (xs :: [*]) (f :: * -> *).
SListI xs =>
NS f xs -> EraIndex xs
eraIndexFromNS NS (K ()) (CardanoEras c)
ns

instance
  c ~ StandardCrypto =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c))
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c)))
arbitrary =
    [(Int,
  Gen
    (WithVersion
       (HardForkNodeToClientVersion (CardanoEras c))
       (SomeResult (CardanoBlock c))))]
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [
        ( Int
1
        , (SomeResult ByronBlock -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (TPraos c) ShelleyEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (TPraos c) AllegraEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (TPraos c) MaryEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (TPraos c) AlonzoEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (Praos c) BabbageEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (Praos c) ConwayEra)
    -> SomeResult (CardanoBlock c))
-> (SomeResult (ShelleyBlock (Praos c) DijkstraEra)
    -> SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall byron shelley allegra mary alonzo babbage conway dijkstra
       cardano c.
(Arbitrary (WithVersion ByronNodeToClientVersion byron),
 Arbitrary (WithVersion ShelleyNodeToClientVersion shelley),
 Arbitrary (WithVersion ShelleyNodeToClientVersion allegra),
 Arbitrary (WithVersion ShelleyNodeToClientVersion mary),
 Arbitrary (WithVersion ShelleyNodeToClientVersion alonzo),
 Arbitrary (WithVersion ShelleyNodeToClientVersion babbage),
 Arbitrary (WithVersion ShelleyNodeToClientVersion conway),
 Arbitrary (WithVersion ShelleyNodeToClientVersion dijkstra)) =>
(byron -> cardano)
-> (shelley -> cardano)
-> (allegra -> cardano)
-> (mary -> cardano)
-> (alonzo -> cardano)
-> (babbage -> cardano)
-> (conway -> cardano)
-> (dijkstra -> cardano)
-> Gen
     (WithVersion (HardForkNodeToClientVersion (CardanoEras c)) cardano)
arbitraryNodeToClient
            SomeResult ByronBlock -> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult ByronBlock -> SomeResult (CardanoBlock c)
injByron
            SomeResult (ShelleyBlock (TPraos c) ShelleyEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (TPraos c) ShelleyEra)
-> SomeResult (CardanoBlock c)
injShelley
            SomeResult (ShelleyBlock (TPraos c) AllegraEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (TPraos c) AllegraEra)
-> SomeResult (CardanoBlock c)
injAllegra
            SomeResult (ShelleyBlock (TPraos c) MaryEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (TPraos c) MaryEra)
-> SomeResult (CardanoBlock c)
injMary
            SomeResult (ShelleyBlock (TPraos c) AlonzoEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (TPraos c) AlonzoEra)
-> SomeResult (CardanoBlock c)
injAlonzo
            SomeResult (ShelleyBlock (Praos c) BabbageEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (Praos c) BabbageEra)
-> SomeResult (CardanoBlock c)
injBabbage
            SomeResult (ShelleyBlock (Praos c) ConwayEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (Praos c) ConwayEra)
-> SomeResult (CardanoBlock c)
injConway
            SomeResult (ShelleyBlock (Praos c) DijkstraEra)
-> SomeResult (CardanoBlock c)
forall {c}.
(PraosCrypto c, PraosCrypto c) =>
SomeResult (ShelleyBlock (Praos c) DijkstraEra)
-> SomeResult (CardanoBlock c)
injDijkstra
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryIfCurrentResultEraMismatch
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultByron
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultShelley
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultAllegra
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultMary
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultAlonzo
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultBabbage
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultConway
        )
      ,
        ( Int
1
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultDijkstra
        )
      , (Int
1, Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c)))
genQueryHardForkResult)
      ]
   where
    injByron :: SomeResult ByronBlock -> SomeResult (CardanoBlock c)
injByron (SomeResult BlockQuery ByronBlock fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery ByronBlock fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery ByronBlock fp result -> CardanoQuery c fp a
QueryIfCurrentByron BlockQuery ByronBlock fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injShelley :: SomeResult (ShelleyBlock (TPraos c) ShelleyEra)
-> SomeResult (CardanoBlock c)
injShelley (SomeResult BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentShelley BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injAllegra :: SomeResult (ShelleyBlock (TPraos c) AllegraEra)
-> SomeResult (CardanoBlock c)
injAllegra (SomeResult BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAllegra BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injMary :: SomeResult (ShelleyBlock (TPraos c) MaryEra)
-> SomeResult (CardanoBlock c)
injMary (SomeResult BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentMary BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injAlonzo :: SomeResult (ShelleyBlock (TPraos c) AlonzoEra)
-> SomeResult (CardanoBlock c)
injAlonzo (SomeResult BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAlonzo BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injBabbage :: SomeResult (ShelleyBlock (Praos c) BabbageEra)
-> SomeResult (CardanoBlock c)
injBabbage (SomeResult BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentBabbage BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injConway :: SomeResult (ShelleyBlock (Praos c) ConwayEra)
-> SomeResult (CardanoBlock c)
injConway (SomeResult BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentConway BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)
    injDijkstra :: SomeResult (ShelleyBlock (Praos c) DijkstraEra)
-> SomeResult (CardanoBlock c)
injDijkstra (SomeResult BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
q result
r) = BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
-> CardanoQueryResult c result -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
-> BlockQuery (CardanoBlock c) fp (CardanoQueryResult c result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentDijkstra BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
q) (result -> CardanoQueryResult c result
forall result c. result -> CardanoQueryResult c result
QueryResultSuccess result
r)

    -- In practice, when sending a Byron query you'll never get a mismatch
    -- saying that your query is from the Shelley era while the ledger is
    -- from Byron. Only the inverse. We ignore that in this generator, as it
    -- doesn't matter for serialisation purposes, we just generate a random
    -- 'MismatchEraInfo'.
    genQueryIfCurrentResultEraMismatch :: Gen (SomeResult (CardanoBlock c))
    genQueryIfCurrentResultEraMismatch :: Gen (SomeResult (CardanoBlock c))
genQueryIfCurrentResultEraMismatch =
      [Gen (SomeResult (CardanoBlock c))]
-> Gen (SomeResult (CardanoBlock c))
forall a. HasCallStack => [Gen a] -> Gen a
oneof
        [ ( \(SomeResult BlockQuery ByronBlock fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery ByronBlock fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery ByronBlock fp result -> CardanoQuery c fp a
QueryIfCurrentByron BlockQuery ByronBlock fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult ByronBlock
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen (SomeResult ByronBlock)
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult ByronBlock)
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentShelley BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) fp result
BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (TPraos StandardCrypto) ShelleyEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen
     (SomeResult (ShelleyBlock (TPraos StandardCrypto) ShelleyEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (TPraos StandardCrypto) ShelleyEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) AllegraEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAllegra BlockQuery (ShelleyBlock (TPraos c) AllegraEra) fp result
BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) AllegraEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (TPraos StandardCrypto) AllegraEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen
     (SomeResult (ShelleyBlock (TPraos StandardCrypto) AllegraEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (TPraos StandardCrypto) AllegraEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentMary BlockQuery (ShelleyBlock (TPraos c) MaryEra) fp result
BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (TPraos StandardCrypto) MaryEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen (SomeResult (ShelleyBlock (TPraos StandardCrypto) MaryEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (TPraos StandardCrypto) MaryEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentAlonzo BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) fp result
BlockQuery
  (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (TPraos StandardCrypto) AlonzoEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen
     (SomeResult (ShelleyBlock (TPraos StandardCrypto) AlonzoEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (TPraos StandardCrypto) AlonzoEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (Praos StandardCrypto) BabbageEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentBabbage BlockQuery (ShelleyBlock (Praos c) BabbageEra) fp result
BlockQuery
  (ShelleyBlock (Praos StandardCrypto) BabbageEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (Praos StandardCrypto) BabbageEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen
     (SomeResult (ShelleyBlock (Praos StandardCrypto) BabbageEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (Praos StandardCrypto) BabbageEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (Praos StandardCrypto) ConwayEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentConway BlockQuery (ShelleyBlock (Praos c) ConwayEra) fp result
BlockQuery
  (ShelleyBlock (Praos StandardCrypto) ConwayEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (Praos StandardCrypto) ConwayEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen (SomeResult (ShelleyBlock (Praos StandardCrypto) ConwayEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (Praos StandardCrypto) ConwayEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        , ( \(SomeResult BlockQuery
  (ShelleyBlock (Praos StandardCrypto) DijkstraEra) fp result
q (result
_ :: result)) MismatchEraInfo (CardanoEras StandardCrypto)
mismatch ->
              BlockQuery
  (CardanoBlock c)
  fp
  (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
-> Either (MismatchEraInfo (CardanoEras StandardCrypto)) result
-> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
-> BlockQuery
     (CardanoBlock c)
     fp
     (Either (MismatchEraInfo (CardanoEras StandardCrypto)) result)
forall c a (fp :: QueryFootprint) result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
-> CardanoQuery c fp a
QueryIfCurrentDijkstra BlockQuery (ShelleyBlock (Praos c) DijkstraEra) fp result
BlockQuery
  (ShelleyBlock (Praos StandardCrypto) DijkstraEra) fp result
q) (forall a b. a -> Either a b
Left @_ @result MismatchEraInfo (CardanoEras StandardCrypto)
mismatch)
          )
            (SomeResult (ShelleyBlock (Praos StandardCrypto) DijkstraEra)
 -> MismatchEraInfo (CardanoEras StandardCrypto)
 -> SomeResult (CardanoBlock c))
-> Gen
     (SomeResult (ShelleyBlock (Praos StandardCrypto) DijkstraEra))
-> Gen
     (MismatchEraInfo (CardanoEras StandardCrypto)
      -> SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (SomeResult (ShelleyBlock (Praos StandardCrypto) DijkstraEra))
forall a. Arbitrary a => Gen a
arbitrary
            Gen
  (MismatchEraInfo (CardanoEras StandardCrypto)
   -> SomeResult (CardanoBlock c))
-> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
-> Gen (SomeResult (CardanoBlock c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (MismatchEraInfo (CardanoEras StandardCrypto))
forall a. Arbitrary a => Gen a
arbitrary
        ]

    genQueryAnytimeResultByron :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultByron :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultByron =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeByron QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultShelley :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultShelley :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultShelley =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeShelley QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultAllegra :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultAllegra :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultAllegra =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeAllegra QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultMary :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultMary :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultMary =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeMary QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultAlonzo :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultAlonzo :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultAlonzo =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeAlonzo QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultBabbage :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultBabbage :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultBabbage =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeBabbage QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultConway :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultConway :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultConway =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeConway QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryAnytimeResultDijkstra :: Gen (SomeResult (CardanoBlock c))
    genQueryAnytimeResultDijkstra :: Gen (SomeResult (CardanoBlock c))
genQueryAnytimeResultDijkstra =
      BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
-> Maybe Bound -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryAnytime (Maybe Bound)
-> BlockQuery (CardanoBlock c) 'QFNoTables (Maybe Bound)
forall result c.
QueryAnytime result -> CardanoQuery c 'QFNoTables result
QueryAnytimeDijkstra QueryAnytime (Maybe Bound)
GetEraStart) (Maybe Bound -> SomeResult (CardanoBlock c))
-> Gen (Maybe Bound) -> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Bound)
forall a. Arbitrary a => Gen a
arbitrary

    genQueryHardForkResult ::
      Gen
        ( WithVersion
            (HardForkNodeToClientVersion (CardanoEras c))
            (SomeResult (CardanoBlock c))
        )
    genQueryHardForkResult :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c)))
genQueryHardForkResult =
      [Gen
   (WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))]
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a. HasCallStack => [Gen a] -> Gen a
oneof
        [ HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (BlockQuery
  (CardanoBlock c) 'QFNoTables (Interpreter (CardanoEras c))
-> Interpreter (CardanoEras c) -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryHardFork (CardanoEras c) (Interpreter (CardanoEras c))
-> BlockQuery
     (CardanoBlock c) 'QFNoTables (Interpreter (CardanoEras c))
forall (xs1 :: [*]) x result.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) result
-> BlockQuery (HardForkBlock (x : xs1)) 'QFNoTables result
QueryHardFork QueryHardFork (CardanoEras c) (Interpreter (CardanoEras c))
forall (xs :: [*]). QueryHardFork xs (Interpreter xs)
GetInterpreter) (Interpreter (CardanoEras c) -> SomeResult (CardanoBlock c))
-> Gen (Interpreter (CardanoEras c))
-> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Interpreter (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary)
        , HardForkNodeToClientVersion (CardanoEras c)
-> SomeResult (CardanoBlock c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (SomeResult (CardanoBlock c))
forall v a. v -> a -> WithVersion v a
WithVersion
            (HardForkNodeToClientVersion (CardanoEras c)
 -> SomeResult (CardanoBlock c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (SomeResult (CardanoBlock c)))
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
-> Gen
     (SomeResult (CardanoBlock c)
      -> WithVersion
           (HardForkNodeToClientVersion (CardanoEras c))
           (SomeResult (CardanoBlock c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
forall c.
HardForkEnabledNodeToClientVersion c
-> HardForkNodeToClientVersion (CardanoEras c)
getHardForkEnabledNodeToClientVersion (HardForkEnabledNodeToClientVersion c
 -> HardForkNodeToClientVersion (CardanoEras c))
-> Gen (HardForkEnabledNodeToClientVersion c)
-> Gen (HardForkNodeToClientVersion (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkEnabledNodeToClientVersion c)
forall a. Arbitrary a => Gen a
arbitrary)
            Gen
  (SomeResult (CardanoBlock c)
   -> WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
-> Gen (SomeResult (CardanoBlock c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (SomeResult (CardanoBlock c)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (BlockQuery (CardanoBlock c) 'QFNoTables (EraIndex (CardanoEras c))
-> EraIndex (CardanoEras c) -> SomeResult (CardanoBlock c)
forall result blk (fp :: QueryFootprint).
(Eq result, Show result, Typeable result) =>
BlockQuery blk fp result -> result -> SomeResult blk
SomeResult (QueryHardFork (CardanoEras c) (EraIndex (CardanoEras c))
-> BlockQuery
     (CardanoBlock c) 'QFNoTables (EraIndex (CardanoEras c))
forall (xs1 :: [*]) x result.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) result
-> BlockQuery (HardForkBlock (x : xs1)) 'QFNoTables result
QueryHardFork QueryHardFork (CardanoEras c) (EraIndex (CardanoEras c))
forall (xs :: [*]). QueryHardFork xs (EraIndex xs)
GetCurrentEra) (EraIndex (CardanoEras c) -> SomeResult (CardanoBlock c))
-> Gen (EraIndex (CardanoEras c))
-> Gen (SomeResult (CardanoBlock c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (EraIndex (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary)
        ]

{------------------------------------------------------------------------------
  Ledger Config
------------------------------------------------------------------------------}

-- | See 'encodeNodeToClientNP' and 'decodeNodeToClientNP'.
instance
  CardanoHardForkConstraints c =>
  Arbitrary
    ( WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (HardForkLedgerConfig (CardanoEras c))
    )
  where
  arbitrary :: Gen
  (WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (HardForkLedgerConfig (CardanoEras c)))
arbitrary =
    HardForkNodeToClientVersion (CardanoEras c)
-> HardForkLedgerConfig (CardanoEras c)
-> WithVersion
     (HardForkNodeToClientVersion (CardanoEras c))
     (HardForkLedgerConfig (CardanoEras c))
forall v a. v -> a -> WithVersion v a
WithVersion
      -- Use a version that enables all eras. We assume that all eras are
      -- enabled in the maximum supported version.
      ((NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
-> HardForkNodeToClientVersion (CardanoEras c)
forall a b. (a, b) -> b
snd ((NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
 -> HardForkNodeToClientVersion (CardanoEras c))
-> (NodeToClientVersion,
    HardForkNodeToClientVersion (CardanoEras c))
-> HardForkNodeToClientVersion (CardanoEras c)
forall a b. (a -> b) -> a -> b
$ (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
-> Maybe
     (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
-> (NodeToClientVersion,
    HardForkNodeToClientVersion (CardanoEras c))
forall a. a -> Maybe a -> a
fromMaybe (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
forall {a}. a
err (Maybe
   (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
 -> (NodeToClientVersion,
     HardForkNodeToClientVersion (CardanoEras c)))
-> Maybe
     (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
-> (NodeToClientVersion,
    HardForkNodeToClientVersion (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ Map
  NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> Maybe
     (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
forall k a. Map k a -> Maybe (k, a)
Map.lookupMax (Map
   NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
 -> Maybe
      (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c)))
-> Map
     NodeToClientVersion (HardForkNodeToClientVersion (CardanoEras c))
-> Maybe
     (NodeToClientVersion, HardForkNodeToClientVersion (CardanoEras c))
forall a b. (a -> b) -> a -> b
$ Proxy (CardanoBlock c)
-> Map
     NodeToClientVersion (BlockNodeToClientVersion (CardanoBlock c))
forall blk.
SupportedNetworkProtocolVersion blk =>
Proxy blk -> Map NodeToClientVersion (BlockNodeToClientVersion blk)
supportedNodeToClientVersions (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CardanoBlock c)))
      (HardForkLedgerConfig (CardanoEras c)
 -> WithVersion
      (HardForkNodeToClientVersion (CardanoEras c))
      (HardForkLedgerConfig (CardanoEras c)))
-> Gen (HardForkLedgerConfig (CardanoEras c))
-> Gen
     (WithVersion
        (HardForkNodeToClientVersion (CardanoEras c))
        (HardForkLedgerConfig (CardanoEras c)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (HardForkLedgerConfig (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary
   where
    err :: a
err =
      String -> a
forall a. HasCallStack => String -> a
error
        String
"Expected at least 1 supported note-to-client version, but `supportedNodeToClientVersions` has none"

instance
  CardanoHardForkConstraints c =>
  Arbitrary (HardForkLedgerConfig (CardanoEras c))
  where
  arbitrary :: Gen (HardForkLedgerConfig (CardanoEras c))
arbitrary = Shape (CardanoEras c)
-> PerEraLedgerConfig (CardanoEras c)
-> HardForkLedgerConfig (CardanoEras c)
forall (xs :: [*]).
Shape xs -> PerEraLedgerConfig xs -> HardForkLedgerConfig xs
HardForkLedgerConfig (Shape (CardanoEras c)
 -> PerEraLedgerConfig (CardanoEras c)
 -> HardForkLedgerConfig (CardanoEras c))
-> Gen (Shape (CardanoEras c))
-> Gen
     (PerEraLedgerConfig (CardanoEras c)
      -> HardForkLedgerConfig (CardanoEras c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Shape (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary Gen
  (PerEraLedgerConfig (CardanoEras c)
   -> HardForkLedgerConfig (CardanoEras c))
-> Gen (PerEraLedgerConfig (CardanoEras c))
-> Gen (HardForkLedgerConfig (CardanoEras c))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (PerEraLedgerConfig (CardanoEras c))
forall a. Arbitrary a => Gen a
arbitrary

instance SListI xs => Arbitrary (History.Shape xs) where
  arbitrary :: Gen (Shape xs)
arbitrary = Exactly xs EraParams -> Shape xs
forall (xs :: [*]). Exactly xs EraParams -> Shape xs
History.Shape (Exactly xs EraParams -> Shape xs)
-> (NP (K EraParams) xs -> Exactly xs EraParams)
-> NP (K EraParams) xs
-> Shape xs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NP (K EraParams) xs -> Exactly xs EraParams
forall (xs :: [*]) a. NP (K a) xs -> Exactly xs a
Exactly (NP (K EraParams) xs -> Shape xs)
-> Gen (NP (K EraParams) xs) -> Gen (Shape xs)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NP (K (Gen EraParams)) xs -> Gen (NP (K EraParams) xs)
forall {k} {l} (h :: (k -> *) -> l -> *) (xs :: l) (f :: * -> *) a.
(SListIN h xs, SListIN (Prod h) xs, Applicative f, HSequence h) =>
h (K (f a)) xs -> f (h (K a) xs)
hsequenceK ((forall a. K (Gen EraParams) a) -> NP (K (Gen EraParams)) xs
forall (xs :: [*]) (f :: * -> *).
SListIN NP xs =>
(forall a. f a) -> NP f xs
forall k l (h :: (k -> *) -> l -> *) (xs :: l) (f :: k -> *).
(HPure h, SListIN h xs) =>
(forall (a :: k). f a) -> h f xs
hpure (Gen EraParams -> K (Gen EraParams) a
forall k a (b :: k). a -> K a b
K Gen EraParams
forall a. Arbitrary a => Gen a
arbitrary))

instance
  CardanoHardForkConstraints c =>
  Arbitrary (PerEraLedgerConfig (CardanoEras c))
  where
  arbitrary :: Gen (PerEraLedgerConfig (CardanoEras c))
arbitrary =
    (NP WrapPartialLedgerConfig (CardanoEras c)
 -> PerEraLedgerConfig (CardanoEras c))
-> Gen (NP WrapPartialLedgerConfig (CardanoEras c))
-> Gen (PerEraLedgerConfig (CardanoEras c))
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NP WrapPartialLedgerConfig (CardanoEras c)
-> PerEraLedgerConfig (CardanoEras c)
forall (xs :: [*]).
NP WrapPartialLedgerConfig xs -> PerEraLedgerConfig xs
PerEraLedgerConfig (Gen (NP WrapPartialLedgerConfig (CardanoEras c))
 -> Gen (PerEraLedgerConfig (CardanoEras c)))
-> (NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
    -> Gen (NP WrapPartialLedgerConfig (CardanoEras c)))
-> NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
-> Gen (PerEraLedgerConfig (CardanoEras c))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
-> Gen (NP WrapPartialLedgerConfig (CardanoEras c))
forall (xs :: [*]) (f :: * -> *) (g :: * -> *).
(SListIN NP xs, Applicative f) =>
NP (f :.: g) xs -> f (NP g xs)
forall k l (h :: (k -> *) -> l -> *) (xs :: l) (f :: * -> *)
       (g :: k -> *).
(HSequence h, SListIN h xs, Applicative f) =>
h (f :.: g) xs -> f (h g xs)
hsequence' (NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
 -> Gen (PerEraLedgerConfig (CardanoEras c)))
-> NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
-> Gen (PerEraLedgerConfig (CardanoEras c))
forall a b. (a -> b) -> a -> b
$
      Proxy (Compose Arbitrary WrapPartialLedgerConfig)
-> (forall a.
    Compose Arbitrary WrapPartialLedgerConfig a =>
    (:.:) Gen WrapPartialLedgerConfig a)
-> NP (Gen :.: WrapPartialLedgerConfig) (CardanoEras c)
forall k l (h :: (k -> *) -> l -> *) (c :: k -> Constraint)
       (xs :: l) (proxy :: (k -> Constraint) -> *) (f :: k -> *).
(HPure h, AllN h c xs) =>
proxy c -> (forall (a :: k). c a => f a) -> h f xs
forall (c :: * -> Constraint) (xs :: [*])
       (proxy :: (* -> Constraint) -> *) (f :: * -> *).
AllN NP c xs =>
proxy c -> (forall a. c a => f a) -> NP f xs
hcpure (forall {k} (t :: k). Proxy t
forall (t :: * -> Constraint). Proxy t
Proxy @(Compose Arbitrary WrapPartialLedgerConfig)) (Gen (WrapPartialLedgerConfig a)
-> (:.:) Gen WrapPartialLedgerConfig a
forall l k (f :: l -> *) (g :: k -> l) (p :: k).
f (g p) -> (:.:) f g p
Comp Gen (WrapPartialLedgerConfig a)
forall a. Arbitrary a => Gen a
arbitrary)

instance Arbitrary (PartialLedgerConfig blk) => Arbitrary (WrapPartialLedgerConfig blk) where
  arbitrary :: Gen (WrapPartialLedgerConfig blk)
arbitrary = PartialLedgerConfig blk -> WrapPartialLedgerConfig blk
forall blk. PartialLedgerConfig blk -> WrapPartialLedgerConfig blk
WrapPartialLedgerConfig (PartialLedgerConfig blk -> WrapPartialLedgerConfig blk)
-> Gen (PartialLedgerConfig blk)
-> Gen (WrapPartialLedgerConfig blk)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (PartialLedgerConfig blk)
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary ByronPartialLedgerConfig where
  arbitrary :: Gen ByronPartialLedgerConfig
arbitrary = Config -> TriggerHardFork -> ByronPartialLedgerConfig
LedgerConfig ByronBlock
-> TriggerHardFork -> ByronPartialLedgerConfig
ByronPartialLedgerConfig (Config -> TriggerHardFork -> ByronPartialLedgerConfig)
-> Gen Config -> Gen (TriggerHardFork -> ByronPartialLedgerConfig)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Config
forall a. Arbitrary a => Gen a
arbitrary Gen (TriggerHardFork -> ByronPartialLedgerConfig)
-> Gen TriggerHardFork -> Gen ByronPartialLedgerConfig
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen TriggerHardFork
forall a. Arbitrary a => Gen a
arbitrary

instance
  Arbitrary (ShelleyLedgerConfig era) =>
  Arbitrary (ShelleyPartialLedgerConfig era)
  where
  arbitrary :: Gen (ShelleyPartialLedgerConfig era)
arbitrary = ShelleyLedgerConfig era
-> TriggerHardFork -> ShelleyPartialLedgerConfig era
forall era.
ShelleyLedgerConfig era
-> TriggerHardFork -> ShelleyPartialLedgerConfig era
ShelleyPartialLedgerConfig (ShelleyLedgerConfig era
 -> TriggerHardFork -> ShelleyPartialLedgerConfig era)
-> Gen (ShelleyLedgerConfig era)
-> Gen (TriggerHardFork -> ShelleyPartialLedgerConfig era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ShelleyLedgerConfig era)
forall a. Arbitrary a => Gen a
arbitrary Gen (TriggerHardFork -> ShelleyPartialLedgerConfig era)
-> Gen TriggerHardFork -> Gen (ShelleyPartialLedgerConfig era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen TriggerHardFork
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary TriggerHardFork where
  arbitrary :: Gen TriggerHardFork
arbitrary =
    [Gen TriggerHardFork] -> Gen TriggerHardFork
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ Word16 -> TriggerHardFork
TriggerHardForkAtVersion (Word16 -> TriggerHardFork) -> Gen Word16 -> Gen TriggerHardFork
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word16
forall a. Arbitrary a => Gen a
arbitrary
      , EpochNo -> TriggerHardFork
TriggerHardForkAtEpoch (EpochNo -> TriggerHardFork) -> Gen EpochNo -> Gen TriggerHardFork
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen EpochNo
forall a. Arbitrary a => Gen a
arbitrary
      , TriggerHardFork -> Gen TriggerHardFork
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TriggerHardFork
TriggerHardForkNotDuringThisExecution
      ]