{-# LANGUAGE ScopedTypeVariables #-}

module Cardano.Ledger.Binary.Crypto (
  -- * DSIGN
  encodeVerKeyDSIGN,
  decodeVerKeyDSIGN,
  encodeSignKeyDSIGN,
  decodeSignKeyDSIGN,
  encodeSigDSIGN,
  decodeSigDSIGN,
  encodeSignedDSIGN,
  decodeSignedDSIGN,

  -- * KES
  encodeVerKeyKES,
  decodeVerKeyKES,
  encodeSigKES,
  decodeSigKES,
  encodeSignedKES,
  decodeSignedKES,

  -- * VRF
  encodeVerKeyVRF,
  decodeVerKeyVRF,
  encodeSignKeyVRF,
  decodeSignKeyVRF,
  encodeCertVRF,
  decodeCertVRF,
) where

import qualified Cardano.Crypto.DSIGN.Class as C
import qualified Cardano.Crypto.KES.Class as C
import qualified Cardano.Crypto.VRF.Class as C
import Cardano.Ledger.Binary.Decoding.Decoder (Decoder, decodeFixedSized)
import Cardano.Ledger.Binary.Encoding.Encoder (Encoding, encodeFixedSized)

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

encodeVerKeyDSIGN :: C.DSIGNAlgorithm v => C.VerKeyDSIGN v -> Encoding
encodeVerKeyDSIGN :: forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> Encoding
encodeVerKeyDSIGN = VerKeyDSIGN v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeVerKeyDSIGN #-}
{-# DEPRECATED encodeVerKeyDSIGN "Use encodeFixedSized instead" #-}

decodeVerKeyDSIGN :: C.DSIGNAlgorithm v => Decoder s (C.VerKeyDSIGN v)
decodeVerKeyDSIGN :: forall v s. DSIGNAlgorithm v => Decoder s (VerKeyDSIGN v)
decodeVerKeyDSIGN = Decoder s (VerKeyDSIGN v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeVerKeyDSIGN #-}
{-# DEPRECATED decodeVerKeyDSIGN "Use decodeFixedSized instead" #-}

encodeSignKeyDSIGN :: C.DSIGNAlgorithm v => C.SignKeyDSIGN v -> Encoding
encodeSignKeyDSIGN :: forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> Encoding
encodeSignKeyDSIGN = SignKeyDSIGN v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSignKeyDSIGN #-}
{-# DEPRECATED encodeSignKeyDSIGN "Use encodeFixedSized instead" #-}

decodeSignKeyDSIGN :: C.DSIGNAlgorithm v => Decoder s (C.SignKeyDSIGN v)
decodeSignKeyDSIGN :: forall v s. DSIGNAlgorithm v => Decoder s (SignKeyDSIGN v)
decodeSignKeyDSIGN = Decoder s (SignKeyDSIGN v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSignKeyDSIGN #-}
{-# DEPRECATED decodeSignKeyDSIGN "Use decodeFixedSized instead" #-}

encodeSigDSIGN :: C.DSIGNAlgorithm v => C.SigDSIGN v -> Encoding
encodeSigDSIGN :: forall v. DSIGNAlgorithm v => SigDSIGN v -> Encoding
encodeSigDSIGN = SigDSIGN v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSigDSIGN #-}
{-# DEPRECATED encodeSigDSIGN "Use encodeFixedSized instead" #-}

decodeSigDSIGN :: C.DSIGNAlgorithm v => Decoder s (C.SigDSIGN v)
decodeSigDSIGN :: forall v s. DSIGNAlgorithm v => Decoder s (SigDSIGN v)
decodeSigDSIGN = Decoder s (SigDSIGN v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSigDSIGN #-}
{-# DEPRECATED decodeSigDSIGN "Use decodeFixedSized instead" #-}

encodeSignedDSIGN :: C.DSIGNAlgorithm v => C.SignedDSIGN v a -> Encoding
encodeSignedDSIGN :: forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
encodeSignedDSIGN = SignedDSIGN v a -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSignedDSIGN #-}
{-# DEPRECATED encodeSignedDSIGN "Use encodeFixedSized instead" #-}

decodeSignedDSIGN :: C.DSIGNAlgorithm v => Decoder s (C.SignedDSIGN v a)
decodeSignedDSIGN :: forall v s a. DSIGNAlgorithm v => Decoder s (SignedDSIGN v a)
decodeSignedDSIGN = Decoder s (SignedDSIGN v a)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSignedDSIGN #-}
{-# DEPRECATED decodeSignedDSIGN "Use decodeFixedSized instead" #-}

--------------------------------------------------------------------------------
-- KES
--------------------------------------------------------------------------------

encodeVerKeyKES :: C.KESAlgorithm v => C.VerKeyKES v -> Encoding
encodeVerKeyKES :: forall v. KESAlgorithm v => VerKeyKES v -> Encoding
encodeVerKeyKES = VerKeyKES v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeVerKeyKES #-}
{-# DEPRECATED encodeVerKeyKES "Use encodeFixedSized instead" #-}

decodeVerKeyKES :: C.KESAlgorithm v => Decoder s (C.VerKeyKES v)
decodeVerKeyKES :: forall v s. KESAlgorithm v => Decoder s (VerKeyKES v)
decodeVerKeyKES = Decoder s (VerKeyKES v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeVerKeyKES #-}
{-# DEPRECATED decodeVerKeyKES "Use decodeFixedSized instead" #-}

encodeSigKES :: C.KESAlgorithm v => C.SigKES v -> Encoding
encodeSigKES :: forall v. KESAlgorithm v => SigKES v -> Encoding
encodeSigKES = SigKES v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSigKES #-}
{-# DEPRECATED encodeSigKES "Use encodeFixedSized instead" #-}

decodeSigKES :: C.KESAlgorithm v => Decoder s (C.SigKES v)
decodeSigKES :: forall v s. KESAlgorithm v => Decoder s (SigKES v)
decodeSigKES = Decoder s (SigKES v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSigKES #-}
{-# DEPRECATED decodeSigKES "Use decodeFixedSized instead" #-}

encodeSignedKES :: C.KESAlgorithm v => C.SignedKES v a -> Encoding
encodeSignedKES :: forall v a. KESAlgorithm v => SignedKES v a -> Encoding
encodeSignedKES = SignedKES v a -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSignedKES #-}
{-# DEPRECATED encodeSignedKES "Use encodeFixedSized instead" #-}

decodeSignedKES :: C.KESAlgorithm v => Decoder s (C.SignedKES v a)
decodeSignedKES :: forall v s a. KESAlgorithm v => Decoder s (SignedKES v a)
decodeSignedKES = Decoder s (SignedKES v a)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSignedKES #-}
{-# DEPRECATED decodeSignedKES "Use decodeFixedSized instead" #-}

--------------------------------------------------------------------------------
-- VRF
--------------------------------------------------------------------------------

encodeVerKeyVRF :: C.VRFAlgorithm v => C.VerKeyVRF v -> Encoding
encodeVerKeyVRF :: forall v. VRFAlgorithm v => VerKeyVRF v -> Encoding
encodeVerKeyVRF = VerKeyVRF v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeVerKeyVRF #-}
{-# DEPRECATED encodeVerKeyVRF "Use encodeFixedSized instead" #-}

decodeVerKeyVRF :: C.VRFAlgorithm v => Decoder s (C.VerKeyVRF v)
decodeVerKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (VerKeyVRF v)
decodeVerKeyVRF = Decoder s (VerKeyVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeVerKeyVRF #-}
{-# DEPRECATED decodeVerKeyVRF "Use decodeFixedSized instead" #-}

encodeSignKeyVRF :: C.VRFAlgorithm v => C.SignKeyVRF v -> Encoding
encodeSignKeyVRF :: forall v. VRFAlgorithm v => SignKeyVRF v -> Encoding
encodeSignKeyVRF = SignKeyVRF v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeSignKeyVRF #-}
{-# DEPRECATED encodeSignKeyVRF "Use encodeFixedSized instead" #-}

decodeSignKeyVRF :: C.VRFAlgorithm v => Decoder s (C.SignKeyVRF v)
decodeSignKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (SignKeyVRF v)
decodeSignKeyVRF = Decoder s (SignKeyVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSignKeyVRF #-}
{-# DEPRECATED decodeSignKeyVRF "Use decodeFixedSized instead" #-}

encodeCertVRF :: C.VRFAlgorithm v => C.CertVRF v -> Encoding
encodeCertVRF :: forall v. VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF = CertVRF v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
{-# INLINE encodeCertVRF #-}
{-# DEPRECATED encodeCertVRF "Use encodeFixedSized instead" #-}

decodeCertVRF :: C.VRFAlgorithm v => Decoder s (C.CertVRF v)
decodeCertVRF :: forall v s. VRFAlgorithm v => Decoder s (CertVRF v)
decodeCertVRF = Decoder s (CertVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeCertVRF #-}
{-# DEPRECATED decodeCertVRF "Use decodeFixedSized instead" #-}