-- | Cardano Network reponses

{-# LANGUAGE NumericUnderscores #-}

module Blockfrost.Types.Cardano.Network
  ( Network (..)
  , NetworkStake (..)
  , NetworkSupply (..)
  , NetworkEraSummary (..)
  , NetworkEraBound (..)
  , NetworkEraParameters (..)
  ) where

import Data.Time (NominalDiffTime)
import Data.Word (Word64)
import Deriving.Aeson
import Servant.Docs (ToSample (..), samples, singleSample)

import Blockfrost.Types.Shared

-- | Lovelace supply data
data NetworkSupply = NetworkSupply
  { NetworkSupply -> Lovelaces
_supplyMax         :: Lovelaces -- ^ Maximum supply in Lovelaces
  , NetworkSupply -> Lovelaces
_supplyTotal       :: Lovelaces -- ^ Current total (max supply - reserves) supply in Lovelaces
  , NetworkSupply -> Lovelaces
_supplyCirculating :: Lovelaces -- ^ Current circulating (UTXOs + withdrawables) supply in Lovelaces
  , NetworkSupply -> Lovelaces
_supplyLocked      :: Lovelaces -- ^ Current supply locked by scripts in Lovelaces
  , NetworkSupply -> Lovelaces
_supplyTreasury    :: Lovelaces -- ^ Current supply locked in treasury
  , NetworkSupply -> Lovelaces
_supplyReserves    :: Lovelaces -- ^ Current supply locked in reserves
  }
  deriving stock (Int -> NetworkSupply -> ShowS
[NetworkSupply] -> ShowS
NetworkSupply -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkSupply] -> ShowS
$cshowList :: [NetworkSupply] -> ShowS
show :: NetworkSupply -> String
$cshow :: NetworkSupply -> String
showsPrec :: Int -> NetworkSupply -> ShowS
$cshowsPrec :: Int -> NetworkSupply -> ShowS
Show, NetworkSupply -> NetworkSupply -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkSupply -> NetworkSupply -> Bool
$c/= :: NetworkSupply -> NetworkSupply -> Bool
== :: NetworkSupply -> NetworkSupply -> Bool
$c== :: NetworkSupply -> NetworkSupply -> Bool
Eq, forall x. Rep NetworkSupply x -> NetworkSupply
forall x. NetworkSupply -> Rep NetworkSupply x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkSupply x -> NetworkSupply
$cfrom :: forall x. NetworkSupply -> Rep NetworkSupply x
Generic)
  deriving (Maybe NetworkSupply
Value -> Parser [NetworkSupply]
Value -> Parser NetworkSupply
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe NetworkSupply
$comittedField :: Maybe NetworkSupply
parseJSONList :: Value -> Parser [NetworkSupply]
$cparseJSONList :: Value -> Parser [NetworkSupply]
parseJSON :: Value -> Parser NetworkSupply
$cparseJSON :: Value -> Parser NetworkSupply
FromJSON, [NetworkSupply] -> Encoding
[NetworkSupply] -> Value
NetworkSupply -> Bool
NetworkSupply -> Encoding
NetworkSupply -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: NetworkSupply -> Bool
$comitField :: NetworkSupply -> Bool
toEncodingList :: [NetworkSupply] -> Encoding
$ctoEncodingList :: [NetworkSupply] -> Encoding
toJSONList :: [NetworkSupply] -> Value
$ctoJSONList :: [NetworkSupply] -> Value
toEncoding :: NetworkSupply -> Encoding
$ctoEncoding :: NetworkSupply -> Encoding
toJSON :: NetworkSupply -> Value
$ctoJSON :: NetworkSupply -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_supply", CamelToSnake]] NetworkSupply

netSupplySample :: NetworkSupply
netSupplySample :: NetworkSupply
netSupplySample =
  NetworkSupply
    { _supplyMax :: Lovelaces
_supplyMax = Discrete' "ADA" '(1000000, 1)
45_000_000_000_000_000
    , _supplyTotal :: Lovelaces
_supplyTotal = Discrete' "ADA" '(1000000, 1)
32_890_715_183_299_160
    , _supplyCirculating :: Lovelaces
_supplyCirculating = Discrete' "ADA" '(1000000, 1)
32_412_601_976_210_393
    , _supplyLocked :: Lovelaces
_supplyLocked = Discrete' "ADA" '(1000000, 1)
125_006_953_355
    , _supplyTreasury :: Lovelaces
_supplyTreasury = Discrete' "ADA" '(1000000, 1)
98_635_632_000_000
    , _supplyReserves :: Lovelaces
_supplyReserves = Discrete' "ADA" '(1000000, 1)
46_635_632_000_000
    }

instance ToSample NetworkSupply where
  toSamples :: Proxy NetworkSupply -> [(Text, NetworkSupply)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> [(Text, a)]
singleSample NetworkSupply
netSupplySample

-- | Live and active stake of the whole network
data NetworkStake = NetworkStake
  { NetworkStake -> Lovelaces
_stakeLive   :: Lovelaces -- ^ Current live stake in Lovelaces
  , NetworkStake -> Lovelaces
_stakeActive :: Lovelaces -- ^ Current active stake in Lovelaces
  }
  deriving stock (Int -> NetworkStake -> ShowS
[NetworkStake] -> ShowS
NetworkStake -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkStake] -> ShowS
$cshowList :: [NetworkStake] -> ShowS
show :: NetworkStake -> String
$cshow :: NetworkStake -> String
showsPrec :: Int -> NetworkStake -> ShowS
$cshowsPrec :: Int -> NetworkStake -> ShowS
Show, NetworkStake -> NetworkStake -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkStake -> NetworkStake -> Bool
$c/= :: NetworkStake -> NetworkStake -> Bool
== :: NetworkStake -> NetworkStake -> Bool
$c== :: NetworkStake -> NetworkStake -> Bool
Eq, forall x. Rep NetworkStake x -> NetworkStake
forall x. NetworkStake -> Rep NetworkStake x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkStake x -> NetworkStake
$cfrom :: forall x. NetworkStake -> Rep NetworkStake x
Generic)
  deriving (Maybe NetworkStake
Value -> Parser [NetworkStake]
Value -> Parser NetworkStake
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe NetworkStake
$comittedField :: Maybe NetworkStake
parseJSONList :: Value -> Parser [NetworkStake]
$cparseJSONList :: Value -> Parser [NetworkStake]
parseJSON :: Value -> Parser NetworkStake
$cparseJSON :: Value -> Parser NetworkStake
FromJSON, [NetworkStake] -> Encoding
[NetworkStake] -> Value
NetworkStake -> Bool
NetworkStake -> Encoding
NetworkStake -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: NetworkStake -> Bool
$comitField :: NetworkStake -> Bool
toEncodingList :: [NetworkStake] -> Encoding
$ctoEncodingList :: [NetworkStake] -> Encoding
toJSONList :: [NetworkStake] -> Value
$ctoJSONList :: [NetworkStake] -> Value
toEncoding :: NetworkStake -> Encoding
$ctoEncoding :: NetworkStake -> Encoding
toJSON :: NetworkStake -> Value
$ctoJSON :: NetworkStake -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_stake", CamelToSnake]] NetworkStake

netStakeSample :: NetworkStake
netStakeSample :: NetworkStake
netStakeSample =
  NetworkStake
    { _stakeLive :: Lovelaces
_stakeLive = Discrete' "ADA" '(1000000, 1)
23_204_950_463_991_654
    , _stakeActive :: Lovelaces
_stakeActive = Discrete' "ADA" '(1000000, 1)
22_210_233_523_456_321
    }

instance ToSample NetworkStake where
  toSamples :: Proxy NetworkStake -> [(Text, NetworkStake)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> [(Text, a)]
singleSample NetworkStake
netStakeSample

-- | Detailed network information
data Network = Network
  { Network -> NetworkSupply
_networkSupply :: NetworkSupply -- ^ Supply data
  , Network -> NetworkStake
_networkStake  :: NetworkStake -- ^ Stake data
  }
  deriving stock (Int -> Network -> ShowS
[Network] -> ShowS
Network -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Network] -> ShowS
$cshowList :: [Network] -> ShowS
show :: Network -> String
$cshow :: Network -> String
showsPrec :: Int -> Network -> ShowS
$cshowsPrec :: Int -> Network -> ShowS
Show, Network -> Network -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Network -> Network -> Bool
$c/= :: Network -> Network -> Bool
== :: Network -> Network -> Bool
$c== :: Network -> Network -> Bool
Eq, forall x. Rep Network x -> Network
forall x. Network -> Rep Network x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Network x -> Network
$cfrom :: forall x. Network -> Rep Network x
Generic)
  deriving (Maybe Network
Value -> Parser [Network]
Value -> Parser Network
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe Network
$comittedField :: Maybe Network
parseJSONList :: Value -> Parser [Network]
$cparseJSONList :: Value -> Parser [Network]
parseJSON :: Value -> Parser Network
$cparseJSON :: Value -> Parser Network
FromJSON, [Network] -> Encoding
[Network] -> Value
Network -> Bool
Network -> Encoding
Network -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: Network -> Bool
$comitField :: Network -> Bool
toEncodingList :: [Network] -> Encoding
$ctoEncodingList :: [Network] -> Encoding
toJSONList :: [Network] -> Value
$ctoJSONList :: [Network] -> Value
toEncoding :: Network -> Encoding
$ctoEncoding :: Network -> Encoding
toJSON :: Network -> Value
$ctoJSON :: Network -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_network", CamelToSnake]] Network

instance ToSample Network where
  toSamples :: Proxy Network -> [(Text, Network)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> [(Text, a)]
singleSample forall a b. (a -> b) -> a -> b
$
    NetworkSupply -> NetworkStake -> Network
Network NetworkSupply
netSupplySample NetworkStake
netStakeSample

-- | Time bounds of an era.
data NetworkEraBound = NetworkEraBound
  { NetworkEraBound -> Epoch
_boundEpoch :: Epoch, -- ^ The epoch number bounding a specific era.
    NetworkEraBound -> Slot
_boundSlot  :: Slot, -- ^ The slot number bounding a specific era.
    NetworkEraBound -> NominalDiffTime
_boundTime  :: NominalDiffTime -- ^ The time, relative to network system start, bounding a specific era.
  }
  deriving stock (Int -> NetworkEraBound -> ShowS
[NetworkEraBound] -> ShowS
NetworkEraBound -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkEraBound] -> ShowS
$cshowList :: [NetworkEraBound] -> ShowS
show :: NetworkEraBound -> String
$cshow :: NetworkEraBound -> String
showsPrec :: Int -> NetworkEraBound -> ShowS
$cshowsPrec :: Int -> NetworkEraBound -> ShowS
Show, NetworkEraBound -> NetworkEraBound -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkEraBound -> NetworkEraBound -> Bool
$c/= :: NetworkEraBound -> NetworkEraBound -> Bool
== :: NetworkEraBound -> NetworkEraBound -> Bool
$c== :: NetworkEraBound -> NetworkEraBound -> Bool
Eq, forall x. Rep NetworkEraBound x -> NetworkEraBound
forall x. NetworkEraBound -> Rep NetworkEraBound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkEraBound x -> NetworkEraBound
$cfrom :: forall x. NetworkEraBound -> Rep NetworkEraBound x
Generic)
  deriving (Maybe NetworkEraBound
Value -> Parser [NetworkEraBound]
Value -> Parser NetworkEraBound
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe NetworkEraBound
$comittedField :: Maybe NetworkEraBound
parseJSONList :: Value -> Parser [NetworkEraBound]
$cparseJSONList :: Value -> Parser [NetworkEraBound]
parseJSON :: Value -> Parser NetworkEraBound
$cparseJSON :: Value -> Parser NetworkEraBound
FromJSON, [NetworkEraBound] -> Encoding
[NetworkEraBound] -> Value
NetworkEraBound -> Bool
NetworkEraBound -> Encoding
NetworkEraBound -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: NetworkEraBound -> Bool
$comitField :: NetworkEraBound -> Bool
toEncodingList :: [NetworkEraBound] -> Encoding
$ctoEncodingList :: [NetworkEraBound] -> Encoding
toJSONList :: [NetworkEraBound] -> Value
$ctoJSONList :: [NetworkEraBound] -> Value
toEncoding :: NetworkEraBound -> Encoding
$ctoEncoding :: NetworkEraBound -> Encoding
toJSON :: NetworkEraBound -> Value
$ctoJSON :: NetworkEraBound -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_bound", CamelToSnake]] NetworkEraBound

netEraBoundSample0 :: NetworkEraBound
netEraBoundSample0 :: NetworkEraBound
netEraBoundSample0 =
  NetworkEraBound
    { _boundEpoch :: Epoch
_boundEpoch = Epoch
4
    , _boundSlot :: Slot
_boundSlot = Slot
86_400
    , _boundTime :: NominalDiffTime
_boundTime = NominalDiffTime
1_728_000
    }

netEraBoundSample1 :: NetworkEraBound
netEraBoundSample1 :: NetworkEraBound
netEraBoundSample1 =
  NetworkEraBound
    { _boundEpoch :: Epoch
_boundEpoch = Epoch
5
    , _boundSlot :: Slot
_boundSlot = Slot
518_400
    , _boundTime :: NominalDiffTime
_boundTime = NominalDiffTime
2_160_00
    }

instance ToSample NetworkEraBound where
  toSamples :: Proxy NetworkEraBound -> [(Text, NetworkEraBound)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [(Text, a)]
samples [NetworkEraBound
netEraBoundSample0, NetworkEraBound
netEraBoundSample1]

-- | Parameters for a network era which can vary between hardforks.
data NetworkEraParameters = NetworkEraParameters
  { NetworkEraParameters -> EpochLength
_parametersEpochLength :: EpochLength, -- ^ Number of slots in an epoch.
    NetworkEraParameters -> NominalDiffTime
_parametersSlotLength  :: NominalDiffTime, -- ^ How long a slot lasts.
    NetworkEraParameters -> Word64
_parametersSafeZone    :: Word64 -- ^ Number of slots from the tip of the ledger in which a hardfork will not happen.
  }
  deriving stock (Int -> NetworkEraParameters -> ShowS
[NetworkEraParameters] -> ShowS
NetworkEraParameters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkEraParameters] -> ShowS
$cshowList :: [NetworkEraParameters] -> ShowS
show :: NetworkEraParameters -> String
$cshow :: NetworkEraParameters -> String
showsPrec :: Int -> NetworkEraParameters -> ShowS
$cshowsPrec :: Int -> NetworkEraParameters -> ShowS
Show, NetworkEraParameters -> NetworkEraParameters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkEraParameters -> NetworkEraParameters -> Bool
$c/= :: NetworkEraParameters -> NetworkEraParameters -> Bool
== :: NetworkEraParameters -> NetworkEraParameters -> Bool
$c== :: NetworkEraParameters -> NetworkEraParameters -> Bool
Eq, forall x. Rep NetworkEraParameters x -> NetworkEraParameters
forall x. NetworkEraParameters -> Rep NetworkEraParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkEraParameters x -> NetworkEraParameters
$cfrom :: forall x. NetworkEraParameters -> Rep NetworkEraParameters x
Generic)
  deriving (Maybe NetworkEraParameters
Value -> Parser [NetworkEraParameters]
Value -> Parser NetworkEraParameters
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe NetworkEraParameters
$comittedField :: Maybe NetworkEraParameters
parseJSONList :: Value -> Parser [NetworkEraParameters]
$cparseJSONList :: Value -> Parser [NetworkEraParameters]
parseJSON :: Value -> Parser NetworkEraParameters
$cparseJSON :: Value -> Parser NetworkEraParameters
FromJSON, [NetworkEraParameters] -> Encoding
[NetworkEraParameters] -> Value
NetworkEraParameters -> Bool
NetworkEraParameters -> Encoding
NetworkEraParameters -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: NetworkEraParameters -> Bool
$comitField :: NetworkEraParameters -> Bool
toEncodingList :: [NetworkEraParameters] -> Encoding
$ctoEncodingList :: [NetworkEraParameters] -> Encoding
toJSONList :: [NetworkEraParameters] -> Value
$ctoJSONList :: [NetworkEraParameters] -> Value
toEncoding :: NetworkEraParameters -> Encoding
$ctoEncoding :: NetworkEraParameters -> Encoding
toJSON :: NetworkEraParameters -> Value
$ctoJSON :: NetworkEraParameters -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_parameters", CamelToSnake]] NetworkEraParameters

netEraParamSample :: NetworkEraParameters
netEraParamSample :: NetworkEraParameters
netEraParamSample =
  NetworkEraParameters
    { _parametersEpochLength :: EpochLength
_parametersEpochLength = EpochLength
432_000
    , _parametersSlotLength :: NominalDiffTime
_parametersSlotLength = NominalDiffTime
1
    , _parametersSafeZone :: Word64
_parametersSafeZone = Word64
129_600
    }

instance ToSample NetworkEraParameters where
  toSamples :: Proxy NetworkEraParameters -> [(Text, NetworkEraParameters)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> [(Text, a)]
singleSample NetworkEraParameters
netEraParamSample

-- | Summary of information about network eras.
data NetworkEraSummary = NetworkEraSummary
  { NetworkEraSummary -> NetworkEraBound
_networkEraStart      :: NetworkEraBound, -- ^ Start of a specific era.
    NetworkEraSummary -> NetworkEraBound
_networkEraEnd        :: NetworkEraBound, -- ^ End of a specific era.
    NetworkEraSummary -> NetworkEraParameters
_networkEraParameters :: NetworkEraParameters -- ^ Active parameters for a specific era.
  }
  deriving stock (Int -> NetworkEraSummary -> ShowS
[NetworkEraSummary] -> ShowS
NetworkEraSummary -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkEraSummary] -> ShowS
$cshowList :: [NetworkEraSummary] -> ShowS
show :: NetworkEraSummary -> String
$cshow :: NetworkEraSummary -> String
showsPrec :: Int -> NetworkEraSummary -> ShowS
$cshowsPrec :: Int -> NetworkEraSummary -> ShowS
Show, NetworkEraSummary -> NetworkEraSummary -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkEraSummary -> NetworkEraSummary -> Bool
$c/= :: NetworkEraSummary -> NetworkEraSummary -> Bool
== :: NetworkEraSummary -> NetworkEraSummary -> Bool
$c== :: NetworkEraSummary -> NetworkEraSummary -> Bool
Eq, forall x. Rep NetworkEraSummary x -> NetworkEraSummary
forall x. NetworkEraSummary -> Rep NetworkEraSummary x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkEraSummary x -> NetworkEraSummary
$cfrom :: forall x. NetworkEraSummary -> Rep NetworkEraSummary x
Generic)
  deriving (Maybe NetworkEraSummary
Value -> Parser [NetworkEraSummary]
Value -> Parser NetworkEraSummary
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
omittedField :: Maybe NetworkEraSummary
$comittedField :: Maybe NetworkEraSummary
parseJSONList :: Value -> Parser [NetworkEraSummary]
$cparseJSONList :: Value -> Parser [NetworkEraSummary]
parseJSON :: Value -> Parser NetworkEraSummary
$cparseJSON :: Value -> Parser NetworkEraSummary
FromJSON, [NetworkEraSummary] -> Encoding
[NetworkEraSummary] -> Value
NetworkEraSummary -> Bool
NetworkEraSummary -> Encoding
NetworkEraSummary -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
omitField :: NetworkEraSummary -> Bool
$comitField :: NetworkEraSummary -> Bool
toEncodingList :: [NetworkEraSummary] -> Encoding
$ctoEncodingList :: [NetworkEraSummary] -> Encoding
toJSONList :: [NetworkEraSummary] -> Value
$ctoJSONList :: [NetworkEraSummary] -> Value
toEncoding :: NetworkEraSummary -> Encoding
$ctoEncoding :: NetworkEraSummary -> Encoding
toJSON :: NetworkEraSummary -> Value
$ctoJSON :: NetworkEraSummary -> Value
ToJSON)
  via CustomJSON '[FieldLabelModifier '[StripPrefix "_networkEra", CamelToSnake]] NetworkEraSummary

instance ToSample NetworkEraSummary where
  toSamples :: Proxy NetworkEraSummary -> [(Text, NetworkEraSummary)]
toSamples = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [(Text, a)]
singleSample forall a b. (a -> b) -> a -> b
$
    NetworkEraSummary
      { _networkEraStart :: NetworkEraBound
_networkEraStart = NetworkEraBound
netEraBoundSample0
      , _networkEraEnd :: NetworkEraBound
_networkEraEnd = NetworkEraBound
netEraBoundSample1
      , _networkEraParameters :: NetworkEraParameters
_networkEraParameters = NetworkEraParameters
netEraParamSample
      }