{-# LANGUAGE CPP #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoStarIsType #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Binary.Encoding.EncCBOR (
  EncCBOR (..),
  PreEncoded (..),
  toByronCBOR,
) where

import Cardano.Crypto.DSIGN.Class (
  DSIGNAlgorithm,
  SigDSIGN,
  SignKeyDSIGN,
  SignedDSIGN,
  VerKeyDSIGN,
 )
import Cardano.Crypto.Hash.Class (
  Hash (..),
  HashAlgorithm,
 )
import Cardano.Crypto.KES.Class (
  KESAlgorithm,
  SigKES,
  VerKeyKES,
 )
import Cardano.Crypto.VRF.Class (
  CertVRF,
  CertifiedVRF (..),
  OutputVRF (..),
  SignKeyVRF,
  VRFAlgorithm,
  VerKeyVRF,
 )
import Cardano.Crypto.VRF.Mock (MockVRF)
import qualified Cardano.Crypto.VRF.Praos as Praos
import Cardano.Crypto.VRF.Simple (SimpleVRF)
import Cardano.Ledger.Binary.Crypto
import Cardano.Ledger.Binary.Encoding.Encoder
import Cardano.Ledger.Binary.Version (Version, byronProtVer)
import Cardano.Slotting.Block (BlockNo (..))
import Cardano.Slotting.Slot (
  EpochInterval (..),
  EpochNo (..),
  EpochSize (..),
  SlotNo (..),
  WithOrigin (..),
 )
import Cardano.Slotting.Time (SystemStart (..))
import Codec.CBOR.ByteArray (ByteArray (..))
import Codec.CBOR.ByteArray.Sliced (SlicedByteArray (SBA), fromByteArray)
import qualified Codec.CBOR.Encoding as C (Encoding (..))
import Codec.CBOR.Term (Term (..))
import qualified Codec.Serialise as Serialise (Serialise (encode))
import Control.Category (Category ((.)))
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BS.Lazy
import qualified Data.ByteString.Short as SBS (length)
#if MIN_VERSION_bytestring(0,11,1)
import Data.ByteString.Short (ShortByteString(SBS))
#else
import Data.ByteString.Short.Internal (ShortByteString(SBS))
#endif
import qualified Cardano.Binary as Plain (Encoding, ToCBOR (..))
import Data.Fixed (Fixed (..))
import Data.Foldable (toList)
import Data.IP (IPv4, IPv6)
import Data.Int (Int16, Int32, Int64, Int8)
import Data.List.NonEmpty (NonEmpty)
import qualified Data.Map.Strict as Map
import qualified Data.Maybe.Strict as SMaybe
import qualified Data.Primitive.ByteArray as Prim (ByteArray (..))
import Data.Ratio (Ratio)
import qualified Data.Sequence as Seq
import qualified Data.Sequence.Strict as SSeq
import qualified Data.Set as Set
import Data.Tagged (Tagged (..))
import qualified Data.Text as Text
import Data.Time.Clock (UTCTime (..))
import qualified Data.VMap as VMap
import qualified Data.Vector as V
import qualified Data.Vector.Primitive as VP
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Unboxed as VU
import Data.Void (Void, absurd)
import Data.Word (Word16, Word32, Word64, Word8)
import Numeric.Natural (Natural)
import qualified PlutusLedgerApi.V1 as PV1
import qualified PlutusLedgerApi.V2 as PV2
import qualified PlutusLedgerApi.V3 as PV3
import Prelude hiding (encodeFloat, (.))

class EncCBOR a where
  encCBOR :: a -> Encoding
  default encCBOR :: Plain.ToCBOR a => a -> Encoding
  encCBOR = Encoding -> Encoding
fromPlainEncoding (Encoding -> Encoding) -> (a -> Encoding) -> a -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> Encoding
forall a. ToCBOR a => a -> Encoding
Plain.toCBOR

newtype PreEncoded = PreEncoded {PreEncoded -> ByteString
unPreEncoded :: BS.ByteString}

instance EncCBOR PreEncoded where
  encCBOR :: PreEncoded -> Encoding
encCBOR = ByteString -> Encoding
encodePreEncoded (ByteString -> Encoding)
-> (PreEncoded -> ByteString) -> PreEncoded -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. PreEncoded -> ByteString
unPreEncoded

instance EncCBOR Version where
  encCBOR :: Version -> Encoding
encCBOR = Version -> Encoding
encodeVersion

-- | Convert a versioned `EncCBOR` instance to a plain `Plain.Encoding` using Byron
-- protocol version.
toByronCBOR :: EncCBOR a => a -> Plain.Encoding
toByronCBOR :: forall a. EncCBOR a => a -> Encoding
toByronCBOR = Version -> Encoding -> Encoding
toPlainEncoding Version
byronProtVer (Encoding -> Encoding) -> (a -> Encoding) -> a -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

--------------------------------------------------------------------------------
-- Primitive types
--------------------------------------------------------------------------------

instance EncCBOR () where
  encCBOR :: () -> Encoding
encCBOR = Encoding -> () -> Encoding
forall a b. a -> b -> a
const Encoding
encodeNull

instance EncCBOR Bool where
  encCBOR :: Bool -> Encoding
encCBOR = Bool -> Encoding
encodeBool

--------------------------------------------------------------------------------
-- Numeric data
--------------------------------------------------------------------------------

instance EncCBOR Integer where
  encCBOR :: Integer -> Encoding
encCBOR = Integer -> Encoding
encodeInteger

instance EncCBOR Word where
  encCBOR :: Word -> Encoding
encCBOR = Word -> Encoding
encodeWord

instance EncCBOR Word8 where
  encCBOR :: Word8 -> Encoding
encCBOR = Word8 -> Encoding
encodeWord8

instance EncCBOR Word16 where
  encCBOR :: Word16 -> Encoding
encCBOR = Word16 -> Encoding
encodeWord16

instance EncCBOR Word32 where
  encCBOR :: Word32 -> Encoding
encCBOR = Word32 -> Encoding
encodeWord32

instance EncCBOR Word64 where
  encCBOR :: Word64 -> Encoding
encCBOR = Word64 -> Encoding
encodeWord64

instance EncCBOR Int where
  encCBOR :: Int -> Encoding
encCBOR = Int -> Encoding
encodeInt

instance EncCBOR Int8 where
  encCBOR :: Int8 -> Encoding
encCBOR = Int8 -> Encoding
encodeInt8

instance EncCBOR Int16 where
  encCBOR :: Int16 -> Encoding
encCBOR = Int16 -> Encoding
encodeInt16

instance EncCBOR Int32 where
  encCBOR :: Int32 -> Encoding
encCBOR = Int32 -> Encoding
encodeInt32

instance EncCBOR Int64 where
  encCBOR :: Int64 -> Encoding
encCBOR = Int64 -> Encoding
encodeInt64

instance EncCBOR Float where
  encCBOR :: Float -> Encoding
encCBOR = Float -> Encoding
encodeFloat

instance EncCBOR Double where
  encCBOR :: Double -> Encoding
encCBOR = Double -> Encoding
encodeDouble

instance EncCBOR a => EncCBOR (Ratio a) where
  encCBOR :: Ratio a -> Encoding
encCBOR = (a -> Encoding) -> Ratio a -> Encoding
forall t. (t -> Encoding) -> Ratio t -> Encoding
encodeRatio a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

deriving newtype instance EncCBOR (Fixed p)

instance EncCBOR Natural where
  encCBOR :: Natural -> Encoding
encCBOR = Integer -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (Integer -> Encoding)
-> (Natural -> Integer) -> Natural -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Natural -> Integer
forall a. Integral a => a -> Integer
toInteger

instance EncCBOR Void where
  encCBOR :: Void -> Encoding
encCBOR = Void -> Encoding
forall a. Void -> a
absurd

instance EncCBOR IPv4 where
  encCBOR :: IPv4 -> Encoding
encCBOR = IPv4 -> Encoding
encodeIPv4

instance EncCBOR IPv6 where
  encCBOR :: IPv6 -> Encoding
encCBOR = IPv6 -> Encoding
encodeIPv6

--------------------------------------------------------------------------------
-- CBOR
--------------------------------------------------------------------------------

instance EncCBOR Term where
  encCBOR :: Term -> Encoding
encCBOR = Term -> Encoding
encodeTerm

instance EncCBOR Encoding where
  encCBOR :: Encoding -> Encoding
encCBOR = Encoding -> Encoding
forall a. a -> a
id

instance EncCBOR C.Encoding where
  encCBOR :: Encoding -> Encoding
encCBOR = Encoding -> Encoding
fromPlainEncoding

instance EncCBOR (Tokens -> Tokens) where
  encCBOR :: (Tokens -> Tokens) -> Encoding
encCBOR Tokens -> Tokens
t = Encoding -> Encoding
fromPlainEncoding ((Tokens -> Tokens) -> Encoding
C.Encoding Tokens -> Tokens
t)

--------------------------------------------------------------------------------
-- Tagged
--------------------------------------------------------------------------------

instance EncCBOR a => EncCBOR (Tagged s a) where
  encCBOR :: Tagged s a -> Encoding
encCBOR (Tagged a
a) = a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a

--------------------------------------------------------------------------------
-- Containers
--------------------------------------------------------------------------------

instance (EncCBOR a, EncCBOR b) => EncCBOR (a, b) where
  encCBOR :: (a, b) -> Encoding
encCBOR (a
a, b
b) = Word -> Encoding
encodeListLen Word
2 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b

instance (EncCBOR a, EncCBOR b, EncCBOR c) => EncCBOR (a, b, c) where
  encCBOR :: (a, b, c) -> Encoding
encCBOR (a
a, b
b, c
c) = Word -> Encoding
encodeListLen Word
3 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> c -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR c
c

instance (EncCBOR a, EncCBOR b, EncCBOR c, EncCBOR d) => EncCBOR (a, b, c, d) where
  encCBOR :: (a, b, c, d) -> Encoding
encCBOR (a
a, b
b, c
c, d
d) =
    Word -> Encoding
encodeListLen Word
4 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> c -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR c
c Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> d -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR d
d

instance
  (EncCBOR a, EncCBOR b, EncCBOR c, EncCBOR d, EncCBOR e) =>
  EncCBOR (a, b, c, d, e)
  where
  encCBOR :: (a, b, c, d, e) -> Encoding
encCBOR (a
a, b
b, c
c, d
d, e
e) =
    Word -> Encoding
encodeListLen Word
5
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> c -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR c
c
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> d -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR d
d
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> e -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR e
e

instance
  (EncCBOR a, EncCBOR b, EncCBOR c, EncCBOR d, EncCBOR e, EncCBOR f) =>
  EncCBOR (a, b, c, d, e, f)
  where
  encCBOR :: (a, b, c, d, e, f) -> Encoding
encCBOR (a
a, b
b, c
c, d
d, e
e, f
f) =
    Word -> Encoding
encodeListLen Word
6
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> c -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR c
c
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> d -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR d
d
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> e -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR e
e
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> f -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR f
f

instance
  (EncCBOR a, EncCBOR b, EncCBOR c, EncCBOR d, EncCBOR e, EncCBOR f, EncCBOR g) =>
  EncCBOR (a, b, c, d, e, f, g)
  where
  encCBOR :: (a, b, c, d, e, f, g) -> Encoding
encCBOR (a
a, b
b, c
c, d
d, e
e, f
f, g
g) =
    Word -> Encoding
encodeListLen Word
7
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
a
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
b
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> c -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR c
c
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> d -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR d
d
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> e -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR e
e
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> f -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR f
f
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> g -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR g
g

instance EncCBOR BS.ByteString where
  encCBOR :: ByteString -> Encoding
encCBOR = ByteString -> Encoding
encodeBytes

instance EncCBOR Text.Text where
  encCBOR :: Text -> Encoding
encCBOR = Text -> Encoding
encodeString

instance EncCBOR ByteArray where
  encCBOR :: ByteArray -> Encoding
encCBOR = ByteArray -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ByteArray -> Encoding)
-> (ByteArray -> ByteArray) -> ByteArray -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteArray -> ByteArray
unBA
  {-# INLINE encCBOR #-}

instance EncCBOR Prim.ByteArray where
  encCBOR :: ByteArray -> Encoding
encCBOR = SlicedByteArray -> Encoding
encodeByteArray (SlicedByteArray -> Encoding)
-> (ByteArray -> SlicedByteArray) -> ByteArray -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteArray -> SlicedByteArray
fromByteArray
  {-# INLINE encCBOR #-}

instance EncCBOR SlicedByteArray where
  encCBOR :: SlicedByteArray -> Encoding
encCBOR = SlicedByteArray -> Encoding
encodeByteArray
  {-# INLINE encCBOR #-}

instance EncCBOR ShortByteString where
  encCBOR :: ShortByteString -> Encoding
encCBOR sbs :: ShortByteString
sbs@(SBS ByteArray#
ba) =
    SlicedByteArray -> Encoding
encodeByteArray (SlicedByteArray -> Encoding) -> SlicedByteArray -> Encoding
forall a b. (a -> b) -> a -> b
$ ByteArray -> Int -> Int -> SlicedByteArray
SBA (ByteArray# -> ByteArray
Prim.ByteArray ByteArray#
ba) Int
0 (ShortByteString -> Int
SBS.length ShortByteString
sbs)

instance EncCBOR BS.Lazy.ByteString where
  encCBOR :: ByteString -> Encoding
encCBOR = ByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ByteString -> Encoding)
-> (ByteString -> ByteString) -> ByteString -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
BS.Lazy.toStrict

instance EncCBOR a => EncCBOR [a] where
  encCBOR :: [a] -> Encoding
encCBOR = (a -> Encoding) -> [a] -> Encoding
forall a. (a -> Encoding) -> [a] -> Encoding
encodeList a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance (EncCBOR a, EncCBOR b) => EncCBOR (Either a b) where
  encCBOR :: Either a b -> Encoding
encCBOR (Left a
x) = Word -> Encoding
encodeListLen Word
2 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Word -> Encoding
encodeWord Word
0 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
x
  encCBOR (Right b
x) = Word -> Encoding
encodeListLen Word
2 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Word -> Encoding
encodeWord Word
1 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> b -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR b
x

instance EncCBOR a => EncCBOR (NonEmpty a) where
  encCBOR :: NonEmpty a -> Encoding
encCBOR = [a] -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ([a] -> Encoding) -> (NonEmpty a -> [a]) -> NonEmpty a -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
toList

instance EncCBOR a => EncCBOR (Maybe a) where
  encCBOR :: Maybe a -> Encoding
encCBOR = (a -> Encoding) -> Maybe a -> Encoding
forall a. (a -> Encoding) -> Maybe a -> Encoding
encodeMaybe a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance EncCBOR a => EncCBOR (SMaybe.StrictMaybe a) where
  encCBOR :: StrictMaybe a -> Encoding
encCBOR = (a -> Encoding) -> StrictMaybe a -> Encoding
forall a. (a -> Encoding) -> StrictMaybe a -> Encoding
encodeStrictMaybe a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance (EncCBOR k, EncCBOR v) => EncCBOR (Map.Map k v) where
  encCBOR :: Map k v -> Encoding
encCBOR = (k -> Encoding) -> (v -> Encoding) -> Map k v -> Encoding
forall k v.
(k -> Encoding) -> (v -> Encoding) -> Map k v -> Encoding
encodeMap k -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR v -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance EncCBOR a => EncCBOR (Set.Set a) where
  encCBOR :: Set a -> Encoding
encCBOR = (a -> Encoding) -> Set a -> Encoding
forall a. (a -> Encoding) -> Set a -> Encoding
encodeSet a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance EncCBOR a => EncCBOR (Seq.Seq a) where
  encCBOR :: Seq a -> Encoding
encCBOR = (a -> Encoding) -> Seq a -> Encoding
forall a. (a -> Encoding) -> Seq a -> Encoding
encodeSeq a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance EncCBOR a => EncCBOR (SSeq.StrictSeq a) where
  encCBOR :: StrictSeq a -> Encoding
encCBOR = (a -> Encoding) -> StrictSeq a -> Encoding
forall a. (a -> Encoding) -> StrictSeq a -> Encoding
encodeStrictSeq a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance
  (EncCBOR k, EncCBOR v, VMap.Vector kv k, VMap.Vector vv v) =>
  EncCBOR (VMap.VMap kv vv k v)
  where
  encCBOR :: VMap kv vv k v -> Encoding
encCBOR = (k -> Encoding) -> (v -> Encoding) -> VMap kv vv k v -> Encoding
forall (kv :: Type -> Type) k (vv :: Type -> Type) v.
(Vector kv k, Vector vv v) =>
(k -> Encoding) -> (v -> Encoding) -> VMap kv vv k v -> Encoding
encodeVMap k -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR v -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR

instance EncCBOR a => EncCBOR (V.Vector a) where
  encCBOR :: Vector a -> Encoding
encCBOR = (a -> Encoding) -> Vector a -> Encoding
forall (v :: Type -> Type) a.
Vector v a =>
(a -> Encoding) -> v a -> Encoding
encodeVector a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR
  {-# INLINE encCBOR #-}

instance (EncCBOR a, VP.Prim a) => EncCBOR (VP.Vector a) where
  encCBOR :: Vector a -> Encoding
encCBOR = (a -> Encoding) -> Vector a -> Encoding
forall (v :: Type -> Type) a.
Vector v a =>
(a -> Encoding) -> v a -> Encoding
encodeVector a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR
  {-# INLINE encCBOR #-}

instance (EncCBOR a, VS.Storable a) => EncCBOR (VS.Vector a) where
  encCBOR :: Vector a -> Encoding
encCBOR = (a -> Encoding) -> Vector a -> Encoding
forall (v :: Type -> Type) a.
Vector v a =>
(a -> Encoding) -> v a -> Encoding
encodeVector a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR
  {-# INLINE encCBOR #-}

instance (EncCBOR a, VU.Unbox a) => EncCBOR (VU.Vector a) where
  encCBOR :: Vector a -> Encoding
encCBOR = (a -> Encoding) -> Vector a -> Encoding
forall (v :: Type -> Type) a.
Vector v a =>
(a -> Encoding) -> v a -> Encoding
encodeVector a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR
  {-# INLINE encCBOR #-}

--------------------------------------------------------------------------------
-- Time
--------------------------------------------------------------------------------

instance EncCBOR UTCTime where
  encCBOR :: UTCTime -> Encoding
encCBOR = UTCTime -> Encoding
encodeUTCTime

--------------------------------------------------------------------------------
-- DSIGN
--------------------------------------------------------------------------------

instance DSIGNAlgorithm v => EncCBOR (VerKeyDSIGN v) where
  encCBOR :: VerKeyDSIGN v -> Encoding
encCBOR = VerKeyDSIGN v -> Encoding
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> Encoding
encodeVerKeyDSIGN

instance DSIGNAlgorithm v => EncCBOR (SignKeyDSIGN v) where
  encCBOR :: SignKeyDSIGN v -> Encoding
encCBOR = SignKeyDSIGN v -> Encoding
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> Encoding
encodeSignKeyDSIGN

instance DSIGNAlgorithm v => EncCBOR (SigDSIGN v) where
  encCBOR :: SigDSIGN v -> Encoding
encCBOR = SigDSIGN v -> Encoding
forall v. DSIGNAlgorithm v => SigDSIGN v -> Encoding
encodeSigDSIGN

instance DSIGNAlgorithm v => EncCBOR (SignedDSIGN v a) where
  encCBOR :: SignedDSIGN v a -> Encoding
encCBOR = SignedDSIGN v a -> Encoding
forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
encodeSignedDSIGN

--------------------------------------------------------------------------------
-- Hash
--------------------------------------------------------------------------------

instance HashAlgorithm h => EncCBOR (Hash h a) where
  encCBOR :: Hash h a -> Encoding
encCBOR (UnsafeHash ShortByteString
h) = ShortByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ShortByteString
h

instance KESAlgorithm k => EncCBOR (VerKeyKES k) where
  encCBOR :: VerKeyKES k -> Encoding
encCBOR = VerKeyKES k -> Encoding
forall k. KESAlgorithm k => VerKeyKES k -> Encoding
encodeVerKeyKES

instance KESAlgorithm k => EncCBOR (SigKES k) where
  encCBOR :: SigKES k -> Encoding
encCBOR = SigKES k -> Encoding
forall k. KESAlgorithm k => SigKES k -> Encoding
encodeSigKES

instance EncCBOR (VerKeyVRF SimpleVRF) where
  encCBOR :: VerKeyVRF SimpleVRF -> Encoding
encCBOR = VerKeyVRF SimpleVRF -> Encoding
forall v. VRFAlgorithm v => VerKeyVRF v -> Encoding
encodeVerKeyVRF

instance EncCBOR (SignKeyVRF SimpleVRF) where
  encCBOR :: SignKeyVRF SimpleVRF -> Encoding
encCBOR = SignKeyVRF SimpleVRF -> Encoding
forall v. VRFAlgorithm v => SignKeyVRF v -> Encoding
encodeSignKeyVRF

instance EncCBOR (CertVRF SimpleVRF) where
  encCBOR :: CertVRF SimpleVRF -> Encoding
encCBOR = CertVRF SimpleVRF -> Encoding
forall v. VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF

instance EncCBOR (VerKeyVRF MockVRF) where
  encCBOR :: VerKeyVRF MockVRF -> Encoding
encCBOR = VerKeyVRF MockVRF -> Encoding
forall v. VRFAlgorithm v => VerKeyVRF v -> Encoding
encodeVerKeyVRF

instance EncCBOR (SignKeyVRF MockVRF) where
  encCBOR :: SignKeyVRF MockVRF -> Encoding
encCBOR = SignKeyVRF MockVRF -> Encoding
forall v. VRFAlgorithm v => SignKeyVRF v -> Encoding
encodeSignKeyVRF

instance EncCBOR (CertVRF MockVRF) where
  encCBOR :: CertVRF MockVRF -> Encoding
encCBOR = CertVRF MockVRF -> Encoding
forall v. VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF

deriving instance EncCBOR (OutputVRF v)

instance VRFAlgorithm v => EncCBOR (CertifiedVRF v a) where
  encCBOR :: CertifiedVRF v a -> Encoding
encCBOR CertifiedVRF v a
cvrf =
    Word -> Encoding
encodeListLen Word
2
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> OutputVRF v -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (CertifiedVRF v a -> OutputVRF v
forall v a. CertifiedVRF v a -> OutputVRF v
certifiedOutput CertifiedVRF v a
cvrf)
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CertVRF v -> Encoding
forall v. VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF (CertifiedVRF v a -> CertVRF v
forall v a. CertifiedVRF v a -> CertVRF v
certifiedProof CertifiedVRF v a
cvrf)

instance EncCBOR Praos.Proof where
  encCBOR :: Proof -> Encoding
encCBOR = ByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ByteString -> Encoding)
-> (Proof -> ByteString) -> Proof -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Proof -> ByteString
Praos.proofBytes

instance EncCBOR Praos.SignKey where
  encCBOR :: SignKey -> Encoding
encCBOR = ByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ByteString -> Encoding)
-> (SignKey -> ByteString) -> SignKey -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. SignKey -> ByteString
Praos.skBytes

instance EncCBOR Praos.VerKey where
  encCBOR :: VerKey -> Encoding
encCBOR = ByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ByteString -> Encoding)
-> (VerKey -> ByteString) -> VerKey -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. VerKey -> ByteString
Praos.vkBytes

deriving instance EncCBOR (VerKeyVRF Praos.PraosVRF)

deriving instance EncCBOR (SignKeyVRF Praos.PraosVRF)

deriving instance EncCBOR (CertVRF Praos.PraosVRF)

--------------------------------------------------------------------------------
-- Slotting
--------------------------------------------------------------------------------

-- TODO: Remove usage of 'serialise' package
instance EncCBOR SlotNo where
  encCBOR :: SlotNo -> Encoding
encCBOR = Encoding -> Encoding
fromPlainEncoding (Encoding -> Encoding)
-> (SlotNo -> Encoding) -> SlotNo -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. SlotNo -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode

instance Serialise.Serialise t => EncCBOR (WithOrigin t) where
  encCBOR :: WithOrigin t -> Encoding
encCBOR = Encoding -> Encoding
fromPlainEncoding (Encoding -> Encoding)
-> (WithOrigin t -> Encoding) -> WithOrigin t -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. WithOrigin t -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode

deriving instance EncCBOR EpochNo

deriving instance EncCBOR EpochSize

deriving instance EncCBOR SystemStart

instance EncCBOR BlockNo where
  encCBOR :: BlockNo -> Encoding
encCBOR = Encoding -> Encoding
fromPlainEncoding (Encoding -> Encoding)
-> (BlockNo -> Encoding) -> BlockNo -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. BlockNo -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode

deriving instance EncCBOR EpochInterval

--------------------------------------------------------------------------------
-- Plutus
--------------------------------------------------------------------------------

instance Plain.ToCBOR PV1.Data where
  toCBOR :: Data -> Encoding
toCBOR = Data -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode

instance EncCBOR PV1.Data

instance EncCBOR PV1.ScriptContext where
  encCBOR :: ScriptContext -> Encoding
encCBOR = Data -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (Data -> Encoding)
-> (ScriptContext -> Data) -> ScriptContext -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ScriptContext -> Data
forall a. ToData a => a -> Data
PV3.toData

instance EncCBOR PV2.ScriptContext where
  encCBOR :: ScriptContext -> Encoding
encCBOR = Data -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (Data -> Encoding)
-> (ScriptContext -> Data) -> ScriptContext -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ScriptContext -> Data
forall a. ToData a => a -> Data
PV3.toData

instance EncCBOR PV3.ScriptContext where
  encCBOR :: ScriptContext -> Encoding
encCBOR = Data -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (Data -> Encoding)
-> (ScriptContext -> Data) -> ScriptContext -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> Type) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ScriptContext -> Data
forall a. ToData a => a -> Data
PV3.toData