{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies          #-}

{-# OPTIONS_GHC -Wno-orphans #-}
module Ouroboros.Consensus.Shelley.Node.Serialisation () where

import           Control.Exception (Exception, throw)
import qualified Data.ByteString.Lazy as Lazy
import           Data.Typeable (Typeable)

import           Cardano.Binary (fromCBOR, toCBOR)
import           Codec.Serialise (decode, encode)

import           Ouroboros.Network.Block (Serialised, unwrapCBORinCBOR,
                     wrapCBORinCBOR)

import           Ouroboros.Consensus.Block
import           Ouroboros.Consensus.HeaderValidation
import           Ouroboros.Consensus.Ledger.SupportsMempool (GenTxId)
import           Ouroboros.Consensus.Node.Run
import           Ouroboros.Consensus.Node.Serialisation
import           Ouroboros.Consensus.Storage.Serialisation

import qualified Shelley.Spec.Ledger.API as SL

import           Ouroboros.Consensus.Shelley.Eras (EraCrypto)
import           Ouroboros.Consensus.Shelley.Ledger
import           Ouroboros.Consensus.Shelley.Ledger.NetworkProtocolVersion ()
import           Ouroboros.Consensus.Shelley.Protocol

{-------------------------------------------------------------------------------
  EncodeDisk & DecodeDisk
-------------------------------------------------------------------------------}

instance ShelleyBasedEra era => HasBinaryBlockInfo (ShelleyBlock era) where
  getBinaryBlockInfo :: ShelleyBlock era -> BinaryBlockInfo
getBinaryBlockInfo = ShelleyBlock era -> BinaryBlockInfo
forall era.
ShelleyBasedEra era =>
ShelleyBlock era -> BinaryBlockInfo
shelleyBinaryBlockInfo

instance ShelleyBasedEra era => SerialiseDiskConstraints (ShelleyBlock era)

instance ShelleyBasedEra era => EncodeDisk (ShelleyBlock era) (ShelleyBlock era) where
  encodeDisk :: CodecConfig (ShelleyBlock era) -> ShelleyBlock era -> Encoding
encodeDisk CodecConfig (ShelleyBlock era)
_ = ShelleyBlock era -> Encoding
forall era. ShelleyBasedEra era => ShelleyBlock era -> Encoding
encodeShelleyBlock
instance ShelleyBasedEra era => DecodeDisk (ShelleyBlock era) (Lazy.ByteString -> ShelleyBlock era) where
  decodeDisk :: CodecConfig (ShelleyBlock era)
-> forall s. Decoder s (ByteString -> ShelleyBlock era)
decodeDisk CodecConfig (ShelleyBlock era)
_ = Decoder s (ByteString -> ShelleyBlock era)
forall era s.
ShelleyBasedEra era =>
Decoder s (ByteString -> ShelleyBlock era)
decodeShelleyBlock

instance ShelleyBasedEra era => EncodeDisk (ShelleyBlock era) (Header (ShelleyBlock era)) where
  encodeDisk :: CodecConfig (ShelleyBlock era)
-> Header (ShelleyBlock era) -> Encoding
encodeDisk CodecConfig (ShelleyBlock era)
_ = Header (ShelleyBlock era) -> Encoding
forall era.
ShelleyBasedEra era =>
Header (ShelleyBlock era) -> Encoding
encodeShelleyHeader
instance ShelleyBasedEra era => DecodeDisk (ShelleyBlock era) (Lazy.ByteString -> Header (ShelleyBlock era)) where
  decodeDisk :: CodecConfig (ShelleyBlock era)
-> forall s. Decoder s (ByteString -> Header (ShelleyBlock era))
decodeDisk CodecConfig (ShelleyBlock era)
_ = Decoder s (ByteString -> Header (ShelleyBlock era))
forall era s.
ShelleyBasedEra era =>
Decoder s (ByteString -> Header (ShelleyBlock era))
decodeShelleyHeader

instance ShelleyBasedEra era => EncodeDisk (ShelleyBlock era) (LedgerState (ShelleyBlock era)) where
  encodeDisk :: CodecConfig (ShelleyBlock era)
-> LedgerState (ShelleyBlock era) -> Encoding
encodeDisk CodecConfig (ShelleyBlock era)
_ = LedgerState (ShelleyBlock era) -> Encoding
forall era.
ShelleyBasedEra era =>
LedgerState (ShelleyBlock era) -> Encoding
encodeShelleyLedgerState
instance ShelleyBasedEra era => DecodeDisk (ShelleyBlock era) (LedgerState (ShelleyBlock era)) where
  decodeDisk :: CodecConfig (ShelleyBlock era)
-> forall s. Decoder s (LedgerState (ShelleyBlock era))
decodeDisk CodecConfig (ShelleyBlock era)
_ = Decoder s (LedgerState (ShelleyBlock era))
forall era s.
ShelleyBasedEra era =>
Decoder s (LedgerState (ShelleyBlock era))
decodeShelleyLedgerState

-- | @'ChainDepState' ('BlockProtocol' ('ShelleyBlock' era))@
instance (ShelleyBasedEra era, EraCrypto era ~ c) => EncodeDisk (ShelleyBlock era) (TPraosState c) where
  encodeDisk :: CodecConfig (ShelleyBlock era) -> TPraosState c -> Encoding
encodeDisk CodecConfig (ShelleyBlock era)
_ = TPraosState c -> Encoding
forall a. Serialise a => a -> Encoding
encode
-- | @'ChainDepState' ('BlockProtocol' ('ShelleyBlock' era))@
instance (ShelleyBasedEra era, EraCrypto era ~ c) => DecodeDisk (ShelleyBlock era) (TPraosState c) where
  decodeDisk :: CodecConfig (ShelleyBlock era)
-> forall s. Decoder s (TPraosState c)
decodeDisk CodecConfig (ShelleyBlock era)
_ = Decoder s (TPraosState c)
forall a s. Serialise a => Decoder s a
decode

instance ShelleyBasedEra era => EncodeDisk (ShelleyBlock era) (AnnTip (ShelleyBlock era)) where
  encodeDisk :: CodecConfig (ShelleyBlock era)
-> AnnTip (ShelleyBlock era) -> Encoding
encodeDisk CodecConfig (ShelleyBlock era)
_ = AnnTip (ShelleyBlock era) -> Encoding
forall era.
ShelleyBasedEra era =>
AnnTip (ShelleyBlock era) -> Encoding
encodeShelleyAnnTip
instance ShelleyBasedEra era =>  DecodeDisk (ShelleyBlock era) (AnnTip (ShelleyBlock era)) where
  decodeDisk :: CodecConfig (ShelleyBlock era)
-> forall s. Decoder s (AnnTip (ShelleyBlock era))
decodeDisk CodecConfig (ShelleyBlock era)
_ = Decoder s (AnnTip (ShelleyBlock era))
forall era s.
ShelleyBasedEra era =>
Decoder s (AnnTip (ShelleyBlock era))
decodeShelleyAnnTip

{-------------------------------------------------------------------------------
  SerialiseNodeToNode
-------------------------------------------------------------------------------}

instance ShelleyBasedEra era => SerialiseNodeToNodeConstraints (ShelleyBlock era) where
  estimateBlockSize :: Header (ShelleyBlock era) -> SizeInBytes
estimateBlockSize Header (ShelleyBlock era)
hdr = SizeInBytes
overhead SizeInBytes -> SizeInBytes -> SizeInBytes
forall a. Num a => a -> a -> a
+ SizeInBytes
hdrSize SizeInBytes -> SizeInBytes -> SizeInBytes
forall a. Num a => a -> a -> a
+ SizeInBytes
bodySize
    where
      -- The maximum block size is 65536, the CBOR-in-CBOR tag for this block
      -- is:
      --
      -- > D8 18          # tag(24)
      -- >    1A 00010000 # bytes(65536)
      --
      -- Which is 7 bytes, enough for up to 4294967295 bytes.
      overhead :: SizeInBytes
overhead = SizeInBytes
7 {- CBOR-in-CBOR -} SizeInBytes -> SizeInBytes -> SizeInBytes
forall a. Num a => a -> a -> a
+ SizeInBytes
1 {- encodeListLen -}
      bodySize :: SizeInBytes
bodySize = Natural -> SizeInBytes
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Natural -> SizeInBytes)
-> (Header (ShelleyBlock era) -> Natural)
-> Header (ShelleyBlock era)
-> SizeInBytes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BHBody (Crypto era) -> Natural
forall crypto. BHBody crypto -> Natural
SL.bsize (BHBody (Crypto era) -> Natural)
-> (Header (ShelleyBlock era) -> BHBody (Crypto era))
-> Header (ShelleyBlock era)
-> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BHeader (Crypto era) -> BHBody (Crypto era)
forall crypto. Crypto crypto => BHeader crypto -> BHBody crypto
SL.bhbody (BHeader (Crypto era) -> BHBody (Crypto era))
-> (Header (ShelleyBlock era) -> BHeader (Crypto era))
-> Header (ShelleyBlock era)
-> BHBody (Crypto era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Header (ShelleyBlock era) -> BHeader (Crypto era)
forall era. Header (ShelleyBlock era) -> BHeader (EraCrypto era)
shelleyHeaderRaw (Header (ShelleyBlock era) -> SizeInBytes)
-> Header (ShelleyBlock era) -> SizeInBytes
forall a b. (a -> b) -> a -> b
$ Header (ShelleyBlock era)
hdr
      hdrSize :: SizeInBytes
hdrSize  = Int -> SizeInBytes
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> SizeInBytes)
-> (Header (ShelleyBlock era) -> Int)
-> Header (ShelleyBlock era)
-> SizeInBytes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BHeader (Crypto era) -> Int
forall crypto. Crypto crypto => BHeader crypto -> Int
SL.bHeaderSize (BHeader (Crypto era) -> Int)
-> (Header (ShelleyBlock era) -> BHeader (Crypto era))
-> Header (ShelleyBlock era)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Header (ShelleyBlock era) -> BHeader (Crypto era)
forall era. Header (ShelleyBlock era) -> BHeader (EraCrypto era)
shelleyHeaderRaw (Header (ShelleyBlock era) -> SizeInBytes)
-> Header (ShelleyBlock era) -> SizeInBytes
forall a b. (a -> b) -> a -> b
$ Header (ShelleyBlock era)
hdr

-- | CBOR-in-CBOR for the annotation. This also makes it compatible with the
-- wrapped ('Serialised') variant.
instance ShelleyBasedEra era => SerialiseNodeToNode (ShelleyBlock era) (ShelleyBlock era) where
  encodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> ShelleyBlock era
-> Encoding
encodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = (ShelleyBlock era -> Encoding) -> ShelleyBlock era -> Encoding
forall a. (a -> Encoding) -> a -> Encoding
wrapCBORinCBOR   ShelleyBlock era -> Encoding
forall era. ShelleyBasedEra era => ShelleyBlock era -> Encoding
encodeShelleyBlock
  decodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> forall s. Decoder s (ShelleyBlock era)
decodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = (forall s. Decoder s (ByteString -> ShelleyBlock era))
-> forall s. Decoder s (ShelleyBlock era)
forall a.
(forall s. Decoder s (ByteString -> a)) -> forall s. Decoder s a
unwrapCBORinCBOR forall s. Decoder s (ByteString -> ShelleyBlock era)
forall era s.
ShelleyBasedEra era =>
Decoder s (ByteString -> ShelleyBlock era)
decodeShelleyBlock

-- | 'Serialised' uses CBOR-in-CBOR by default.
instance SerialiseNodeToNode (ShelleyBlock era) (Serialised (ShelleyBlock era))
  -- Default instance

-- | CBOR-in-CBOR to be compatible with the wrapped ('Serialised') variant.
instance ShelleyBasedEra era => SerialiseNodeToNode (ShelleyBlock era) (Header (ShelleyBlock era)) where
  encodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> Header (ShelleyBlock era)
-> Encoding
encodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = (Header (ShelleyBlock era) -> Encoding)
-> Header (ShelleyBlock era) -> Encoding
forall a. (a -> Encoding) -> a -> Encoding
wrapCBORinCBOR   Header (ShelleyBlock era) -> Encoding
forall era.
ShelleyBasedEra era =>
Header (ShelleyBlock era) -> Encoding
encodeShelleyHeader
  decodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> forall s. Decoder s (Header (ShelleyBlock era))
decodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = (forall s. Decoder s (ByteString -> Header (ShelleyBlock era)))
-> forall s. Decoder s (Header (ShelleyBlock era))
forall a.
(forall s. Decoder s (ByteString -> a)) -> forall s. Decoder s a
unwrapCBORinCBOR forall s. Decoder s (ByteString -> Header (ShelleyBlock era))
forall era s.
ShelleyBasedEra era =>
Decoder s (ByteString -> Header (ShelleyBlock era))
decodeShelleyHeader

-- | We use CBOR-in-CBOR
instance SerialiseNodeToNode (ShelleyBlock era) (SerialisedHeader (ShelleyBlock era)) where
  encodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> SerialisedHeader (ShelleyBlock era)
-> Encoding
encodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = SerialisedHeader (ShelleyBlock era) -> Encoding
forall blk.
TrivialDependency (NestedCtxt_ blk Header) =>
SerialisedHeader blk -> Encoding
encodeTrivialSerialisedHeader
  decodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> forall s. Decoder s (SerialisedHeader (ShelleyBlock era))
decodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = Decoder s (SerialisedHeader (ShelleyBlock era))
forall blk s.
TrivialDependency (NestedCtxt_ blk Header) =>
Decoder s (SerialisedHeader blk)
decodeTrivialSerialisedHeader

-- | The @To/FromCBOR@ instances defined in @cardano-ledger-specs@ use
-- CBOR-in-CBOR to get the annotation.
instance ShelleyBasedEra era => SerialiseNodeToNode (ShelleyBlock era) (GenTx (ShelleyBlock era)) where
  encodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> GenTx (ShelleyBlock era)
-> Encoding
encodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = GenTx (ShelleyBlock era) -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR
  decodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> forall s. Decoder s (GenTx (ShelleyBlock era))
decodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = Decoder s (GenTx (ShelleyBlock era))
forall a s. FromCBOR a => Decoder s a
fromCBOR

instance ShelleyBasedEra era => SerialiseNodeToNode (ShelleyBlock era) (GenTxId (ShelleyBlock era)) where
  encodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> GenTxId (ShelleyBlock era)
-> Encoding
encodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = GenTxId (ShelleyBlock era) -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR
  decodeNodeToNode :: CodecConfig (ShelleyBlock era)
-> BlockNodeToNodeVersion (ShelleyBlock era)
-> forall s. Decoder s (GenTxId (ShelleyBlock era))
decodeNodeToNode CodecConfig (ShelleyBlock era)
_ BlockNodeToNodeVersion (ShelleyBlock era)
_ = Decoder s (GenTxId (ShelleyBlock era))
forall a s. FromCBOR a => Decoder s a
fromCBOR

{-------------------------------------------------------------------------------
  SerialiseNodeToClient
-------------------------------------------------------------------------------}

-- | Exception thrown in the encoders
data ShelleyEncoderException era =
    -- | A query was submitted that is not supported by the given
    -- 'ShelleyNodeToClientVersion'.
    ShelleyEncoderUnsupportedQuery
         (SomeSecond Query (ShelleyBlock era))
         ShelleyNodeToClientVersion
  deriving (Int -> ShelleyEncoderException era -> ShowS
[ShelleyEncoderException era] -> ShowS
ShelleyEncoderException era -> String
(Int -> ShelleyEncoderException era -> ShowS)
-> (ShelleyEncoderException era -> String)
-> ([ShelleyEncoderException era] -> ShowS)
-> Show (ShelleyEncoderException era)
forall era. Int -> ShelleyEncoderException era -> ShowS
forall era. [ShelleyEncoderException era] -> ShowS
forall era. ShelleyEncoderException era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShelleyEncoderException era] -> ShowS
$cshowList :: forall era. [ShelleyEncoderException era] -> ShowS
show :: ShelleyEncoderException era -> String
$cshow :: forall era. ShelleyEncoderException era -> String
showsPrec :: Int -> ShelleyEncoderException era -> ShowS
$cshowsPrec :: forall era. Int -> ShelleyEncoderException era -> ShowS
Show)

instance Typeable era => Exception (ShelleyEncoderException era)

instance ShelleyBasedEra era => SerialiseNodeToClientConstraints (ShelleyBlock era)

-- | CBOR-in-CBOR for the annotation. This also makes it compatible with the
-- wrapped ('Serialised') variant.
instance ShelleyBasedEra era => SerialiseNodeToClient (ShelleyBlock era) (ShelleyBlock era) where
  encodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> ShelleyBlock era
-> Encoding
encodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = (ShelleyBlock era -> Encoding) -> ShelleyBlock era -> Encoding
forall a. (a -> Encoding) -> a -> Encoding
wrapCBORinCBOR   ShelleyBlock era -> Encoding
forall era. ShelleyBasedEra era => ShelleyBlock era -> Encoding
encodeShelleyBlock
  decodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> forall s. Decoder s (ShelleyBlock era)
decodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = (forall s. Decoder s (ByteString -> ShelleyBlock era))
-> forall s. Decoder s (ShelleyBlock era)
forall a.
(forall s. Decoder s (ByteString -> a)) -> forall s. Decoder s a
unwrapCBORinCBOR forall s. Decoder s (ByteString -> ShelleyBlock era)
forall era s.
ShelleyBasedEra era =>
Decoder s (ByteString -> ShelleyBlock era)
decodeShelleyBlock

-- | 'Serialised' uses CBOR-in-CBOR by default.
instance SerialiseNodeToClient (ShelleyBlock era) (Serialised (ShelleyBlock era))
  -- Default instance

-- | Uses CBOR-in-CBOR in the @To/FromCBOR@ instances to get the annotation.
instance ShelleyBasedEra era => SerialiseNodeToClient (ShelleyBlock era) (GenTx (ShelleyBlock era)) where
  encodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> GenTx (ShelleyBlock era)
-> Encoding
encodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = GenTx (ShelleyBlock era) -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR
  decodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> forall s. Decoder s (GenTx (ShelleyBlock era))
decodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = Decoder s (GenTx (ShelleyBlock era))
forall a s. FromCBOR a => Decoder s a
fromCBOR

-- | @'ApplyTxErr' '(ShelleyBlock era)'@
instance ShelleyBasedEra era => SerialiseNodeToClient (ShelleyBlock era) (SL.ApplyTxError era) where
  encodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> ApplyTxError era
-> Encoding
encodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = ApplyTxError era -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR
  decodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> forall s. Decoder s (ApplyTxError era)
decodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = Decoder s (ApplyTxError era)
forall a s. FromCBOR a => Decoder s a
fromCBOR

instance ShelleyBasedEra era
      => SerialiseNodeToClient (ShelleyBlock era) (SomeSecond Query (ShelleyBlock era)) where
  encodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> SomeSecond Query (ShelleyBlock era)
-> Encoding
encodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
version (SomeSecond Query (ShelleyBlock era) b
q)
    | Query (ShelleyBlock era) b -> ShelleyNodeToClientVersion -> Bool
forall era result.
Query (ShelleyBlock era) result
-> ShelleyNodeToClientVersion -> Bool
querySupportedVersion Query (ShelleyBlock era) b
q BlockNodeToClientVersion (ShelleyBlock era)
ShelleyNodeToClientVersion
version
    = Query (ShelleyBlock era) b -> Encoding
forall era result.
ShelleyBasedEra era =>
Query (ShelleyBlock era) result -> Encoding
encodeShelleyQuery Query (ShelleyBlock era) b
q
    | Bool
otherwise
    = ShelleyEncoderException era -> Encoding
forall a e. Exception e => e -> a
throw (ShelleyEncoderException era -> Encoding)
-> ShelleyEncoderException era -> Encoding
forall a b. (a -> b) -> a -> b
$ SomeSecond Query (ShelleyBlock era)
-> ShelleyNodeToClientVersion -> ShelleyEncoderException era
forall era.
SomeSecond Query (ShelleyBlock era)
-> ShelleyNodeToClientVersion -> ShelleyEncoderException era
ShelleyEncoderUnsupportedQuery (Query (ShelleyBlock era) b -> SomeSecond Query (ShelleyBlock era)
forall (f :: * -> * -> *) a b. f a b -> SomeSecond f a
SomeSecond Query (ShelleyBlock era) b
q) BlockNodeToClientVersion (ShelleyBlock era)
ShelleyNodeToClientVersion
version
  decodeNodeToClient :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> forall s. Decoder s (SomeSecond Query (ShelleyBlock era))
decodeNodeToClient CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = Decoder s (SomeSecond Query (ShelleyBlock era))
forall era s.
ShelleyBasedEra era =>
Decoder s (SomeSecond Query (ShelleyBlock era))
decodeShelleyQuery

instance ShelleyBasedEra era => SerialiseResult (ShelleyBlock era) (Query (ShelleyBlock era)) where
  encodeResult :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> Query (ShelleyBlock era) result
-> result
-> Encoding
encodeResult CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = Query (ShelleyBlock era) result -> result -> Encoding
forall era result.
ShelleyBasedEra era =>
Query (ShelleyBlock era) result -> result -> Encoding
encodeShelleyResult
  decodeResult :: CodecConfig (ShelleyBlock era)
-> BlockNodeToClientVersion (ShelleyBlock era)
-> Query (ShelleyBlock era) result
-> forall s. Decoder s result
decodeResult CodecConfig (ShelleyBlock era)
_ BlockNodeToClientVersion (ShelleyBlock era)
_ = Query (ShelleyBlock era) result -> Decoder s result
forall era result.
ShelleyBasedEra era =>
Query (ShelleyBlock era) result -> forall s. Decoder s result
decodeShelleyResult

{-------------------------------------------------------------------------------
  HFC support

  Since 'NestedCtxt' for Shelley is trivial, these instances can use defaults.
-------------------------------------------------------------------------------}

instance ShelleyBasedEra era => ReconstructNestedCtxt Header (ShelleyBlock era)
instance ShelleyBasedEra era => EncodeDiskDepIx (NestedCtxt Header) (ShelleyBlock era)
instance ShelleyBasedEra era => EncodeDiskDep   (NestedCtxt Header) (ShelleyBlock era)
instance ShelleyBasedEra era => DecodeDiskDepIx (NestedCtxt Header) (ShelleyBlock era)
instance ShelleyBasedEra era => DecodeDiskDep   (NestedCtxt Header) (ShelleyBlock era)