{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

-- | A standard signature scheme is a forward-secure signature scheme with a
-- single time period.
--
-- This is the base case in the naive recursive implementation of the sum
-- composition from section 3 of the \"MMM\" paper:
--
-- /Composition and Efficiency Tradeoffs for Forward-Secure Digital Signatures/
-- By Tal Malkin, Daniele Micciancio and Sara Miner
-- <https://eprint.iacr.org/2001/034>
--
-- Specfically it states:
--
-- > In order to unify the presentation, we regard standard signature schemes
-- > as forward-seure signature schemes with one time period, namely T = 1.
--
-- So this module simply provides a wrapper 'SingleKES' that turns any
-- 'DSIGNMAlgorithm' into an instance of 'KESAlgorithm' with a single period.
--
-- See "Cardano.Crypto.KES.Sum" for the composition case.
module Cardano.Crypto.KES.Single (
  SingleKES,
  VerKeyKES (..),
  SignKeyKES (..),
  SigKES (..),
) where

import Cardano.Binary.FixedSizeCodec (
  FixedSizeCodec (..),
  decodeFixedSized,
  encodeFixedSized,
 )
import Data.Proxy (Proxy (..))
import GHC.Generics (Generic)
import GHC.TypeLits (KnownNat)
import NoThunks.Class (NoThunks)

import Control.DeepSeq (NFData)
import Control.Exception (assert)
import Control.Monad ((<$!>))

import Cardano.Binary (FromCBOR (..), ToCBOR (..))

import Cardano.Crypto.DSIGN.Class as DSIGN
import Cardano.Crypto.DirectSerialise
import Cardano.Crypto.Hash.Class
import Cardano.Crypto.KES.Class

-- | A standard signature scheme is a forward-secure signature scheme with a
-- single time period.
data SingleKES d

deriving instance NFData (VerKeyDSIGN d) => NFData (VerKeyKES (SingleKES d))
deriving instance NFData (SigDSIGN d) => NFData (SigKES (SingleKES d))

deriving via
  (SignKeyDSIGNM d)
  instance
    NFData (SignKeyDSIGNM d) => NFData (SignKeyKES (SingleKES d))

instance
  ( DSIGNMAlgorithm d
  , KnownNat (FixedSize (VerKeyDSIGN d))
  , KnownNat (FixedSize (SigDSIGN d))
  ) =>
  KESAlgorithm (SingleKES d)
  where
  type SeedSizeKES (SingleKES d) = SeedSizeDSIGN d

  --
  -- Key and signature types
  --

  newtype VerKeyKES (SingleKES d) = VerKeySingleKES (VerKeyDSIGN d)
    deriving ((forall x.
 VerKeyKES (SingleKES d) -> Rep (VerKeyKES (SingleKES d)) x)
-> (forall x.
    Rep (VerKeyKES (SingleKES d)) x -> VerKeyKES (SingleKES d))
-> Generic (VerKeyKES (SingleKES d))
forall x.
Rep (VerKeyKES (SingleKES d)) x -> VerKeyKES (SingleKES d)
forall x.
VerKeyKES (SingleKES d) -> Rep (VerKeyKES (SingleKES d)) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall d x.
Rep (VerKeyKES (SingleKES d)) x -> VerKeyKES (SingleKES d)
forall d x.
VerKeyKES (SingleKES d) -> Rep (VerKeyKES (SingleKES d)) x
$cfrom :: forall d x.
VerKeyKES (SingleKES d) -> Rep (VerKeyKES (SingleKES d)) x
from :: forall x.
VerKeyKES (SingleKES d) -> Rep (VerKeyKES (SingleKES d)) x
$cto :: forall d x.
Rep (VerKeyKES (SingleKES d)) x -> VerKeyKES (SingleKES d)
to :: forall x.
Rep (VerKeyKES (SingleKES d)) x -> VerKeyKES (SingleKES d)
Generic)

  newtype SigKES (SingleKES d) = SigSingleKES (SigDSIGN d)
    deriving ((forall x. SigKES (SingleKES d) -> Rep (SigKES (SingleKES d)) x)
-> (forall x. Rep (SigKES (SingleKES d)) x -> SigKES (SingleKES d))
-> Generic (SigKES (SingleKES d))
forall x. Rep (SigKES (SingleKES d)) x -> SigKES (SingleKES d)
forall x. SigKES (SingleKES d) -> Rep (SigKES (SingleKES d)) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall d x. Rep (SigKES (SingleKES d)) x -> SigKES (SingleKES d)
forall d x. SigKES (SingleKES d) -> Rep (SigKES (SingleKES d)) x
$cfrom :: forall d x. SigKES (SingleKES d) -> Rep (SigKES (SingleKES d)) x
from :: forall x. SigKES (SingleKES d) -> Rep (SigKES (SingleKES d)) x
$cto :: forall d x. Rep (SigKES (SingleKES d)) x -> SigKES (SingleKES d)
to :: forall x. Rep (SigKES (SingleKES d)) x -> SigKES (SingleKES d)
Generic)

  newtype SignKeyKES (SingleKES d) = SignKeySingleKES (SignKeyDSIGNM d)

  type ContextKES (SingleKES d) = ContextDSIGN d
  type Signable (SingleKES d) = DSIGN.Signable d

  --
  -- Metadata and basic key operations
  --

  algorithmNameKES :: forall (proxy :: * -> *). proxy (SingleKES d) -> String
algorithmNameKES proxy (SingleKES d)
_ = Proxy d -> String
forall v (proxy :: * -> *). DSIGNAlgorithm v => proxy v -> String
forall (proxy :: * -> *). proxy d -> String
algorithmNameDSIGN (Proxy d
forall {k} (t :: k). Proxy t
Proxy :: Proxy d) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"_kes_2^0"

  type TotalPeriodsKES (SingleKES d) = 1

  verifyKES :: forall a.
(Signable (SingleKES d) a, HasCallStack) =>
ContextKES (SingleKES d)
-> VerKeyKES (SingleKES d)
-> Period
-> a
-> SigKES (SingleKES d)
-> Either String ()
verifyKES ContextKES (SingleKES d)
ctxt (VerKeySingleKES VerKeyDSIGN d
vk) Period
t a
a (SigSingleKES SigDSIGN d
sig) =
    Bool -> Either String () -> Either String ()
forall a. HasCallStack => Bool -> a -> a
assert (Period
t Period -> Period -> Bool
forall a. Eq a => a -> a -> Bool
== Period
0) (Either String () -> Either String ())
-> Either String () -> Either String ()
forall a b. (a -> b) -> a -> b
$
      ContextDSIGN d
-> VerKeyDSIGN d -> a -> SigDSIGN d -> Either String ()
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v
-> VerKeyDSIGN v -> a -> SigDSIGN v -> Either String ()
forall a.
(Signable d a, HasCallStack) =>
ContextDSIGN d
-> VerKeyDSIGN d -> a -> SigDSIGN d -> Either String ()
verifyDSIGN ContextKES (SingleKES d)
ContextDSIGN d
ctxt VerKeyDSIGN d
vk a
a SigDSIGN d
sig

  --
  -- raw serialise/deserialise
  --

  type SignKeySizeKES (SingleKES d) = SignKeySizeDSIGN d

  hashVerKeyKES :: forall h.
HashAlgorithm h =>
VerKeyKES (SingleKES d) -> Hash h (VerKeyKES (SingleKES d))
hashVerKeyKES (VerKeySingleKES VerKeyDSIGN d
vk) =
    Hash h (VerKeyDSIGN d) -> Hash h (VerKeyKES (SingleKES d))
forall h a b. Hash h a -> Hash h b
castHash (VerKeyDSIGN d -> Hash h (VerKeyDSIGN d)
forall h.
HashAlgorithm h =>
VerKeyDSIGN d -> Hash h (VerKeyDSIGN d)
forall v h.
(DSIGNAlgorithm v, HashAlgorithm h) =>
VerKeyDSIGN v -> Hash h (VerKeyDSIGN v)
hashVerKeyDSIGN VerKeyDSIGN d
vk)

  deriveVerKeyKES :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
SignKeyKES (SingleKES d) -> m (VerKeyKES (SingleKES d))
deriveVerKeyKES (SignKeySingleKES SignKeyDSIGNM d
v) =
    VerKeyDSIGN d -> VerKeyKES (SingleKES d)
forall d. VerKeyDSIGN d -> VerKeyKES (SingleKES d)
VerKeySingleKES (VerKeyDSIGN d -> VerKeyKES (SingleKES d))
-> m (VerKeyDSIGN d) -> m (VerKeyKES (SingleKES d))
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> SignKeyDSIGNM d -> m (VerKeyDSIGN d)
forall v (m :: * -> *).
(DSIGNMAlgorithm v, MonadThrow m, MonadST m) =>
SignKeyDSIGNM v -> m (VerKeyDSIGN v)
forall (m :: * -> *).
(MonadThrow m, MonadST m) =>
SignKeyDSIGNM d -> m (VerKeyDSIGN d)
deriveVerKeyDSIGNM SignKeyDSIGNM d
v

  --
  -- Core algorithm operations
  --

  signKES :: forall a (m :: * -> *).
(Signable (SingleKES d) a, MonadST m, MonadThrow m) =>
ContextKES (SingleKES d)
-> Period
-> a
-> SignKeyKES (SingleKES d)
-> m (SigKES (SingleKES d))
signKES ContextKES (SingleKES d)
ctxt Period
t a
a (SignKeySingleKES SignKeyDSIGNM d
sk) =
    Bool -> m (SigKES (SingleKES d)) -> m (SigKES (SingleKES d))
forall a. HasCallStack => Bool -> a -> a
assert (Period
t Period -> Period -> Bool
forall a. Eq a => a -> a -> Bool
== Period
0) (m (SigKES (SingleKES d)) -> m (SigKES (SingleKES d)))
-> m (SigKES (SingleKES d)) -> m (SigKES (SingleKES d))
forall a b. (a -> b) -> a -> b
$!
      SigDSIGN d -> SigKES (SingleKES d)
forall d. SigDSIGN d -> SigKES (SingleKES d)
SigSingleKES (SigDSIGN d -> SigKES (SingleKES d))
-> m (SigDSIGN d) -> m (SigKES (SingleKES d))
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> ContextDSIGN d -> a -> SignKeyDSIGNM d -> m (SigDSIGN d)
forall v a (m :: * -> *).
(DSIGNMAlgorithm v, Signable v a, MonadST m, MonadThrow m) =>
ContextDSIGN v -> a -> SignKeyDSIGNM v -> m (SigDSIGN v)
forall a (m :: * -> *).
(Signable d a, MonadST m, MonadThrow m) =>
ContextDSIGN d -> a -> SignKeyDSIGNM d -> m (SigDSIGN d)
signDSIGNM ContextKES (SingleKES d)
ContextDSIGN d
ctxt a
a SignKeyDSIGNM d
sk

  updateKESWith :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m
-> ContextKES (SingleKES d)
-> SignKeyKES (SingleKES d)
-> Period
-> m (Maybe (SignKeyKES (SingleKES d)))
updateKESWith MLockedAllocator m
_allocator ContextKES (SingleKES d)
_ctx (SignKeySingleKES SignKeyDSIGNM d
_sk) Period
_to = Maybe (SignKeyKES (SingleKES d))
-> m (Maybe (SignKeyKES (SingleKES d)))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (SignKeyKES (SingleKES d))
forall a. Maybe a
Nothing

  --
  -- Key generation
  --

  genKeyKESWith :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m
-> MLockedSeed (SeedSizeKES (SingleKES d))
-> m (SignKeyKES (SingleKES d))
genKeyKESWith MLockedAllocator m
allocator MLockedSeed (SeedSizeKES (SingleKES d))
seed =
    SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
forall d. SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
SignKeySingleKES (SignKeyDSIGNM d -> SignKeyKES (SingleKES d))
-> m (SignKeyDSIGNM d) -> m (SignKeyKES (SingleKES d))
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> MLockedAllocator m
-> MLockedSeed (SeedSizeDSIGN d) -> m (SignKeyDSIGNM d)
forall v (m :: * -> *).
(DSIGNMAlgorithm v, MonadST m, MonadThrow m) =>
MLockedAllocator m
-> MLockedSeed (SeedSizeDSIGN v) -> m (SignKeyDSIGNM v)
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m
-> MLockedSeed (SeedSizeDSIGN d) -> m (SignKeyDSIGNM d)
genKeyDSIGNMWith MLockedAllocator m
allocator MLockedSeed (SeedSizeKES (SingleKES d))
MLockedSeed (SeedSizeDSIGN d)
seed

  --
  -- forgetting
  --
  forgetSignKeyKESWith :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m -> SignKeyKES (SingleKES d) -> m ()
forgetSignKeyKESWith MLockedAllocator m
allocator (SignKeySingleKES SignKeyDSIGNM d
v) =
    MLockedAllocator m -> SignKeyDSIGNM d -> m ()
forall v (m :: * -> *).
(DSIGNMAlgorithm v, MonadST m, MonadThrow m) =>
MLockedAllocator m -> SignKeyDSIGNM v -> m ()
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m -> SignKeyDSIGNM d -> m ()
forgetSignKeyDSIGNMWith MLockedAllocator m
allocator SignKeyDSIGNM d
v

instance
  ( KESAlgorithm (SingleKES d)
  , UnsoundDSIGNMAlgorithm d
  ) =>
  UnsoundPureKESAlgorithm (SingleKES d)
  where
  newtype UnsoundPureSignKeyKES (SingleKES d) = UnsoundPureSignKeySingleKES (SignKeyDSIGN d)
    deriving ((forall x.
 UnsoundPureSignKeyKES (SingleKES d)
 -> Rep (UnsoundPureSignKeyKES (SingleKES d)) x)
-> (forall x.
    Rep (UnsoundPureSignKeyKES (SingleKES d)) x
    -> UnsoundPureSignKeyKES (SingleKES d))
-> Generic (UnsoundPureSignKeyKES (SingleKES d))
forall x.
Rep (UnsoundPureSignKeyKES (SingleKES d)) x
-> UnsoundPureSignKeyKES (SingleKES d)
forall x.
UnsoundPureSignKeyKES (SingleKES d)
-> Rep (UnsoundPureSignKeyKES (SingleKES d)) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall d x.
Rep (UnsoundPureSignKeyKES (SingleKES d)) x
-> UnsoundPureSignKeyKES (SingleKES d)
forall d x.
UnsoundPureSignKeyKES (SingleKES d)
-> Rep (UnsoundPureSignKeyKES (SingleKES d)) x
$cfrom :: forall d x.
UnsoundPureSignKeyKES (SingleKES d)
-> Rep (UnsoundPureSignKeyKES (SingleKES d)) x
from :: forall x.
UnsoundPureSignKeyKES (SingleKES d)
-> Rep (UnsoundPureSignKeyKES (SingleKES d)) x
$cto :: forall d x.
Rep (UnsoundPureSignKeyKES (SingleKES d)) x
-> UnsoundPureSignKeyKES (SingleKES d)
to :: forall x.
Rep (UnsoundPureSignKeyKES (SingleKES d)) x
-> UnsoundPureSignKeyKES (SingleKES d)
Generic)

  unsoundPureSignKES :: forall a.
Signable (SingleKES d) a =>
ContextKES (SingleKES d)
-> Period
-> a
-> UnsoundPureSignKeyKES (SingleKES d)
-> SigKES (SingleKES d)
unsoundPureSignKES ContextKES (SingleKES d)
ctxt Period
t a
a (UnsoundPureSignKeySingleKES SignKeyDSIGN d
sk) =
    Bool -> SigKES (SingleKES d) -> SigKES (SingleKES d)
forall a. HasCallStack => Bool -> a -> a
assert (Period
t Period -> Period -> Bool
forall a. Eq a => a -> a -> Bool
== Period
0) (SigKES (SingleKES d) -> SigKES (SingleKES d))
-> SigKES (SingleKES d) -> SigKES (SingleKES d)
forall a b. (a -> b) -> a -> b
$!
      SigDSIGN d -> SigKES (SingleKES d)
forall d. SigDSIGN d -> SigKES (SingleKES d)
SigSingleKES (SigDSIGN d -> SigKES (SingleKES d))
-> SigDSIGN d -> SigKES (SingleKES d)
forall a b. (a -> b) -> a -> b
$!
        ContextDSIGN d -> a -> SignKeyDSIGN d -> SigDSIGN d
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable d a, HasCallStack) =>
ContextDSIGN d -> a -> SignKeyDSIGN d -> SigDSIGN d
signDSIGN ContextKES (SingleKES d)
ContextDSIGN d
ctxt a
a SignKeyDSIGN d
sk

  unsoundPureUpdateKES :: ContextKES (SingleKES d)
-> UnsoundPureSignKeyKES (SingleKES d)
-> Period
-> Maybe (UnsoundPureSignKeyKES (SingleKES d))
unsoundPureUpdateKES ContextKES (SingleKES d)
_ctx UnsoundPureSignKeyKES (SingleKES d)
_sk Period
_to = Maybe (UnsoundPureSignKeyKES (SingleKES d))
forall a. Maybe a
Nothing

  --
  -- Key generation
  --

  unsoundPureGenKeyKES :: Seed -> UnsoundPureSignKeyKES (SingleKES d)
unsoundPureGenKeyKES Seed
seed =
    SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d)
forall d. SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d)
UnsoundPureSignKeySingleKES (SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d))
-> SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d)
forall a b. (a -> b) -> a -> b
$! Seed -> SignKeyDSIGN d
forall v. DSIGNAlgorithm v => Seed -> SignKeyDSIGN v
genKeyDSIGN Seed
seed

  unsoundPureDeriveVerKeyKES :: UnsoundPureSignKeyKES (SingleKES d) -> VerKeyKES (SingleKES d)
unsoundPureDeriveVerKeyKES (UnsoundPureSignKeySingleKES SignKeyDSIGN d
v) =
    VerKeyDSIGN d -> VerKeyKES (SingleKES d)
forall d. VerKeyDSIGN d -> VerKeyKES (SingleKES d)
VerKeySingleKES (VerKeyDSIGN d -> VerKeyKES (SingleKES d))
-> VerKeyDSIGN d -> VerKeyKES (SingleKES d)
forall a b. (a -> b) -> a -> b
$! SignKeyDSIGN d -> VerKeyDSIGN d
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> VerKeyDSIGN v
deriveVerKeyDSIGN SignKeyDSIGN d
v

  unsoundPureSignKeyKESToSoundSignKeyKES :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
UnsoundPureSignKeyKES (SingleKES d) -> m (SignKeyKES (SingleKES d))
unsoundPureSignKeyKESToSoundSignKeyKES =
    UnsoundPureSignKeyKES (SingleKES d) -> m (SignKeyKES (SingleKES d))
forall (m :: * -> *) k.
(MonadST m, MonadThrow m, UnsoundKESAlgorithm k,
 UnsoundPureKESAlgorithm k) =>
UnsoundPureSignKeyKES k -> m (SignKeyKES k)
unsoundPureSignKeyKESToSoundSignKeyKESViaSer

instance
  (KESAlgorithm (SingleKES d), UnsoundDSIGNMAlgorithm d) =>
  UnsoundKESAlgorithm (SingleKES d)
  where
  rawSerialiseSignKeyKES :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
SignKeyKES (SingleKES d) -> m ByteString
rawSerialiseSignKeyKES (SignKeySingleKES SignKeyDSIGNM d
sk) =
    SignKeyDSIGNM d -> m ByteString
forall v (m :: * -> *).
(UnsoundDSIGNMAlgorithm v, MonadST m, MonadThrow m) =>
SignKeyDSIGNM v -> m ByteString
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
SignKeyDSIGNM d -> m ByteString
rawSerialiseSignKeyDSIGNM SignKeyDSIGNM d
sk

  rawDeserialiseSignKeyKESWith :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m
-> ByteString -> m (Maybe (SignKeyKES (SingleKES d)))
rawDeserialiseSignKeyKESWith MLockedAllocator m
allocator ByteString
bs =
    (SignKeyDSIGNM d -> SignKeyKES (SingleKES d))
-> Maybe (SignKeyDSIGNM d) -> Maybe (SignKeyKES (SingleKES d))
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
forall d. SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
SignKeySingleKES (Maybe (SignKeyDSIGNM d) -> Maybe (SignKeyKES (SingleKES d)))
-> m (Maybe (SignKeyDSIGNM d))
-> m (Maybe (SignKeyKES (SingleKES d)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MLockedAllocator m -> ByteString -> m (Maybe (SignKeyDSIGNM d))
forall v (m :: * -> *).
(UnsoundDSIGNMAlgorithm v, MonadST m, MonadThrow m) =>
MLockedAllocator m -> ByteString -> m (Maybe (SignKeyDSIGNM v))
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
MLockedAllocator m -> ByteString -> m (Maybe (SignKeyDSIGNM d))
rawDeserialiseSignKeyDSIGNMWith MLockedAllocator m
allocator ByteString
bs

--
-- FixedSizeCodec instances
--

instance DSIGNAlgorithm d => FixedSizeCodec (VerKeyKES (SingleKES d)) where
  type FixedSize (VerKeyKES (SingleKES d)) = FixedSize (VerKeyDSIGN d)
  rawEncodeFixedSized :: VerKeyKES (SingleKES d) -> ByteString
rawEncodeFixedSized (VerKeySingleKES VerKeyDSIGN d
vk) = VerKeyDSIGN d -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized VerKeyDSIGN d
vk
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (VerKeyKES (SingleKES d))
rawDecodeFixedSized ByteString
bs = VerKeyDSIGN d -> VerKeyKES (SingleKES d)
forall d. VerKeyDSIGN d -> VerKeyKES (SingleKES d)
VerKeySingleKES (VerKeyDSIGN d -> VerKeyKES (SingleKES d))
-> m (VerKeyDSIGN d) -> m (VerKeyKES (SingleKES d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> m (VerKeyDSIGN d)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *).
MonadFail m =>
ByteString -> m (VerKeyDSIGN d)
rawDecodeFixedSized ByteString
bs
  {-# INLINE rawDecodeFixedSized #-}

instance DSIGNAlgorithm d => FixedSizeCodec (SigKES (SingleKES d)) where
  type FixedSize (SigKES (SingleKES d)) = FixedSize (SigDSIGN d)
  rawEncodeFixedSized :: SigKES (SingleKES d) -> ByteString
rawEncodeFixedSized (SigSingleKES SigDSIGN d
sig) = SigDSIGN d -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized SigDSIGN d
sig
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (SigKES (SingleKES d))
rawDecodeFixedSized ByteString
bs = SigDSIGN d -> SigKES (SingleKES d)
forall d. SigDSIGN d -> SigKES (SingleKES d)
SigSingleKES (SigDSIGN d -> SigKES (SingleKES d))
-> m (SigDSIGN d) -> m (SigKES (SingleKES d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> m (SigDSIGN d)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *). MonadFail m => ByteString -> m (SigDSIGN d)
rawDecodeFixedSized ByteString
bs
  {-# INLINE rawDecodeFixedSized #-}

instance DSIGNAlgorithm d => FixedSizeCodec (UnsoundPureSignKeyKES (SingleKES d)) where
  type FixedSize (UnsoundPureSignKeyKES (SingleKES d)) = SignKeySizeKES (SingleKES d)
  rawEncodeFixedSized :: UnsoundPureSignKeyKES (SingleKES d) -> ByteString
rawEncodeFixedSized (UnsoundPureSignKeySingleKES SignKeyDSIGN d
sk) = SignKeyDSIGN d -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized SignKeyDSIGN d
sk
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (UnsoundPureSignKeyKES (SingleKES d))
rawDecodeFixedSized ByteString
bs = SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d)
forall d. SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d)
UnsoundPureSignKeySingleKES (SignKeyDSIGN d -> UnsoundPureSignKeyKES (SingleKES d))
-> m (SignKeyDSIGN d) -> m (UnsoundPureSignKeyKES (SingleKES d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> m (SignKeyDSIGN d)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *).
MonadFail m =>
ByteString -> m (SignKeyDSIGN d)
rawDecodeFixedSized ByteString
bs
  {-# INLINE rawDecodeFixedSized #-}

--
-- VerKey instances
--

deriving instance DSIGNAlgorithm d => Show (VerKeyKES (SingleKES d))
deriving instance DSIGNAlgorithm d => Eq (VerKeyKES (SingleKES d))

instance DSIGNMAlgorithm d => ToCBOR (VerKeyKES (SingleKES d)) where
  toCBOR :: VerKeyKES (SingleKES d) -> Encoding
toCBOR = VerKeyKES (SingleKES d) -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerKeyKES (SingleKES d)) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_size = Proxy (VerKeyKES (SingleKES d)) -> Size
forall v. KESAlgorithm v => Proxy (VerKeyKES v) -> Size
encodedVerKeyKESSizeExpr

instance DSIGNMAlgorithm d => FromCBOR (VerKeyKES (SingleKES d)) where
  fromCBOR :: forall s. Decoder s (VerKeyKES (SingleKES d))
fromCBOR = Decoder s (VerKeyKES (SingleKES d))
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
  {-# INLINE fromCBOR #-}

instance DSIGNMAlgorithm d => NoThunks (VerKeyKES (SingleKES d))

--
-- SignKey instances
--

deriving via (SignKeyDSIGNM d) instance DSIGNMAlgorithm d => NoThunks (SignKeyKES (SingleKES d))

--
-- Sig instances
--

deriving instance DSIGNAlgorithm d => Show (SigKES (SingleKES d))
deriving instance DSIGNAlgorithm d => Eq (SigKES (SingleKES d))

instance DSIGNAlgorithm d => NoThunks (SigKES (SingleKES d))

instance DSIGNMAlgorithm d => ToCBOR (SigKES (SingleKES d)) where
  toCBOR :: SigKES (SingleKES d) -> Encoding
toCBOR = SigKES (SingleKES d) -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigKES (SingleKES d)) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_size = Proxy (SigKES (SingleKES d)) -> Size
forall v. KESAlgorithm v => Proxy (SigKES v) -> Size
encodedSigKESSizeExpr

instance DSIGNMAlgorithm d => FromCBOR (SigKES (SingleKES d)) where
  fromCBOR :: forall s. Decoder s (SigKES (SingleKES d))
fromCBOR = Decoder s (SigKES (SingleKES d))
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized

--
-- UnsoundPureSignKey instances
--

deriving instance DSIGNAlgorithm d => Show (UnsoundPureSignKeyKES (SingleKES d))
deriving instance Eq (SignKeyDSIGN d) => Eq (UnsoundPureSignKeyKES (SingleKES d))

instance UnsoundDSIGNMAlgorithm d => ToCBOR (UnsoundPureSignKeyKES (SingleKES d)) where
  toCBOR :: UnsoundPureSignKeyKES (SingleKES d) -> Encoding
toCBOR = UnsoundPureSignKeyKES (SingleKES d) -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (UnsoundPureSignKeyKES (SingleKES d)) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_size Proxy (UnsoundPureSignKeyKES (SingleKES d))
_skProxy = Proxy (SignKeyKES (SingleKES d)) -> Size
forall v. KESAlgorithm v => Proxy (SignKeyKES v) -> Size
encodedSignKeyKESSizeExpr (Proxy (SignKeyKES (SingleKES d))
forall {k} (t :: k). Proxy t
Proxy :: Proxy (SignKeyKES (SingleKES d)))

instance UnsoundDSIGNMAlgorithm d => FromCBOR (UnsoundPureSignKeyKES (SingleKES d)) where
  fromCBOR :: forall s. Decoder s (UnsoundPureSignKeyKES (SingleKES d))
fromCBOR = Decoder s (UnsoundPureSignKeyKES (SingleKES d))
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized

instance DSIGNAlgorithm d => NoThunks (UnsoundPureSignKeyKES (SingleKES d))

--
-- Direct ser/deser
--

instance DirectSerialise (SignKeyDSIGNM d) => DirectSerialise (SignKeyKES (SingleKES d)) where
  directSerialise :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> SignKeyKES (SingleKES d) -> m ()
directSerialise Ptr CChar -> CSize -> m ()
push (SignKeySingleKES SignKeyDSIGNM d
sk) = (Ptr CChar -> CSize -> m ()) -> SignKeyDSIGNM d -> m ()
forall a (m :: * -> *).
(DirectSerialise a, MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> a -> m ()
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> SignKeyDSIGNM d -> m ()
directSerialise Ptr CChar -> CSize -> m ()
push SignKeyDSIGNM d
sk

instance DirectDeserialise (SignKeyDSIGNM d) => DirectDeserialise (SignKeyKES (SingleKES d)) where
  directDeserialise :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m (SignKeyKES (SingleKES d))
directDeserialise Ptr CChar -> CSize -> m ()
pull = SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
forall d. SignKeyDSIGNM d -> SignKeyKES (SingleKES d)
SignKeySingleKES (SignKeyDSIGNM d -> SignKeyKES (SingleKES d))
-> m (SignKeyDSIGNM d) -> m (SignKeyKES (SingleKES d))
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (Ptr CChar -> CSize -> m ()) -> m (SignKeyDSIGNM d)
forall a (m :: * -> *).
(DirectDeserialise a, MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m a
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m (SignKeyDSIGNM d)
directDeserialise Ptr CChar -> CSize -> m ()
pull

instance DirectSerialise (VerKeyDSIGN d) => DirectSerialise (VerKeyKES (SingleKES d)) where
  directSerialise :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> VerKeyKES (SingleKES d) -> m ()
directSerialise Ptr CChar -> CSize -> m ()
push (VerKeySingleKES VerKeyDSIGN d
sk) = (Ptr CChar -> CSize -> m ()) -> VerKeyDSIGN d -> m ()
forall a (m :: * -> *).
(DirectSerialise a, MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> a -> m ()
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> VerKeyDSIGN d -> m ()
directSerialise Ptr CChar -> CSize -> m ()
push VerKeyDSIGN d
sk

instance DirectDeserialise (VerKeyDSIGN d) => DirectDeserialise (VerKeyKES (SingleKES d)) where
  directDeserialise :: forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m (VerKeyKES (SingleKES d))
directDeserialise Ptr CChar -> CSize -> m ()
pull = VerKeyDSIGN d -> VerKeyKES (SingleKES d)
forall d. VerKeyDSIGN d -> VerKeyKES (SingleKES d)
VerKeySingleKES (VerKeyDSIGN d -> VerKeyKES (SingleKES d))
-> m (VerKeyDSIGN d) -> m (VerKeyKES (SingleKES d))
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (Ptr CChar -> CSize -> m ()) -> m (VerKeyDSIGN d)
forall a (m :: * -> *).
(DirectDeserialise a, MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m a
forall (m :: * -> *).
(MonadST m, MonadThrow m) =>
(Ptr CChar -> CSize -> m ()) -> m (VerKeyDSIGN d)
directDeserialise Ptr CChar -> CSize -> m ()
pull