{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

-- | Mock implementation of digital signatures.
module Cardano.Crypto.DSIGN.Mock (
  MockDSIGN,
  SignKeyDSIGN (..),
  VerKeyDSIGN (..),
  SigDSIGN (..),
  mockSign,
)
where

import Cardano.Binary.FixedSizeCodec (
  FixedSizeCodec (..),
  decodeFixedSized,
  encodeFixedSized,
  guardFixedSized,
 )
import Control.DeepSeq (NFData)
import Data.Proxy (Proxy (..))
import Data.Word (Word64)
import GHC.Generics (Generic)
import GHC.Stack
import GHC.TypeLits (type (+))
import NoThunks.Class (NoThunks)

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

import Cardano.Crypto.DSIGN.Class
import Cardano.Crypto.Hash
import Cardano.Crypto.Seed
import Cardano.Crypto.Util
import qualified Data.ByteString as BS

data MockDSIGN

instance DSIGNAlgorithm MockDSIGN where
  type SeedSizeDSIGN MockDSIGN = 8

  --
  -- Key and signature types
  --

  newtype VerKeyDSIGN MockDSIGN = VerKeyMockDSIGN Word64
    deriving stock (Int -> VerKeyDSIGN MockDSIGN -> ShowS
[VerKeyDSIGN MockDSIGN] -> ShowS
VerKeyDSIGN MockDSIGN -> String
(Int -> VerKeyDSIGN MockDSIGN -> ShowS)
-> (VerKeyDSIGN MockDSIGN -> String)
-> ([VerKeyDSIGN MockDSIGN] -> ShowS)
-> Show (VerKeyDSIGN MockDSIGN)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerKeyDSIGN MockDSIGN -> ShowS
showsPrec :: Int -> VerKeyDSIGN MockDSIGN -> ShowS
$cshow :: VerKeyDSIGN MockDSIGN -> String
show :: VerKeyDSIGN MockDSIGN -> String
$cshowList :: [VerKeyDSIGN MockDSIGN] -> ShowS
showList :: [VerKeyDSIGN MockDSIGN] -> ShowS
Show, VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool
(VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool)
-> (VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool)
-> Eq (VerKeyDSIGN MockDSIGN)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool
== :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool
$c/= :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool
/= :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN -> Bool
Eq, (forall x. VerKeyDSIGN MockDSIGN -> Rep (VerKeyDSIGN MockDSIGN) x)
-> (forall x.
    Rep (VerKeyDSIGN MockDSIGN) x -> VerKeyDSIGN MockDSIGN)
-> Generic (VerKeyDSIGN MockDSIGN)
forall x. Rep (VerKeyDSIGN MockDSIGN) x -> VerKeyDSIGN MockDSIGN
forall x. VerKeyDSIGN MockDSIGN -> Rep (VerKeyDSIGN MockDSIGN) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VerKeyDSIGN MockDSIGN -> Rep (VerKeyDSIGN MockDSIGN) x
from :: forall x. VerKeyDSIGN MockDSIGN -> Rep (VerKeyDSIGN MockDSIGN) x
$cto :: forall x. Rep (VerKeyDSIGN MockDSIGN) x -> VerKeyDSIGN MockDSIGN
to :: forall x. Rep (VerKeyDSIGN MockDSIGN) x -> VerKeyDSIGN MockDSIGN
Generic)
    deriving newtype (Integer -> VerKeyDSIGN MockDSIGN
VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
(VerKeyDSIGN MockDSIGN
 -> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (VerKeyDSIGN MockDSIGN
    -> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (VerKeyDSIGN MockDSIGN
    -> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN)
-> (Integer -> VerKeyDSIGN MockDSIGN)
-> Num (VerKeyDSIGN MockDSIGN)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
+ :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$c- :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
- :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$c* :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
* :: VerKeyDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$cnegate :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
negate :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$cabs :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
abs :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$csignum :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
signum :: VerKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
$cfromInteger :: Integer -> VerKeyDSIGN MockDSIGN
fromInteger :: Integer -> VerKeyDSIGN MockDSIGN
Num, Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
Proxy (VerKeyDSIGN MockDSIGN) -> String
(Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Proxy (VerKeyDSIGN MockDSIGN) -> String)
-> NoThunks (VerKeyDSIGN MockDSIGN)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
noThunks :: Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> VerKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (VerKeyDSIGN MockDSIGN) -> String
showTypeOf :: Proxy (VerKeyDSIGN MockDSIGN) -> String
NoThunks, VerKeyDSIGN MockDSIGN -> ()
(VerKeyDSIGN MockDSIGN -> ()) -> NFData (VerKeyDSIGN MockDSIGN)
forall a. (a -> ()) -> NFData a
$crnf :: VerKeyDSIGN MockDSIGN -> ()
rnf :: VerKeyDSIGN MockDSIGN -> ()
NFData)

  newtype SignKeyDSIGN MockDSIGN = SignKeyMockDSIGN Word64
    deriving stock (Int -> SignKeyDSIGN MockDSIGN -> ShowS
[SignKeyDSIGN MockDSIGN] -> ShowS
SignKeyDSIGN MockDSIGN -> String
(Int -> SignKeyDSIGN MockDSIGN -> ShowS)
-> (SignKeyDSIGN MockDSIGN -> String)
-> ([SignKeyDSIGN MockDSIGN] -> ShowS)
-> Show (SignKeyDSIGN MockDSIGN)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SignKeyDSIGN MockDSIGN -> ShowS
showsPrec :: Int -> SignKeyDSIGN MockDSIGN -> ShowS
$cshow :: SignKeyDSIGN MockDSIGN -> String
show :: SignKeyDSIGN MockDSIGN -> String
$cshowList :: [SignKeyDSIGN MockDSIGN] -> ShowS
showList :: [SignKeyDSIGN MockDSIGN] -> ShowS
Show, SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool
(SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool)
-> (SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool)
-> Eq (SignKeyDSIGN MockDSIGN)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool
== :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool
$c/= :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool
/= :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN -> Bool
Eq, (forall x.
 SignKeyDSIGN MockDSIGN -> Rep (SignKeyDSIGN MockDSIGN) x)
-> (forall x.
    Rep (SignKeyDSIGN MockDSIGN) x -> SignKeyDSIGN MockDSIGN)
-> Generic (SignKeyDSIGN MockDSIGN)
forall x. Rep (SignKeyDSIGN MockDSIGN) x -> SignKeyDSIGN MockDSIGN
forall x. SignKeyDSIGN MockDSIGN -> Rep (SignKeyDSIGN MockDSIGN) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SignKeyDSIGN MockDSIGN -> Rep (SignKeyDSIGN MockDSIGN) x
from :: forall x. SignKeyDSIGN MockDSIGN -> Rep (SignKeyDSIGN MockDSIGN) x
$cto :: forall x. Rep (SignKeyDSIGN MockDSIGN) x -> SignKeyDSIGN MockDSIGN
to :: forall x. Rep (SignKeyDSIGN MockDSIGN) x -> SignKeyDSIGN MockDSIGN
Generic)
    deriving newtype (Integer -> SignKeyDSIGN MockDSIGN
SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
(SignKeyDSIGN MockDSIGN
 -> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (SignKeyDSIGN MockDSIGN
    -> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (SignKeyDSIGN MockDSIGN
    -> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN)
-> (Integer -> SignKeyDSIGN MockDSIGN)
-> Num (SignKeyDSIGN MockDSIGN)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
+ :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$c- :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
- :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$c* :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
* :: SignKeyDSIGN MockDSIGN
-> SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$cnegate :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
negate :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$cabs :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
abs :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$csignum :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
signum :: SignKeyDSIGN MockDSIGN -> SignKeyDSIGN MockDSIGN
$cfromInteger :: Integer -> SignKeyDSIGN MockDSIGN
fromInteger :: Integer -> SignKeyDSIGN MockDSIGN
Num, Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
Proxy (SignKeyDSIGN MockDSIGN) -> String
(Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Proxy (SignKeyDSIGN MockDSIGN) -> String)
-> NoThunks (SignKeyDSIGN MockDSIGN)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
noThunks :: Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> SignKeyDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (SignKeyDSIGN MockDSIGN) -> String
showTypeOf :: Proxy (SignKeyDSIGN MockDSIGN) -> String
NoThunks, SignKeyDSIGN MockDSIGN -> ()
(SignKeyDSIGN MockDSIGN -> ()) -> NFData (SignKeyDSIGN MockDSIGN)
forall a. (a -> ()) -> NFData a
$crnf :: SignKeyDSIGN MockDSIGN -> ()
rnf :: SignKeyDSIGN MockDSIGN -> ()
NFData)

  data SigDSIGN MockDSIGN = SigMockDSIGN !(Hash ShortHash ()) !Word64
    deriving stock (Int -> SigDSIGN MockDSIGN -> ShowS
[SigDSIGN MockDSIGN] -> ShowS
SigDSIGN MockDSIGN -> String
(Int -> SigDSIGN MockDSIGN -> ShowS)
-> (SigDSIGN MockDSIGN -> String)
-> ([SigDSIGN MockDSIGN] -> ShowS)
-> Show (SigDSIGN MockDSIGN)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigDSIGN MockDSIGN -> ShowS
showsPrec :: Int -> SigDSIGN MockDSIGN -> ShowS
$cshow :: SigDSIGN MockDSIGN -> String
show :: SigDSIGN MockDSIGN -> String
$cshowList :: [SigDSIGN MockDSIGN] -> ShowS
showList :: [SigDSIGN MockDSIGN] -> ShowS
Show, SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
(SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> Eq (SigDSIGN MockDSIGN)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
== :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
$c/= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
/= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
Eq, Eq (SigDSIGN MockDSIGN)
Eq (SigDSIGN MockDSIGN) =>
(SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Ordering)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN)
-> (SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN)
-> Ord (SigDSIGN MockDSIGN)
SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Ordering
SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN
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 :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Ordering
compare :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Ordering
$c< :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
< :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
$c<= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
<= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
$c> :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
> :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
$c>= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
>= :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
$cmax :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN
max :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN
$cmin :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN
min :: SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN
Ord, (forall x. SigDSIGN MockDSIGN -> Rep (SigDSIGN MockDSIGN) x)
-> (forall x. Rep (SigDSIGN MockDSIGN) x -> SigDSIGN MockDSIGN)
-> Generic (SigDSIGN MockDSIGN)
forall x. Rep (SigDSIGN MockDSIGN) x -> SigDSIGN MockDSIGN
forall x. SigDSIGN MockDSIGN -> Rep (SigDSIGN MockDSIGN) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SigDSIGN MockDSIGN -> Rep (SigDSIGN MockDSIGN) x
from :: forall x. SigDSIGN MockDSIGN -> Rep (SigDSIGN MockDSIGN) x
$cto :: forall x. Rep (SigDSIGN MockDSIGN) x -> SigDSIGN MockDSIGN
to :: forall x. Rep (SigDSIGN MockDSIGN) x -> SigDSIGN MockDSIGN
Generic)
    deriving anyclass (Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
Proxy (SigDSIGN MockDSIGN) -> String
(Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo))
-> (Proxy (SigDSIGN MockDSIGN) -> String)
-> NoThunks (SigDSIGN MockDSIGN)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
noThunks :: Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> SigDSIGN MockDSIGN -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (SigDSIGN MockDSIGN) -> String
showTypeOf :: Proxy (SigDSIGN MockDSIGN) -> String
NoThunks, SigDSIGN MockDSIGN -> ()
(SigDSIGN MockDSIGN -> ()) -> NFData (SigDSIGN MockDSIGN)
forall a. (a -> ()) -> NFData a
$crnf :: SigDSIGN MockDSIGN -> ()
rnf :: SigDSIGN MockDSIGN -> ()
NFData)

  --
  -- Metadata and basic key operations
  --

  algorithmNameDSIGN :: forall (proxy :: * -> *). proxy MockDSIGN -> String
algorithmNameDSIGN proxy MockDSIGN
_ = String
"mock"

  deriveVerKeyDSIGN :: SignKeyDSIGN MockDSIGN -> VerKeyDSIGN MockDSIGN
deriveVerKeyDSIGN (SignKeyMockDSIGN Word64
n) = Word64 -> VerKeyDSIGN MockDSIGN
VerKeyMockDSIGN Word64
n

  --
  -- Core algorithm operations
  --

  type Signable MockDSIGN = SignableRepresentation

  signDSIGN :: forall a.
(Signable MockDSIGN a, HasCallStack) =>
ContextDSIGN MockDSIGN
-> a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
signDSIGN () a
a SignKeyDSIGN MockDSIGN
sk = a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
forall a.
SignableRepresentation a =>
a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
mockSign a
a SignKeyDSIGN MockDSIGN
sk

  verifyDSIGN :: forall a.
(Signable MockDSIGN a, HasCallStack) =>
ContextDSIGN MockDSIGN
-> VerKeyDSIGN MockDSIGN
-> a
-> SigDSIGN MockDSIGN
-> Either String ()
verifyDSIGN () (VerKeyMockDSIGN Word64
n) a
a SigDSIGN MockDSIGN
s =
    if SigDSIGN MockDSIGN
s SigDSIGN MockDSIGN -> SigDSIGN MockDSIGN -> Bool
forall a. Eq a => a -> a -> Bool
== a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
forall a.
SignableRepresentation a =>
a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
mockSign a
a (Word64 -> SignKeyDSIGN MockDSIGN
SignKeyMockDSIGN Word64
n)
      then () -> Either String ()
forall a b. b -> Either a b
Right ()
      else
        String -> Either String ()
forall a b. a -> Either a b
Left (String -> Either String ()) -> String -> Either String ()
forall a b. (a -> b) -> a -> b
$
          VerificationFailure -> String
forall a. Show a => a -> String
show (VerificationFailure -> String) -> VerificationFailure -> String
forall a b. (a -> b) -> a -> b
$
            MockVerificationFailure
              { vErrVerKey :: VerKeyDSIGN MockDSIGN
vErrVerKey = Word64 -> VerKeyDSIGN MockDSIGN
VerKeyMockDSIGN Word64
n
              , vErrSignature :: SigDSIGN MockDSIGN
vErrSignature = SigDSIGN MockDSIGN
s
              , vErrCallStack :: String
vErrCallStack = CallStack -> String
prettyCallStack CallStack
HasCallStack => CallStack
callStack
              }

  --
  -- Key generation
  --

  genKeyDSIGN :: Seed -> SignKeyDSIGN MockDSIGN
genKeyDSIGN Seed
seed =
    Word64 -> SignKeyDSIGN MockDSIGN
SignKeyMockDSIGN (Seed -> (forall (m :: * -> *). MonadRandom m => m Word64) -> Word64
forall a. Seed -> (forall (m :: * -> *). MonadRandom m => m a) -> a
runMonadRandomWithSeed Seed
seed m Word64
forall (m :: * -> *). MonadRandom m => m Word64
getRandomWord64)

instance FixedSizeCodec (VerKeyDSIGN MockDSIGN) where
  type FixedSize (VerKeyDSIGN MockDSIGN) = 8 -- for 64 bit int
  rawEncodeFixedSized :: VerKeyDSIGN MockDSIGN -> ByteString
rawEncodeFixedSized (VerKeyMockDSIGN Word64
k) = Word64 -> ByteString
writeBinaryWord64 Word64
k
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (VerKeyDSIGN MockDSIGN)
rawDecodeFixedSized ByteString
bs = ByteString
-> m (VerKeyDSIGN MockDSIGN) -> m (VerKeyDSIGN MockDSIGN)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m, Typeable a) =>
ByteString -> m a -> m a
guardFixedSized ByteString
bs (m (VerKeyDSIGN MockDSIGN) -> m (VerKeyDSIGN MockDSIGN))
-> m (VerKeyDSIGN MockDSIGN) -> m (VerKeyDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$ VerKeyDSIGN MockDSIGN -> m (VerKeyDSIGN MockDSIGN)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN MockDSIGN -> m (VerKeyDSIGN MockDSIGN))
-> VerKeyDSIGN MockDSIGN -> m (VerKeyDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$! Word64 -> VerKeyDSIGN MockDSIGN
VerKeyMockDSIGN (ByteString -> Word64
readBinaryWord64 ByteString
bs)
  {-# INLINE rawDecodeFixedSized #-}

instance FixedSizeCodec (SignKeyDSIGN MockDSIGN) where
  type FixedSize (SignKeyDSIGN MockDSIGN) = 8
  rawEncodeFixedSized :: SignKeyDSIGN MockDSIGN -> ByteString
rawEncodeFixedSized (SignKeyMockDSIGN Word64
k) = Word64 -> ByteString
writeBinaryWord64 Word64
k
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (SignKeyDSIGN MockDSIGN)
rawDecodeFixedSized ByteString
bs = ByteString
-> m (SignKeyDSIGN MockDSIGN) -> m (SignKeyDSIGN MockDSIGN)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m, Typeable a) =>
ByteString -> m a -> m a
guardFixedSized ByteString
bs (m (SignKeyDSIGN MockDSIGN) -> m (SignKeyDSIGN MockDSIGN))
-> m (SignKeyDSIGN MockDSIGN) -> m (SignKeyDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN MockDSIGN -> m (SignKeyDSIGN MockDSIGN)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SignKeyDSIGN MockDSIGN -> m (SignKeyDSIGN MockDSIGN))
-> SignKeyDSIGN MockDSIGN -> m (SignKeyDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$! Word64 -> SignKeyDSIGN MockDSIGN
SignKeyMockDSIGN (ByteString -> Word64
readBinaryWord64 ByteString
bs)
  {-# INLINE rawDecodeFixedSized #-}

instance FixedSizeCodec (SigDSIGN MockDSIGN) where
  type FixedSize (SigDSIGN MockDSIGN) = HashSize ShortHash + 8
  rawEncodeFixedSized :: SigDSIGN MockDSIGN -> ByteString
rawEncodeFixedSized (SigMockDSIGN Hash ShortHash ()
h Word64
k) = Hash ShortHash () -> ByteString
forall h a. Hash h a -> ByteString
hashToBytes Hash ShortHash ()
h ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Word64 -> ByteString
writeBinaryWord64 Word64
k
  rawDecodeFixedSized :: forall (m :: * -> *).
MonadFail m =>
ByteString -> m (SigDSIGN MockDSIGN)
rawDecodeFixedSized ByteString
bs = ByteString -> m (SigDSIGN MockDSIGN) -> m (SigDSIGN MockDSIGN)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m, Typeable a) =>
ByteString -> m a -> m a
guardFixedSized ByteString
bs (m (SigDSIGN MockDSIGN) -> m (SigDSIGN MockDSIGN))
-> m (SigDSIGN MockDSIGN) -> m (SigDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$ do
    let
      (ByteString
hb, ByteString
kb) = Int -> ByteString -> (ByteString, ByteString)
BS.splitAt (forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Int (Word -> Int) -> Word -> Int
forall a b. (a -> b) -> a -> b
$ Proxy ShortHash -> Word
forall h (proxy :: * -> *). HashAlgorithm h => proxy h -> Word
hashSize (Proxy ShortHash
forall {k} (t :: k). Proxy t
Proxy :: Proxy ShortHash)) ByteString
bs
    Hash ShortHash ()
h <- ByteString -> m (Hash ShortHash ())
forall h a (m :: * -> *).
(HashAlgorithm h, MonadFail m) =>
ByteString -> m (Hash h a)
hashFromByteStringM ByteString
hb
    SigDSIGN MockDSIGN -> m (SigDSIGN MockDSIGN)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SigDSIGN MockDSIGN -> m (SigDSIGN MockDSIGN))
-> SigDSIGN MockDSIGN -> m (SigDSIGN MockDSIGN)
forall a b. (a -> b) -> a -> b
$! Hash ShortHash () -> Word64 -> SigDSIGN MockDSIGN
SigMockDSIGN Hash ShortHash ()
h (ByteString -> Word64
readBinaryWord64 ByteString
kb)
  {-# INLINE rawDecodeFixedSized #-}

instance ToCBOR (VerKeyDSIGN MockDSIGN) where
  toCBOR :: VerKeyDSIGN MockDSIGN -> Encoding
toCBOR = VerKeyDSIGN MockDSIGN -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerKeyDSIGN MockDSIGN) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_ = Proxy (VerKeyDSIGN MockDSIGN) -> Size
forall v. DSIGNAlgorithm v => Proxy (VerKeyDSIGN v) -> Size
encodedVerKeyDSIGNSizeExpr

instance FromCBOR (VerKeyDSIGN MockDSIGN) where
  fromCBOR :: forall s. Decoder s (VerKeyDSIGN MockDSIGN)
fromCBOR = Decoder s (VerKeyDSIGN MockDSIGN)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized

instance ToCBOR (SignKeyDSIGN MockDSIGN) where
  toCBOR :: SignKeyDSIGN MockDSIGN -> Encoding
toCBOR = SignKeyDSIGN MockDSIGN -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SignKeyDSIGN MockDSIGN) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_ = Proxy (SignKeyDSIGN MockDSIGN) -> Size
forall v. DSIGNAlgorithm v => Proxy (SignKeyDSIGN v) -> Size
encodedSignKeyDSIGNSizeExpr

instance FromCBOR (SignKeyDSIGN MockDSIGN) where
  fromCBOR :: forall s. Decoder s (SignKeyDSIGN MockDSIGN)
fromCBOR = Decoder s (SignKeyDSIGN MockDSIGN)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized

instance ToCBOR (SigDSIGN MockDSIGN) where
  toCBOR :: SigDSIGN MockDSIGN -> Encoding
toCBOR = SigDSIGN MockDSIGN -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized
  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigDSIGN MockDSIGN) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_ = Proxy (SigDSIGN MockDSIGN) -> Size
forall v. DSIGNAlgorithm v => Proxy (SigDSIGN v) -> Size
encodedSigDSIGNSizeExpr

instance FromCBOR (SigDSIGN MockDSIGN) where
  fromCBOR :: forall s. Decoder s (SigDSIGN MockDSIGN)
fromCBOR = Decoder s (SigDSIGN MockDSIGN)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized

-- | Debugging: provide information about the verification failure
--
-- We don't include the actual value here as that would require propagating a
-- 'Show' constraint.
data VerificationFailure = MockVerificationFailure
  { VerificationFailure -> VerKeyDSIGN MockDSIGN
vErrVerKey :: VerKeyDSIGN MockDSIGN
  , VerificationFailure -> SigDSIGN MockDSIGN
vErrSignature :: SigDSIGN MockDSIGN
  , VerificationFailure -> String
vErrCallStack :: String
  }
  deriving (Int -> VerificationFailure -> ShowS
[VerificationFailure] -> ShowS
VerificationFailure -> String
(Int -> VerificationFailure -> ShowS)
-> (VerificationFailure -> String)
-> ([VerificationFailure] -> ShowS)
-> Show VerificationFailure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerificationFailure -> ShowS
showsPrec :: Int -> VerificationFailure -> ShowS
$cshow :: VerificationFailure -> String
show :: VerificationFailure -> String
$cshowList :: [VerificationFailure] -> ShowS
showList :: [VerificationFailure] -> ShowS
Show)

mockSign ::
  SignableRepresentation a =>
  a ->
  SignKeyDSIGN MockDSIGN ->
  SigDSIGN MockDSIGN
mockSign :: forall a.
SignableRepresentation a =>
a -> SignKeyDSIGN MockDSIGN -> SigDSIGN MockDSIGN
mockSign a
a (SignKeyMockDSIGN Word64
n) =
  Hash ShortHash () -> Word64 -> SigDSIGN MockDSIGN
SigMockDSIGN (Hash ShortHash a -> Hash ShortHash ()
forall h a b. Hash h a -> Hash h b
castHash ((a -> ByteString) -> a -> Hash ShortHash a
forall h a. HashAlgorithm h => (a -> ByteString) -> a -> Hash h a
hashWith a -> ByteString
forall a. SignableRepresentation a => a -> ByteString
getSignableRepresentation a
a)) Word64
n