{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}

module Cardano.Ledger.Block (
  Block (..),
  blockHeaderL,
  blockBodyL,
  bheader,
  bbody,
  TPraosBbodySignal (..),
  PraosBbodySignal (..),
  LeiosBbodySignal (..),
  EraBlockHeader (..),
  TPraosEraBlockHeader,
  PraosEraBlockHeader (..),
  LeiosEraBlockHeader (..),
  BlockHeaderVersionInfo (..),
  neededTxInsForBlock,
  EbReferencesAnnouncement (..),
) where

import Cardano.Ledger.BaseTypes (
  KeyValuePairs (..),
  Nonce (..),
  ProtVer (..),
  StrictMaybe,
  ToKeyValuePairs (..),
 )
import Cardano.Ledger.Binary (DecCBOR (..), EncCBOR (..), decodeRecordNamed, encodeListLen)
import Cardano.Ledger.Core
import Cardano.Ledger.TxIn (TxIn (..))
import Cardano.Slotting.Slot (SlotNo)
import Control.DeepSeq (NFData)
import Data.Aeson (ToJSON, (.=))
import Data.Foldable (toList)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Word (Word32)
import GHC.Generics (Generic)
import Lens.Micro (Lens', SimpleGetter, lens, (^.))
import NoThunks.Class (NoThunks (..))

data Block h era = Block
  { forall h era. Block h era -> h
blockHeader :: !h
  , forall h era. Block h era -> BlockBody era
blockBody :: !(BlockBody era)
  }
  deriving ((forall x. Block h era -> Rep (Block h era) x)
-> (forall x. Rep (Block h era) x -> Block h era)
-> Generic (Block h era)
forall x. Rep (Block h era) x -> Block h era
forall x. Block h era -> Rep (Block h era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall h era x. Rep (Block h era) x -> Block h era
forall h era x. Block h era -> Rep (Block h era) x
$cfrom :: forall h era x. Block h era -> Rep (Block h era) x
from :: forall x. Block h era -> Rep (Block h era) x
$cto :: forall h era x. Rep (Block h era) x -> Block h era
to :: forall x. Rep (Block h era) x -> Block h era
Generic)

deriving stock instance
  (Era era, Show (BlockBody era), Show h) =>
  Show (Block h era)

deriving stock instance
  (Era era, Eq (BlockBody era), Eq h) =>
  Eq (Block h era)

deriving anyclass instance
  ( Era era
  , NoThunks (BlockBody era)
  , NoThunks h
  ) =>
  NoThunks (Block h era)

instance (NFData h, NFData (BlockBody era)) => NFData (Block h era)

blockHeaderL :: Lens' (Block h era) h
blockHeaderL :: forall h era (f :: * -> *).
Functor f =>
(h -> f h) -> Block h era -> f (Block h era)
blockHeaderL = (Block h era -> h)
-> (Block h era -> h -> Block h era)
-> Lens (Block h era) (Block h era) h h
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Block h era -> h
forall h era. Block h era -> h
blockHeader (\Block h era
b h
h -> Block h era
b {blockHeader = h})

blockBodyL :: Lens' (Block h era) (BlockBody era)
blockBodyL :: forall h era (f :: * -> *).
Functor f =>
(BlockBody era -> f (BlockBody era))
-> Block h era -> f (Block h era)
blockBodyL = (Block h era -> BlockBody era)
-> (Block h era -> BlockBody era -> Block h era)
-> Lens (Block h era) (Block h era) (BlockBody era) (BlockBody era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Block h era -> BlockBody era
forall h era. Block h era -> BlockBody era
blockBody (\Block h era
b BlockBody era
h -> Block h era
b {blockBody = h})

bheader ::
  Block h era ->
  h
bheader :: forall h era. Block h era -> h
bheader (Block h
bh BlockBody era
_) = h
bh
{-# DEPRECATED bheader "In favor of `blockHeader`" #-}

bbody :: Block h era -> BlockBody era
bbody :: forall h era. Block h era -> BlockBody era
bbody (Block h
_ BlockBody era
txs) = BlockBody era
txs
{-# DEPRECATED bbody "In favor of `blockBody`" #-}

-- | The validity of any individual block depends only on a subset
-- of the UTxO stored in the ledger state. This function returns
-- the transaction inputs corresponding to the required UTxO for a
-- given Block.
--
-- This function will be used by the consensus layer to enable storing
-- the UTxO on disk. In particular, given a block, the consensus layer
-- will use 'neededTxInsForBlock' to retrieve the needed UTxO from disk
-- and present only those to the ledger.
neededTxInsForBlock ::
  forall h era.
  EraBlockBody era =>
  Block h era ->
  Set TxIn
neededTxInsForBlock :: forall h era. EraBlockBody era => Block h era -> Set TxIn
neededTxInsForBlock Block {BlockBody era
blockBody :: forall h era. Block h era -> BlockBody era
blockBody :: BlockBody era
blockBody} = (TxIn -> Bool) -> Set TxIn -> Set TxIn
forall a. (a -> Bool) -> Set a -> Set a
Set.filter TxIn -> Bool
isNotNewInput Set TxIn
allTxIns
  where
    txBodies :: [TxBody TopTx era]
txBodies = (Tx TopTx era -> TxBody TopTx era)
-> [Tx TopTx era] -> [TxBody TopTx era]
forall a b. (a -> b) -> [a] -> [b]
map (Tx TopTx era
-> Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
-> TxBody TopTx era
forall s a. s -> Getting a s a -> a
^. Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxBody l era)
forall (l :: TxLevel). Lens' (Tx l era) (TxBody l era)
bodyTxL) ([Tx TopTx era] -> [TxBody TopTx era])
-> [Tx TopTx era] -> [TxBody TopTx era]
forall a b. (a -> b) -> a -> b
$ StrictSeq (Tx TopTx era) -> [Tx TopTx era]
forall a. StrictSeq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (StrictSeq (Tx TopTx era) -> [Tx TopTx era])
-> StrictSeq (Tx TopTx era) -> [Tx TopTx era]
forall a b. (a -> b) -> a -> b
$ BlockBody era
blockBody BlockBody era
-> Getting
     (StrictSeq (Tx TopTx era))
     (BlockBody era)
     (StrictSeq (Tx TopTx era))
-> StrictSeq (Tx TopTx era)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (Tx TopTx era))
  (BlockBody era)
  (StrictSeq (Tx TopTx era))
forall era.
EraBlockBody era =>
Lens' (BlockBody era) (StrictSeq (Tx TopTx era))
Lens' (BlockBody era) (StrictSeq (Tx TopTx era))
txSeqBlockBodyL
    allTxIns :: Set TxIn
allTxIns = [Set TxIn] -> Set TxIn
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set TxIn] -> Set TxIn) -> [Set TxIn] -> Set TxIn
forall a b. (a -> b) -> a -> b
$ (TxBody TopTx era -> Set TxIn) -> [TxBody TopTx era] -> [Set TxIn]
forall a b. (a -> b) -> [a] -> [b]
map (TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era. EraTx era => SimpleGetter (TxBody TopTx era) (Set TxIn)
SimpleGetter (TxBody TopTx era) (Set TxIn)
allInputsTxBodyF) [TxBody TopTx era]
txBodies
    newTxIds :: Set TxId
newTxIds = [TxId] -> Set TxId
forall a. Ord a => [a] -> Set a
Set.fromList ([TxId] -> Set TxId) -> [TxId] -> Set TxId
forall a b. (a -> b) -> a -> b
$ (TxBody TopTx era -> TxId) -> [TxBody TopTx era] -> [TxId]
forall a b. (a -> b) -> [a] -> [b]
map TxBody TopTx era -> TxId
forall era (l :: TxLevel). EraTxBody era => TxBody l era -> TxId
txIdTxBody [TxBody TopTx era]
txBodies
    isNotNewInput :: TxIn -> Bool
isNotNewInput (TxIn TxId
txId TxIx
_) = TxId
txId TxId -> Set TxId -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.notMember` Set TxId
newTxIds

data TPraosBbodySignal era
  = forall h. (TPraosEraBlockHeader h era, EraBlockHeader h era) => TPraosBbodySignal (Block h era)

data PraosBbodySignal era
  = forall h. (PraosEraBlockHeader h era, EraBlockHeader h era) => PraosBbodySignal (Block h era)

data LeiosBbodySignal era
  = forall h. (LeiosEraBlockHeader h era, EraBlockHeader h era) => LeiosBbodySignal (Block h era)

class Era era => EraBlockHeader h era where
  blockIssuerBlockHeaderG :: SimpleGetter (Block h era) (KeyHash BlockIssuer)
  blockHeaderSizeBlockHeaderG :: SimpleGetter (Block h era) Int
  blockHeaderHashBlockHeaderG :: SimpleGetter (Block h era) (SafeHash EraIndependentBlockHeader)
  blockBodySizeBlockHeaderL :: Lens' (Block h era) Word32
  blockBodyHashBlockHeaderL :: Lens' (Block h era) (Hash HASH EraIndependentBlockBody)
  slotNoBlockHeaderL :: Lens' (Block h era) SlotNo

class Era era => TPraosEraBlockHeader h era

class Era era => PraosEraBlockHeader h era where
  protVerBlockHeaderL :: Lens' (Block h era) ProtVer

class Era era => LeiosEraBlockHeader h era where
  -- TODO Peras related:
  --
  -- This interface is slightly off and will need to be ajdusted once Peras gets
  -- implemented. Previous Nonce is probably not going to be part of the block header, but that
  -- doesn't mean we cannot use this interface, it is just the "block header" naming will not be
  -- accurate. In any case, today this is not a problem and we can keep this stub here and tackle it
  -- as part of this ticket: https://github.com/IntersectMBO/cardano-ledger/issues/6098
  prevNonceBlockHeaderL :: Lens' (Block h era) Nonce
  prevNonceBlockHeaderL = (Block h era -> Nonce)
-> (Block h era -> Nonce -> Block h era)
-> Lens' (Block h era) Nonce
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Nonce -> Block h era -> Nonce
forall a b. a -> b -> a
const Nonce
NeutralNonce) (\Block h era
b Nonce
_ -> Block h era
b)

  versionInfoBlockHeaderL :: Lens' (Block h era) BlockHeaderVersionInfo

  ebReferencesAnnouncementBlockHeaderL :: Lens' (Block h era) (StrictMaybe EbReferencesAnnouncement)

  blockBodyContainsLeiosCertBlockHeaderL :: Lens' (Block h era) Bool

-- | Version information reported by the block producer in the block header.
--
-- It has the same wire format as 'ProtVer', but neither field is validated upon decoding.
-- See <https://github.com/IntersectMBO/cardano-ledger/issues/5763>.
data BlockHeaderVersionInfo = BlockHeaderVersionInfo
  { BlockHeaderVersionInfo -> Word32
bhviHighestSupportedMajorVersion :: !Word32
  -- ^ Highest major protocol version that the block producer is capable of hard forking into
  , BlockHeaderVersionInfo -> Word32
bhviSelfReportedSoftwareTag :: !Word32
  -- ^ Arbitrary value chosen by the block producer's software; not interpreted by the ledger
  }
  deriving (Int -> BlockHeaderVersionInfo -> ShowS
[BlockHeaderVersionInfo] -> ShowS
BlockHeaderVersionInfo -> String
(Int -> BlockHeaderVersionInfo -> ShowS)
-> (BlockHeaderVersionInfo -> String)
-> ([BlockHeaderVersionInfo] -> ShowS)
-> Show BlockHeaderVersionInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlockHeaderVersionInfo -> ShowS
showsPrec :: Int -> BlockHeaderVersionInfo -> ShowS
$cshow :: BlockHeaderVersionInfo -> String
show :: BlockHeaderVersionInfo -> String
$cshowList :: [BlockHeaderVersionInfo] -> ShowS
showList :: [BlockHeaderVersionInfo] -> ShowS
Show, BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
(BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> (BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> Eq BlockHeaderVersionInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
== :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
$c/= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
/= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
Eq, Eq BlockHeaderVersionInfo
Eq BlockHeaderVersionInfo =>
(BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Ordering)
-> (BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> (BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> (BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> (BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool)
-> (BlockHeaderVersionInfo
    -> BlockHeaderVersionInfo -> BlockHeaderVersionInfo)
-> (BlockHeaderVersionInfo
    -> BlockHeaderVersionInfo -> BlockHeaderVersionInfo)
-> Ord BlockHeaderVersionInfo
BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Ordering
BlockHeaderVersionInfo
-> BlockHeaderVersionInfo -> BlockHeaderVersionInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Ordering
compare :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Ordering
$c< :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
< :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
$c<= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
<= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
$c> :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
> :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
$c>= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
>= :: BlockHeaderVersionInfo -> BlockHeaderVersionInfo -> Bool
$cmax :: BlockHeaderVersionInfo
-> BlockHeaderVersionInfo -> BlockHeaderVersionInfo
max :: BlockHeaderVersionInfo
-> BlockHeaderVersionInfo -> BlockHeaderVersionInfo
$cmin :: BlockHeaderVersionInfo
-> BlockHeaderVersionInfo -> BlockHeaderVersionInfo
min :: BlockHeaderVersionInfo
-> BlockHeaderVersionInfo -> BlockHeaderVersionInfo
Ord, (forall x. BlockHeaderVersionInfo -> Rep BlockHeaderVersionInfo x)
-> (forall x.
    Rep BlockHeaderVersionInfo x -> BlockHeaderVersionInfo)
-> Generic BlockHeaderVersionInfo
forall x. Rep BlockHeaderVersionInfo x -> BlockHeaderVersionInfo
forall x. BlockHeaderVersionInfo -> Rep BlockHeaderVersionInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BlockHeaderVersionInfo -> Rep BlockHeaderVersionInfo x
from :: forall x. BlockHeaderVersionInfo -> Rep BlockHeaderVersionInfo x
$cto :: forall x. Rep BlockHeaderVersionInfo x -> BlockHeaderVersionInfo
to :: forall x. Rep BlockHeaderVersionInfo x -> BlockHeaderVersionInfo
Generic)
  deriving anyclass (BlockHeaderVersionInfo -> ()
(BlockHeaderVersionInfo -> ()) -> NFData BlockHeaderVersionInfo
forall a. (a -> ()) -> NFData a
$crnf :: BlockHeaderVersionInfo -> ()
rnf :: BlockHeaderVersionInfo -> ()
NFData, Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo)
Proxy BlockHeaderVersionInfo -> String
(Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo))
-> (Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo))
-> (Proxy BlockHeaderVersionInfo -> String)
-> NoThunks BlockHeaderVersionInfo
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo)
noThunks :: Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> BlockHeaderVersionInfo -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy BlockHeaderVersionInfo -> String
showTypeOf :: Proxy BlockHeaderVersionInfo -> String
NoThunks)

instance EncCBOR BlockHeaderVersionInfo where
  encCBOR :: BlockHeaderVersionInfo -> Encoding
encCBOR (BlockHeaderVersionInfo Word32
major Word32
tag) = Word -> Encoding
encodeListLen Word
2 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Word32 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR Word32
major Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Word32 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR Word32
tag

instance DecCBOR BlockHeaderVersionInfo where
  decCBOR :: forall s. Decoder s BlockHeaderVersionInfo
decCBOR =
    Text
-> (BlockHeaderVersionInfo -> Int)
-> Decoder s BlockHeaderVersionInfo
-> Decoder s BlockHeaderVersionInfo
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed Text
"BlockHeaderVersionInfo" (Int -> BlockHeaderVersionInfo -> Int
forall a b. a -> b -> a
const Int
2) (Decoder s BlockHeaderVersionInfo
 -> Decoder s BlockHeaderVersionInfo)
-> Decoder s BlockHeaderVersionInfo
-> Decoder s BlockHeaderVersionInfo
forall a b. (a -> b) -> a -> b
$
      Word32 -> Word32 -> BlockHeaderVersionInfo
BlockHeaderVersionInfo (Word32 -> Word32 -> BlockHeaderVersionInfo)
-> Decoder s Word32 -> Decoder s (Word32 -> BlockHeaderVersionInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s Word32
forall s. Decoder s Word32
forall a s. DecCBOR a => Decoder s a
decCBOR Decoder s (Word32 -> BlockHeaderVersionInfo)
-> Decoder s Word32 -> Decoder s BlockHeaderVersionInfo
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s Word32
forall s. Decoder s Word32
forall a s. DecCBOR a => Decoder s a
decCBOR

-- | Announcement of Endorser Block (EB) references.
data EbReferencesAnnouncement = EbReferencesAnnouncement
  { EbReferencesAnnouncement -> SafeHash EraIndependentEbReferences
ebReferencesAnnouncementHash :: !(SafeHash EraIndependentEbReferences)
  -- ^ Hash of the announced Endorser Block references
  , EbReferencesAnnouncement -> Word32
ebReferencesAnnouncementSize :: !Word32
  -- ^ Size of the announced Endorser Block references
  }
  deriving stock (Int -> EbReferencesAnnouncement -> ShowS
[EbReferencesAnnouncement] -> ShowS
EbReferencesAnnouncement -> String
(Int -> EbReferencesAnnouncement -> ShowS)
-> (EbReferencesAnnouncement -> String)
-> ([EbReferencesAnnouncement] -> ShowS)
-> Show EbReferencesAnnouncement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EbReferencesAnnouncement -> ShowS
showsPrec :: Int -> EbReferencesAnnouncement -> ShowS
$cshow :: EbReferencesAnnouncement -> String
show :: EbReferencesAnnouncement -> String
$cshowList :: [EbReferencesAnnouncement] -> ShowS
showList :: [EbReferencesAnnouncement] -> ShowS
Show, EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool
(EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool)
-> (EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool)
-> Eq EbReferencesAnnouncement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool
== :: EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool
$c/= :: EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool
/= :: EbReferencesAnnouncement -> EbReferencesAnnouncement -> Bool
Eq, (forall x.
 EbReferencesAnnouncement -> Rep EbReferencesAnnouncement x)
-> (forall x.
    Rep EbReferencesAnnouncement x -> EbReferencesAnnouncement)
-> Generic EbReferencesAnnouncement
forall x.
Rep EbReferencesAnnouncement x -> EbReferencesAnnouncement
forall x.
EbReferencesAnnouncement -> Rep EbReferencesAnnouncement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
EbReferencesAnnouncement -> Rep EbReferencesAnnouncement x
from :: forall x.
EbReferencesAnnouncement -> Rep EbReferencesAnnouncement x
$cto :: forall x.
Rep EbReferencesAnnouncement x -> EbReferencesAnnouncement
to :: forall x.
Rep EbReferencesAnnouncement x -> EbReferencesAnnouncement
Generic)
  deriving anyclass (Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo)
Proxy EbReferencesAnnouncement -> String
(Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo))
-> (Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo))
-> (Proxy EbReferencesAnnouncement -> String)
-> NoThunks EbReferencesAnnouncement
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo)
noThunks :: Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> EbReferencesAnnouncement -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy EbReferencesAnnouncement -> String
showTypeOf :: Proxy EbReferencesAnnouncement -> String
NoThunks, EbReferencesAnnouncement -> ()
(EbReferencesAnnouncement -> ()) -> NFData EbReferencesAnnouncement
forall a. (a -> ()) -> NFData a
$crnf :: EbReferencesAnnouncement -> ()
rnf :: EbReferencesAnnouncement -> ()
NFData)
  deriving ([EbReferencesAnnouncement] -> Value
[EbReferencesAnnouncement] -> Encoding
EbReferencesAnnouncement -> Bool
EbReferencesAnnouncement -> Value
EbReferencesAnnouncement -> Encoding
(EbReferencesAnnouncement -> Value)
-> (EbReferencesAnnouncement -> Encoding)
-> ([EbReferencesAnnouncement] -> Value)
-> ([EbReferencesAnnouncement] -> Encoding)
-> (EbReferencesAnnouncement -> Bool)
-> ToJSON EbReferencesAnnouncement
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EbReferencesAnnouncement -> Value
toJSON :: EbReferencesAnnouncement -> Value
$ctoEncoding :: EbReferencesAnnouncement -> Encoding
toEncoding :: EbReferencesAnnouncement -> Encoding
$ctoJSONList :: [EbReferencesAnnouncement] -> Value
toJSONList :: [EbReferencesAnnouncement] -> Value
$ctoEncodingList :: [EbReferencesAnnouncement] -> Encoding
toEncodingList :: [EbReferencesAnnouncement] -> Encoding
$comitField :: EbReferencesAnnouncement -> Bool
omitField :: EbReferencesAnnouncement -> Bool
ToJSON) via KeyValuePairs EbReferencesAnnouncement

instance EncCBOR EbReferencesAnnouncement where
  encCBOR :: EbReferencesAnnouncement -> Encoding
encCBOR (EbReferencesAnnouncement SafeHash EraIndependentEbReferences
h Word32
s) =
    Word -> Encoding
encodeListLen Word
2
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> SafeHash EraIndependentEbReferences -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR SafeHash EraIndependentEbReferences
h
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Word32 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR Word32
s

instance DecCBOR EbReferencesAnnouncement where
  decCBOR :: forall s. Decoder s EbReferencesAnnouncement
decCBOR =
    Text
-> (EbReferencesAnnouncement -> Int)
-> Decoder s EbReferencesAnnouncement
-> Decoder s EbReferencesAnnouncement
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed Text
"EbReferencesAnnouncement" (Int -> EbReferencesAnnouncement -> Int
forall a b. a -> b -> a
const Int
2) (Decoder s EbReferencesAnnouncement
 -> Decoder s EbReferencesAnnouncement)
-> Decoder s EbReferencesAnnouncement
-> Decoder s EbReferencesAnnouncement
forall a b. (a -> b) -> a -> b
$
      SafeHash EraIndependentEbReferences
-> Word32 -> EbReferencesAnnouncement
EbReferencesAnnouncement
        (SafeHash EraIndependentEbReferences
 -> Word32 -> EbReferencesAnnouncement)
-> Decoder s (SafeHash EraIndependentEbReferences)
-> Decoder s (Word32 -> EbReferencesAnnouncement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (SafeHash EraIndependentEbReferences)
forall s. Decoder s (SafeHash EraIndependentEbReferences)
forall a s. DecCBOR a => Decoder s a
decCBOR
        Decoder s (Word32 -> EbReferencesAnnouncement)
-> Decoder s Word32 -> Decoder s EbReferencesAnnouncement
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s Word32
forall s. Decoder s Word32
forall a s. DecCBOR a => Decoder s a
decCBOR

instance ToKeyValuePairs EbReferencesAnnouncement where
  toKeyValuePairs :: forall e kv. KeyValue e kv => EbReferencesAnnouncement -> [kv]
toKeyValuePairs (EbReferencesAnnouncement SafeHash EraIndependentEbReferences
h Word32
s) =
    [ Key
"hash" Key -> SafeHash EraIndependentEbReferences -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SafeHash EraIndependentEbReferences
h
    , Key
"size" Key -> Word32 -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Word32
s
    ]