{-# 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 (Nonce (..), ProtVer (..), StrictMaybe)
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.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.
EraTxBody 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
  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)

-- | 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)

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