-- editorconfig-checker-disable-file
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ConstraintKinds     #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE KindSignatures      #-}
{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE TypeOperators       #-}

module Evaluation.Builtins.SignatureVerification (
  ecdsaSecp256k1Prop,
  ed25519_VariantAProp,
  ed25519_VariantBProp,
  ed25519_VariantCProp,
  schnorrSecp256k1Prop,
  ) where


import Cardano.Crypto.DSIGN.Class (ContextDSIGN, DSIGNAlgorithm, SignKeyDSIGN, Signable,
                                   deriveVerKeyDSIGN, genKeyDSIGN, rawDeserialiseSigDSIGN,
                                   rawDeserialiseVerKeyDSIGN, rawSerialiseSigDSIGN,
                                   rawSerialiseVerKeyDSIGN, signDSIGN)
import Cardano.Crypto.DSIGN.EcdsaSecp256k1 (EcdsaSecp256k1DSIGN, MessageHash, SigDSIGN, VerKeyDSIGN,
                                            fromMessageHash, toMessageHash)
import Cardano.Crypto.DSIGN.Ed25519 (Ed25519DSIGN)
import Cardano.Crypto.DSIGN.SchnorrSecp256k1 (SchnorrSecp256k1DSIGN)
import Cardano.Crypto.Seed (mkSeedFromBytes)
import Control.Lens.Extras (is)
import Control.Lens.Fold (preview)
import Control.Lens.Prism (Prism', prism')
import Control.Lens.Review (review)
import Data.ByteString (ByteString)
import Data.Kind (Type)
import Evaluation.Builtins.Common (typecheckEvaluateCek)
import Hedgehog (Gen, PropertyT, annotateShow, cover, failure, forAllWith, (===))
import Hedgehog.Gen qualified as Gen
import Hedgehog.Range qualified as Range
import PlutusCore (DefaultFun (VerifyEcdsaSecp256k1Signature, VerifyEd25519Signature, VerifySchnorrSecp256k1Signature),
                   EvaluationResult (EvaluationFailure, EvaluationSuccess))
import PlutusCore.Default as Plutus (BuiltinSemanticsVariant (..))
import PlutusCore.Evaluation.Machine.ExBudgetingDefaults

import PlutusCore.MkPlc (builtin, mkConstant, mkIterAppNoAnn)
import PlutusPrelude
import Text.Show.Pretty (ppShow)

ecdsaSecp256k1Prop :: PropertyT IO ()
ecdsaSecp256k1Prop :: PropertyT IO ()
ecdsaSecp256k1Prop = do
  Case EcdsaSecp256k1DSIGN MessageHash
testCase <- (Case EcdsaSecp256k1DSIGN MessageHash -> String)
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
-> PropertyT IO (Case EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a.
(Monad m, HasCallStack) =>
(a -> String) -> Gen a -> PropertyT m a
forAllWith Case EcdsaSecp256k1DSIGN MessageHash -> String
forall a. Show a => a -> String
ppShow Gen (Case EcdsaSecp256k1DSIGN MessageHash)
genEcdsaCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"malformed verification key" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
   (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
   (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
      (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
      (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
      (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
      (Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
    -> Market
         (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
         (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
         (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
  (Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
-> Market
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
     (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
     (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"malformed message" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
          SigDSIGN EcdsaSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, ByteString, SigDSIGN a)
  (f (VerKeyDSIGN a, ByteString, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadMessage) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"malformed signature" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
   (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
      (Identity
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
    -> Market
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
         (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
  (Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
     (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"mismatch of signing key and verification key" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"mismatch of message and signature" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
4 LabelName
"happy path" (Bool -> PropertyT IO ())
-> (Case EcdsaSecp256k1DSIGN MessageHash -> Bool)
-> Case EcdsaSecp256k1DSIGN MessageHash
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> Case EcdsaSecp256k1DSIGN MessageHash -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Identity (Case EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
   (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
   (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
 -> Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Case EcdsaSecp256k1DSIGN MessageHash)
      (Identity (Case EcdsaSecp256k1DSIGN MessageHash)))
-> (Market
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
       SigDSIGN EcdsaSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
          SigDSIGN EcdsaSecp256k1DSIGN)
         (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
         (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)))
-> APrism
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (Case EcdsaSecp256k1DSIGN MessageHash)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
     (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
     (Identity (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood) (Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ())
-> Case EcdsaSecp256k1DSIGN MessageHash -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case EcdsaSecp256k1DSIGN MessageHash
testCase
  BuiltinSemanticsVariant DefaultFun
-> Case EcdsaSecp256k1DSIGN MessageHash
-> (MessageHash -> ByteString)
-> DefaultFun
-> PropertyT IO ()
forall a msg.
DSIGNAlgorithm a =>
BuiltinSemanticsVariant DefaultFun
-> Case a msg
-> (msg -> ByteString)
-> DefaultFun
-> PropertyT IO ()
runTestDataWith BuiltinSemanticsVariant DefaultFun
forall a. Default a => a
def Case EcdsaSecp256k1DSIGN MessageHash
testCase MessageHash -> ByteString
fromMessageHash DefaultFun
VerifyEcdsaSecp256k1Signature

schnorrSecp256k1Prop :: PropertyT IO ()
schnorrSecp256k1Prop :: PropertyT IO ()
schnorrSecp256k1Prop = do
  Case SchnorrSecp256k1DSIGN ByteString
testCase <- (Case SchnorrSecp256k1DSIGN ByteString -> String)
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
-> PropertyT IO (Case SchnorrSecp256k1DSIGN ByteString)
forall (m :: * -> *) a.
(Monad m, HasCallStack) =>
(a -> String) -> Gen a -> PropertyT m a
forAllWith Case SchnorrSecp256k1DSIGN ByteString -> String
forall a. Show a => a -> String
ppShow Gen (Case SchnorrSecp256k1DSIGN ByteString)
genSchnorrCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"malformed verification key" (Bool -> PropertyT IO ())
-> (Case SchnorrSecp256k1DSIGN ByteString -> Bool)
-> Case SchnorrSecp256k1DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case SchnorrSecp256k1DSIGN ByteString)
  (Case SchnorrSecp256k1DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
-> Case SchnorrSecp256k1DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
-> Market
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Identity (Case SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
   (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
   (ErrorCase SchnorrSecp256k1DSIGN ByteString)
   (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
 -> Market
      (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
      (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
      (Case SchnorrSecp256k1DSIGN ByteString)
      (Identity (Case SchnorrSecp256k1DSIGN ByteString)))
-> (Market
      (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
      (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
      (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
      (Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
    -> Market
         (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
         (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
         (ErrorCase SchnorrSecp256k1DSIGN ByteString)
         (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString)))
-> APrism
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
  (Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
-> Market
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
     (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
     (ErrorCase SchnorrSecp256k1DSIGN ByteString)
     (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey) (Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ())
-> Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case SchnorrSecp256k1DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"malformed signature" (Bool -> PropertyT IO ())
-> (Case SchnorrSecp256k1DSIGN ByteString -> Bool)
-> Case SchnorrSecp256k1DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case SchnorrSecp256k1DSIGN ByteString)
  (Case SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
-> Case SchnorrSecp256k1DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Identity (Case SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
   (ErrorCase SchnorrSecp256k1DSIGN ByteString)
   (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
 -> Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
      (Case SchnorrSecp256k1DSIGN ByteString)
      (Identity (Case SchnorrSecp256k1DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
      (Identity
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
    -> Market
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
         (ErrorCase SchnorrSecp256k1DSIGN ByteString)
         (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString)))
-> APrism
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
  (Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
     (ErrorCase SchnorrSecp256k1DSIGN ByteString)
     (Identity (ErrorCase SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature) (Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ())
-> Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case SchnorrSecp256k1DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"mismatch of signing key and verification key" (Bool -> PropertyT IO ())
-> (Case SchnorrSecp256k1DSIGN ByteString -> Bool)
-> Case SchnorrSecp256k1DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case SchnorrSecp256k1DSIGN ByteString)
  (Case SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> Case SchnorrSecp256k1DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Identity (Case SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
   (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
 -> Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Case SchnorrSecp256k1DSIGN ByteString)
      (Identity (Case SchnorrSecp256k1DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
         (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString)))
-> APrism
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
     (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey) (Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ())
-> Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case SchnorrSecp256k1DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"mismatch of message and signature" (Bool -> PropertyT IO ())
-> (Case SchnorrSecp256k1DSIGN ByteString -> Bool)
-> Case SchnorrSecp256k1DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case SchnorrSecp256k1DSIGN ByteString)
  (Case SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> Case SchnorrSecp256k1DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Identity (Case SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
   (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
 -> Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Case SchnorrSecp256k1DSIGN ByteString)
      (Identity (Case SchnorrSecp256k1DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
         (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString)))
-> APrism
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
     (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature) (Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ())
-> Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case SchnorrSecp256k1DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"happy path" (Bool -> PropertyT IO ())
-> (Case SchnorrSecp256k1DSIGN ByteString -> Bool)
-> Case SchnorrSecp256k1DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case SchnorrSecp256k1DSIGN ByteString)
  (Case SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> Case SchnorrSecp256k1DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Identity (Case SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
   (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
   (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
 -> Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Case SchnorrSecp256k1DSIGN ByteString)
      (Identity (Case SchnorrSecp256k1DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
       SigDSIGN SchnorrSecp256k1DSIGN)
      (Identity
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN))
    -> Market
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
          SigDSIGN SchnorrSecp256k1DSIGN)
         (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
         (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString)))
-> APrism
     (Case SchnorrSecp256k1DSIGN ByteString)
     (Case SchnorrSecp256k1DSIGN ByteString)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
  (Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN))
-> Market
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
     (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
     (Identity (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood) (Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ())
-> Case SchnorrSecp256k1DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case SchnorrSecp256k1DSIGN ByteString
testCase
  BuiltinSemanticsVariant DefaultFun
-> Case SchnorrSecp256k1DSIGN ByteString
-> (ByteString -> ByteString)
-> DefaultFun
-> PropertyT IO ()
forall a msg.
DSIGNAlgorithm a =>
BuiltinSemanticsVariant DefaultFun
-> Case a msg
-> (msg -> ByteString)
-> DefaultFun
-> PropertyT IO ()
runTestDataWith BuiltinSemanticsVariant DefaultFun
forall a. Default a => a
def Case SchnorrSecp256k1DSIGN ByteString
testCase ByteString -> ByteString
forall a. a -> a
id DefaultFun
VerifySchnorrSecp256k1Signature

ed25519Prop :: BuiltinSemanticsVariant DefaultFun -> PropertyT IO ()
ed25519Prop :: BuiltinSemanticsVariant DefaultFun -> PropertyT IO ()
ed25519Prop BuiltinSemanticsVariant DefaultFun
semvar = do
  Case Ed25519DSIGN ByteString
testCase <- (Case Ed25519DSIGN ByteString -> String)
-> Gen (Case Ed25519DSIGN ByteString)
-> PropertyT IO (Case Ed25519DSIGN ByteString)
forall (m :: * -> *) a.
(Monad m, HasCallStack) =>
(a -> String) -> Gen a -> PropertyT m a
forAllWith Case Ed25519DSIGN ByteString -> String
forall a. Show a => a -> String
ppShow Gen (Case Ed25519DSIGN ByteString)
genEd25519Case
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"malformed verification key" (Bool -> PropertyT IO ())
-> (Case Ed25519DSIGN ByteString -> Bool)
-> Case Ed25519DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case Ed25519DSIGN ByteString)
  (Case Ed25519DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
-> Case Ed25519DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (ErrorCase Ed25519DSIGN ByteString)
  (Identity (ErrorCase Ed25519DSIGN ByteString))
-> Market
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
     (Case Ed25519DSIGN ByteString)
     (Identity (Case Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
   (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
   (ErrorCase Ed25519DSIGN ByteString)
   (Identity (ErrorCase Ed25519DSIGN ByteString))
 -> Market
      (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
      (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
      (Case Ed25519DSIGN ByteString)
      (Identity (Case Ed25519DSIGN ByteString)))
-> (Market
      (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
      (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
      (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
      (Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
    -> Market
         (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
         (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
         (ErrorCase Ed25519DSIGN ByteString)
         (Identity (ErrorCase Ed25519DSIGN ByteString)))
-> APrism
     (Case Ed25519DSIGN ByteString)
     (Case Ed25519DSIGN ByteString)
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
  (Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
-> Market
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
     (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
     (ErrorCase Ed25519DSIGN ByteString)
     (Identity (ErrorCase Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey) (Case Ed25519DSIGN ByteString -> PropertyT IO ())
-> Case Ed25519DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case Ed25519DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"malformed signature" (Bool -> PropertyT IO ())
-> (Case Ed25519DSIGN ByteString -> Bool)
-> Case Ed25519DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case Ed25519DSIGN ByteString)
  (Case Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
-> Case Ed25519DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (ErrorCase Ed25519DSIGN ByteString)
  (Identity (ErrorCase Ed25519DSIGN ByteString))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
     (Case Ed25519DSIGN ByteString)
     (Identity (Case Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (Market
   (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
   (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
   (ErrorCase Ed25519DSIGN ByteString)
   (Identity (ErrorCase Ed25519DSIGN ByteString))
 -> Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
      (Case Ed25519DSIGN ByteString)
      (Identity (Case Ed25519DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
      (Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
    -> Market
         (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
         (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
         (ErrorCase Ed25519DSIGN ByteString)
         (Identity (ErrorCase Ed25519DSIGN ByteString)))
-> APrism
     (Case Ed25519DSIGN ByteString)
     (Case Ed25519DSIGN ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
  (Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
     (ErrorCase Ed25519DSIGN ByteString)
     (Identity (ErrorCase Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature) (Case Ed25519DSIGN ByteString -> PropertyT IO ())
-> Case Ed25519DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case Ed25519DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"mismatch of signing key and verification key" (Bool -> PropertyT IO ())
-> (Case Ed25519DSIGN ByteString -> Bool)
-> Case Ed25519DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case Ed25519DSIGN ByteString)
  (Case Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Case Ed25519DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (NoErrorCase Ed25519DSIGN ByteString)
  (Identity (NoErrorCase Ed25519DSIGN ByteString))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (Case Ed25519DSIGN ByteString)
     (Identity (Case Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (NoErrorCase Ed25519DSIGN ByteString)
   (Identity (NoErrorCase Ed25519DSIGN ByteString))
 -> Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Case Ed25519DSIGN ByteString)
      (Identity (Case Ed25519DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Identity
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
    -> Market
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (NoErrorCase Ed25519DSIGN ByteString)
         (Identity (NoErrorCase Ed25519DSIGN ByteString)))
-> APrism
     (Case Ed25519DSIGN ByteString)
     (Case Ed25519DSIGN ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (NoErrorCase Ed25519DSIGN ByteString)
     (Identity (NoErrorCase Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey) (Case Ed25519DSIGN ByteString -> PropertyT IO ())
-> Case Ed25519DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case Ed25519DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"mismatch of message and signature" (Bool -> PropertyT IO ())
-> (Case Ed25519DSIGN ByteString -> Bool)
-> Case Ed25519DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case Ed25519DSIGN ByteString)
  (Case Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Case Ed25519DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (NoErrorCase Ed25519DSIGN ByteString)
  (Identity (NoErrorCase Ed25519DSIGN ByteString))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (Case Ed25519DSIGN ByteString)
     (Identity (Case Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (NoErrorCase Ed25519DSIGN ByteString)
   (Identity (NoErrorCase Ed25519DSIGN ByteString))
 -> Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Case Ed25519DSIGN ByteString)
      (Identity (Case Ed25519DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Identity
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
    -> Market
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (NoErrorCase Ed25519DSIGN ByteString)
         (Identity (NoErrorCase Ed25519DSIGN ByteString)))
-> APrism
     (Case Ed25519DSIGN ByteString)
     (Case Ed25519DSIGN ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (NoErrorCase Ed25519DSIGN ByteString)
     (Identity (NoErrorCase Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature) (Case Ed25519DSIGN ByteString -> PropertyT IO ())
-> Case Ed25519DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case Ed25519DSIGN ByteString
testCase
  CoverPercentage -> LabelName -> Bool -> PropertyT IO ()
forall (m :: * -> *).
(MonadTest m, HasCallStack) =>
CoverPercentage -> LabelName -> Bool -> m ()
cover CoverPercentage
5 LabelName
"happy path" (Bool -> PropertyT IO ())
-> (Case Ed25519DSIGN ByteString -> Bool)
-> Case Ed25519DSIGN ByteString
-> PropertyT IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. APrism
  (Case Ed25519DSIGN ByteString)
  (Case Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Case Ed25519DSIGN ByteString -> Bool
forall s t a b. APrism s t a b -> s -> Bool
is (Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (NoErrorCase Ed25519DSIGN ByteString)
  (Identity (NoErrorCase Ed25519DSIGN ByteString))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (Case Ed25519DSIGN ByteString)
     (Identity (Case Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (Market
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
   (NoErrorCase Ed25519DSIGN ByteString)
   (Identity (NoErrorCase Ed25519DSIGN ByteString))
 -> Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Case Ed25519DSIGN ByteString)
      (Identity (Case Ed25519DSIGN ByteString)))
-> (Market
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
      (Identity
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
    -> Market
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
         (NoErrorCase Ed25519DSIGN ByteString)
         (Identity (NoErrorCase Ed25519DSIGN ByteString)))
-> APrism
     (Case Ed25519DSIGN ByteString)
     (Case Ed25519DSIGN ByteString)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Market
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
  (Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN))
-> Market
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
     (NoErrorCase Ed25519DSIGN ByteString)
     (Identity (NoErrorCase Ed25519DSIGN ByteString))
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood) (Case Ed25519DSIGN ByteString -> PropertyT IO ())
-> Case Ed25519DSIGN ByteString -> PropertyT IO ()
forall a b. (a -> b) -> a -> b
$ Case Ed25519DSIGN ByteString
testCase
  BuiltinSemanticsVariant DefaultFun
-> Case Ed25519DSIGN ByteString
-> (ByteString -> ByteString)
-> DefaultFun
-> PropertyT IO ()
forall a msg.
DSIGNAlgorithm a =>
BuiltinSemanticsVariant DefaultFun
-> Case a msg
-> (msg -> ByteString)
-> DefaultFun
-> PropertyT IO ()
runTestDataWith BuiltinSemanticsVariant DefaultFun
semvar Case Ed25519DSIGN ByteString
testCase ByteString -> ByteString
forall a. a -> a
id DefaultFun
VerifyEd25519Signature

ed25519_VariantAProp :: PropertyT IO ()
ed25519_VariantAProp :: PropertyT IO ()
ed25519_VariantAProp = BuiltinSemanticsVariant DefaultFun -> PropertyT IO ()
ed25519Prop BuiltinSemanticsVariant DefaultFun
DefaultFunSemanticsVariantA

ed25519_VariantBProp :: PropertyT IO ()
ed25519_VariantBProp :: PropertyT IO ()
ed25519_VariantBProp = BuiltinSemanticsVariant DefaultFun -> PropertyT IO ()
ed25519Prop BuiltinSemanticsVariant DefaultFun
DefaultFunSemanticsVariantB

ed25519_VariantCProp :: PropertyT IO ()
ed25519_VariantCProp :: PropertyT IO ()
ed25519_VariantCProp = BuiltinSemanticsVariant DefaultFun -> PropertyT IO ()
ed25519Prop BuiltinSemanticsVariant DefaultFun
DefaultFunSemanticsVariantC

-- Helpers

runTestDataWith :: forall (a :: Type) (msg :: Type) .
  (DSIGNAlgorithm a) =>
  BuiltinSemanticsVariant DefaultFun ->
  Case a msg ->
  (msg -> ByteString) ->
  DefaultFun ->
  PropertyT IO ()
runTestDataWith :: forall a msg.
DSIGNAlgorithm a =>
BuiltinSemanticsVariant DefaultFun
-> Case a msg
-> (msg -> ByteString)
-> DefaultFun
-> PropertyT IO ()
runTestDataWith BuiltinSemanticsVariant DefaultFun
semvar Case a msg
testData msg -> ByteString
f DefaultFun
op = do
  let (ByteString
vk, ByteString
msg, ByteString
sig) = (msg -> ByteString)
-> Case a msg -> (ByteString, ByteString, ByteString)
forall a msg.
DSIGNAlgorithm a =>
(msg -> ByteString)
-> Case a msg -> (ByteString, ByteString, ByteString)
getCaseData msg -> ByteString
f Case a msg
testData
  let actualExp :: Term TyName Name DefaultUni DefaultFun ()
actualExp = Term TyName Name DefaultUni DefaultFun ()
-> [Term TyName Name DefaultUni DefaultFun ()]
-> Term TyName Name DefaultUni DefaultFun ()
forall (term :: * -> *) tyname name (uni :: * -> *) fun.
TermLike term tyname name uni fun =>
term () -> [term ()] -> term ()
mkIterAppNoAnn (() -> DefaultFun -> Term TyName Name DefaultUni DefaultFun ()
forall ann.
ann -> DefaultFun -> Term TyName Name DefaultUni DefaultFun ann
forall (term :: * -> *) tyname name (uni :: * -> *) fun ann.
TermLike term tyname name uni fun =>
ann -> fun -> term ann
builtin () DefaultFun
op) [
        forall a (uni :: * -> *) fun (term :: * -> *) tyname name ann.
(TermLike term tyname name uni fun, HasTermLevel uni a) =>
ann -> a -> term ann
mkConstant @ByteString () ByteString
vk,
        forall a (uni :: * -> *) fun (term :: * -> *) tyname name ann.
(TermLike term tyname name uni fun, HasTermLevel uni a) =>
ann -> a -> term ann
mkConstant @ByteString () ByteString
msg,
        forall a (uni :: * -> *) fun (term :: * -> *) tyname name ann.
(TermLike term tyname name uni fun, HasTermLevel uni a) =>
ann -> a -> term ann
mkConstant @ByteString () ByteString
sig
        ]
  let result :: Either
  (Error DefaultUni DefaultFun ())
  (EvaluationResult (Term Name DefaultUni DefaultFun ()), [Text])
result = BuiltinSemanticsVariant DefaultFun
-> CostingPart DefaultUni DefaultFun
-> Term TyName Name DefaultUni DefaultFun ()
-> Either
     (Error DefaultUni DefaultFun ())
     (EvaluationResult (Term Name DefaultUni DefaultFun ()), [Text])
forall (uni :: * -> *) fun (m :: * -> *).
(MonadError (Error uni fun ()) m, Typecheckable uni fun, GEq uni,
 Everywhere uni ExMemoryUsage, PrettyUni uni, Pretty fun) =>
BuiltinSemanticsVariant fun
-> CostingPart uni fun
-> Term TyName Name uni fun ()
-> m (EvaluationResult (Term Name uni fun ()), [Text])
typecheckEvaluateCek BuiltinSemanticsVariant DefaultFun
semvar BuiltinCostModel
CostingPart DefaultUni DefaultFun
defaultBuiltinCostModelForTesting Term TyName Name DefaultUni DefaultFun ()
actualExp  -- FIXME: semantic variant?
  case Either
  (Error DefaultUni DefaultFun ())
  (EvaluationResult (Term Name DefaultUni DefaultFun ()), [Text])
result of
    Left Error DefaultUni DefaultFun ()
x -> Error DefaultUni DefaultFun () -> PropertyT IO ()
forall (m :: * -> *) a.
(MonadTest m, Show a, HasCallStack) =>
a -> m ()
annotateShow Error DefaultUni DefaultFun ()
x PropertyT IO () -> PropertyT IO () -> PropertyT IO ()
forall a b. PropertyT IO a -> PropertyT IO b -> PropertyT IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PropertyT IO ()
forall (m :: * -> *) a. (MonadTest m, HasCallStack) => m a
failure
    Right (EvaluationResult (Term Name DefaultUni DefaultFun ())
res, [Text]
logs) -> do
      [Text] -> PropertyT IO ()
forall (m :: * -> *) a.
(MonadTest m, Show a, HasCallStack) =>
a -> m ()
annotateShow [Text]
logs
      case Getting
  (First (NoErrorCase a msg)) (Case a msg) (NoErrorCase a msg)
-> Case a msg -> Maybe (NoErrorCase a msg)
forall s (m :: * -> *) a.
MonadReader s m =>
Getting (First a) s a -> m (Maybe a)
preview Getting
  (First (NoErrorCase a msg)) (Case a msg) (NoErrorCase a msg)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError Case a msg
testData of
        Maybe (NoErrorCase a msg)
Nothing -> EvaluationResult (Term Name DefaultUni DefaultFun ())
res EvaluationResult (Term Name DefaultUni DefaultFun ())
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
-> PropertyT IO ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== EvaluationResult (Term Name DefaultUni DefaultFun ())
forall a. EvaluationResult a
EvaluationFailure
        Just NoErrorCase a msg
good -> case Getting
  (First (VerKeyDSIGN a, msg, SigDSIGN a))
  (NoErrorCase a msg)
  (VerKeyDSIGN a, msg, SigDSIGN a)
-> NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall s (m :: * -> *) a.
MonadReader s m =>
Getting (First a) s a -> m (Maybe a)
preview Getting
  (First (VerKeyDSIGN a, msg, SigDSIGN a))
  (NoErrorCase a msg)
  (VerKeyDSIGN a, msg, SigDSIGN a)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood NoErrorCase a msg
good of
          Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
Nothing -> EvaluationResult (Term Name DefaultUni DefaultFun ())
res EvaluationResult (Term Name DefaultUni DefaultFun ())
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
-> PropertyT IO ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (Term Name DefaultUni DefaultFun ()
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall a. a -> EvaluationResult a
EvaluationSuccess (Term Name DefaultUni DefaultFun ()
 -> EvaluationResult (Term Name DefaultUni DefaultFun ()))
-> (Bool -> Term Name DefaultUni DefaultFun ())
-> Bool
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Bool -> Term Name DefaultUni DefaultFun ()
forall a (uni :: * -> *) fun (term :: * -> *) tyname name ann.
(TermLike term tyname name uni fun, HasTermLevel uni a) =>
ann -> a -> term ann
mkConstant () (Bool -> EvaluationResult (Term Name DefaultUni DefaultFun ()))
-> Bool -> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall a b. (a -> b) -> a -> b
$ Bool
False)
          Just (VerKeyDSIGN a, msg, SigDSIGN a)
_  -> EvaluationResult (Term Name DefaultUni DefaultFun ())
res EvaluationResult (Term Name DefaultUni DefaultFun ())
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
-> PropertyT IO ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (Term Name DefaultUni DefaultFun ()
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall a. a -> EvaluationResult a
EvaluationSuccess (Term Name DefaultUni DefaultFun ()
 -> EvaluationResult (Term Name DefaultUni DefaultFun ()))
-> (Bool -> Term Name DefaultUni DefaultFun ())
-> Bool
-> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Bool -> Term Name DefaultUni DefaultFun ()
forall a (uni :: * -> *) fun (term :: * -> *) tyname name ann.
(TermLike term tyname name uni fun, HasTermLevel uni a) =>
ann -> a -> term ann
mkConstant () (Bool -> EvaluationResult (Term Name DefaultUni DefaultFun ()))
-> Bool -> EvaluationResult (Term Name DefaultUni DefaultFun ())
forall a b. (a -> b) -> a -> b
$ Bool
True)

-- Data for an erroring case
data ErrorCase (a :: Type) (msg :: Type) where
  BadVerKey :: ByteString -> msg -> SigDSIGN a -> ErrorCase a msg
  BadMsg :: VerKeyDSIGN a -> ByteString -> SigDSIGN a -> ErrorCase a msg
  BadSig :: VerKeyDSIGN a -> msg -> ByteString -> ErrorCase a msg

deriving stock instance (Eq msg, DSIGNAlgorithm a) => Eq (ErrorCase a msg)

deriving stock instance (Show msg, DSIGNAlgorithm a) => Show (ErrorCase a msg)

_BadVerKey :: forall (a :: Type) (msg :: Type) .
  Prism' (ErrorCase a msg) (ByteString, msg, SigDSIGN a)
_BadVerKey :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey = ((ByteString, msg, SigDSIGN a) -> ErrorCase a msg)
-> (ErrorCase a msg -> Maybe (ByteString, msg, SigDSIGN a))
-> Prism
     (ErrorCase a msg)
     (ErrorCase a msg)
     (ByteString, msg, SigDSIGN a)
     (ByteString, msg, SigDSIGN a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (ByteString, msg, SigDSIGN a) -> ErrorCase a msg
into ErrorCase a msg -> Maybe (ByteString, msg, SigDSIGN a)
outOf
  where
    into :: (ByteString, msg, SigDSIGN a) -> ErrorCase a msg
    into :: (ByteString, msg, SigDSIGN a) -> ErrorCase a msg
into (ByteString
bs, msg
message, SigDSIGN a
sig) = ByteString -> msg -> SigDSIGN a -> ErrorCase a msg
forall msg a. ByteString -> msg -> SigDSIGN a -> ErrorCase a msg
BadVerKey ByteString
bs msg
message SigDSIGN a
sig
    outOf :: ErrorCase a msg -> Maybe (ByteString, msg, SigDSIGN a)
    outOf :: ErrorCase a msg -> Maybe (ByteString, msg, SigDSIGN a)
outOf = \case
      BadVerKey ByteString
bs msg
message SigDSIGN a
sig -> (ByteString, msg, SigDSIGN a)
-> Maybe (ByteString, msg, SigDSIGN a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ByteString
bs, msg
message, SigDSIGN a
sig)
      ErrorCase a msg
_                        -> Maybe (ByteString, msg, SigDSIGN a)
forall a. Maybe a
Nothing

_BadMessage :: forall (a :: Type) (msg :: Type) .
  Prism' (ErrorCase a msg) (VerKeyDSIGN a, ByteString, SigDSIGN a)
_BadMessage :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, ByteString, SigDSIGN a)
  (f (VerKeyDSIGN a, ByteString, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadMessage = ((VerKeyDSIGN a, ByteString, SigDSIGN a) -> ErrorCase a msg)
-> (ErrorCase a msg
    -> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a))
-> Prism
     (ErrorCase a msg)
     (ErrorCase a msg)
     (VerKeyDSIGN a, ByteString, SigDSIGN a)
     (VerKeyDSIGN a, ByteString, SigDSIGN a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (VerKeyDSIGN a, ByteString, SigDSIGN a) -> ErrorCase a msg
into ErrorCase a msg -> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a)
outOf
  where
    into :: (VerKeyDSIGN a, ByteString, SigDSIGN a) -> ErrorCase a msg
    into :: (VerKeyDSIGN a, ByteString, SigDSIGN a) -> ErrorCase a msg
into (VerKeyDSIGN a
vk, ByteString
bs, SigDSIGN a
sig) = VerKeyDSIGN a -> ByteString -> SigDSIGN a -> ErrorCase a msg
forall a msg.
VerKeyDSIGN a -> ByteString -> SigDSIGN a -> ErrorCase a msg
BadMsg VerKeyDSIGN a
vk ByteString
bs SigDSIGN a
sig
    outOf :: ErrorCase a msg -> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a)
    outOf :: ErrorCase a msg -> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a)
outOf = \case
      BadMsg VerKeyDSIGN a
vk ByteString
bs SigDSIGN a
sig -> (VerKeyDSIGN a, ByteString, SigDSIGN a)
-> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vk, ByteString
bs, SigDSIGN a
sig)
      ErrorCase a msg
_                -> Maybe (VerKeyDSIGN a, ByteString, SigDSIGN a)
forall a. Maybe a
Nothing

_BadSignature :: forall (a :: Type) (msg :: Type) .
  Prism' (ErrorCase a msg) (VerKeyDSIGN a, msg, ByteString)
_BadSignature :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature = ((VerKeyDSIGN a, msg, ByteString) -> ErrorCase a msg)
-> (ErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, ByteString))
-> Prism
     (ErrorCase a msg)
     (ErrorCase a msg)
     (VerKeyDSIGN a, msg, ByteString)
     (VerKeyDSIGN a, msg, ByteString)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (VerKeyDSIGN a, msg, ByteString) -> ErrorCase a msg
into ErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, ByteString)
outOf
  where
    into :: (VerKeyDSIGN a, msg, ByteString) -> ErrorCase a msg
    into :: (VerKeyDSIGN a, msg, ByteString) -> ErrorCase a msg
into (VerKeyDSIGN a
vk, msg
message, ByteString
sig) = VerKeyDSIGN a -> msg -> ByteString -> ErrorCase a msg
forall a msg. VerKeyDSIGN a -> msg -> ByteString -> ErrorCase a msg
BadSig VerKeyDSIGN a
vk msg
message ByteString
sig
    outOf :: ErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, ByteString)
    outOf :: ErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, ByteString)
outOf = \case
      BadSig VerKeyDSIGN a
vk msg
message ByteString
bs -> (VerKeyDSIGN a, msg, ByteString)
-> Maybe (VerKeyDSIGN a, msg, ByteString)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vk, msg
message, ByteString
bs)
      ErrorCase a msg
_                    -> Maybe (VerKeyDSIGN a, msg, ByteString)
forall a. Maybe a
Nothing

-- Data for non-erroring case
data NoErrorCase (a :: Type) (msg :: Type) where
  WrongVerKey :: VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
  WrongSignature :: VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
  AllGood :: VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg

deriving stock instance (Eq msg, DSIGNAlgorithm a) => Eq (NoErrorCase a msg)

deriving stock instance (Show msg, DSIGNAlgorithm a) => Show (NoErrorCase a msg)

_WrongVerKey :: forall (a :: Type) (msg :: Type) .
  Prism' (NoErrorCase a msg) (VerKeyDSIGN a, msg, SigDSIGN a)
_WrongVerKey :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey = ((VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg)
-> (NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a))
-> Prism
     (NoErrorCase a msg)
     (NoErrorCase a msg)
     (VerKeyDSIGN a, msg, SigDSIGN a)
     (VerKeyDSIGN a, msg, SigDSIGN a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf
  where
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig) = VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
forall a msg.
VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
WrongVerKey VerKeyDSIGN a
vk msg
message SigDSIGN a
sig
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf = \case
      WrongVerKey VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a, msg, SigDSIGN a)
-> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig)
      NoErrorCase a msg
_                          -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. Maybe a
Nothing

_WrongSignature :: forall (a :: Type) (msg :: Type) .
  Prism' (NoErrorCase a msg) (VerKeyDSIGN a, msg, SigDSIGN a)
_WrongSignature :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature = ((VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg)
-> (NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a))
-> Prism
     (NoErrorCase a msg)
     (NoErrorCase a msg)
     (VerKeyDSIGN a, msg, SigDSIGN a)
     (VerKeyDSIGN a, msg, SigDSIGN a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf
  where
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig) = VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
forall a msg.
VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
WrongSignature VerKeyDSIGN a
vk msg
message SigDSIGN a
sig
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf = \case
      WrongSignature VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a, msg, SigDSIGN a)
-> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig)
      NoErrorCase a msg
_                             -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. Maybe a
Nothing

_AllGood :: forall (a :: Type) (msg :: Type) .
  Prism' (NoErrorCase a msg) (VerKeyDSIGN a, msg, SigDSIGN a)
_AllGood :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood = ((VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg)
-> (NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a))
-> Prism
     (NoErrorCase a msg)
     (NoErrorCase a msg)
     (VerKeyDSIGN a, msg, SigDSIGN a)
     (VerKeyDSIGN a, msg, SigDSIGN a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf
  where
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
    into :: (VerKeyDSIGN a, msg, SigDSIGN a) -> NoErrorCase a msg
into (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig) = VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
forall a msg.
VerKeyDSIGN a -> msg -> SigDSIGN a -> NoErrorCase a msg
AllGood VerKeyDSIGN a
vk msg
message SigDSIGN a
sig
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
    outOf :: NoErrorCase a msg -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
outOf = \case
      AllGood VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a, msg, SigDSIGN a)
-> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vk, msg
message, SigDSIGN a
sig)
      NoErrorCase a msg
_                      -> Maybe (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. Maybe a
Nothing

-- Case, irrespective of form
data Case (a :: Type) (msg :: Type) where
  ShouldError :: ErrorCase a msg -> Case a msg
  Shouldn'tError :: NoErrorCase a msg -> Case a msg

deriving stock instance (DSIGNAlgorithm a, Eq msg) => Eq (Case a msg)

deriving stock instance (DSIGNAlgorithm a, Show msg) => Show (Case a msg)

_ShouldError :: forall (a :: Type) (msg :: Type) .
  Prism' (Case a msg) (ErrorCase a msg)
_ShouldError :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError = (ErrorCase a msg -> Case a msg)
-> (Case a msg -> Maybe (ErrorCase a msg))
-> Prism
     (Case a msg) (Case a msg) (ErrorCase a msg) (ErrorCase a msg)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ErrorCase a msg -> Case a msg
into Case a msg -> Maybe (ErrorCase a msg)
outOf
  where
    into :: ErrorCase a msg -> Case a msg
    into :: ErrorCase a msg -> Case a msg
into = ErrorCase a msg -> Case a msg
forall a msg. ErrorCase a msg -> Case a msg
ShouldError
    outOf :: Case a msg -> Maybe (ErrorCase a msg)
    outOf :: Case a msg -> Maybe (ErrorCase a msg)
outOf = \case
      ShouldError ErrorCase a msg
x -> ErrorCase a msg -> Maybe (ErrorCase a msg)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ErrorCase a msg
x
      Case a msg
_             -> Maybe (ErrorCase a msg)
forall a. Maybe a
Nothing

_Shouldn'tError :: forall (a :: Type) (msg :: Type) .
  Prism' (Case a msg) (NoErrorCase a msg)
_Shouldn'tError :: forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError = (NoErrorCase a msg -> Case a msg)
-> (Case a msg -> Maybe (NoErrorCase a msg))
-> Prism
     (Case a msg) (Case a msg) (NoErrorCase a msg) (NoErrorCase a msg)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' NoErrorCase a msg -> Case a msg
into Case a msg -> Maybe (NoErrorCase a msg)
outOf
  where
    into :: NoErrorCase a msg -> Case a msg
    into :: NoErrorCase a msg -> Case a msg
into = NoErrorCase a msg -> Case a msg
forall a msg. NoErrorCase a msg -> Case a msg
Shouldn'tError
    outOf :: Case a msg -> Maybe (NoErrorCase a msg)
    outOf :: Case a msg -> Maybe (NoErrorCase a msg)
outOf = \case
      Shouldn'tError NoErrorCase a msg
x -> NoErrorCase a msg -> Maybe (NoErrorCase a msg)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NoErrorCase a msg
x
      Case a msg
_                -> Maybe (NoErrorCase a msg)
forall a. Maybe a
Nothing

getCaseData :: forall (a :: Type) (msg :: Type) .
  (DSIGNAlgorithm a) =>
  (msg -> ByteString) ->
  Case a msg ->
  (ByteString, ByteString, ByteString)
getCaseData :: forall a msg.
DSIGNAlgorithm a =>
(msg -> ByteString)
-> Case a msg -> (ByteString, ByteString, ByteString)
getCaseData msg -> ByteString
f = \case
  ShouldError ErrorCase a msg
x -> case ErrorCase a msg
x of
    BadVerKey ByteString
vk msg
message SigDSIGN a
sig -> (ByteString
vk, msg -> ByteString
f msg
message, SigDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => SigDSIGN v -> ByteString
rawSerialiseSigDSIGN SigDSIGN a
sig)
    BadMsg VerKeyDSIGN a
vk ByteString
message SigDSIGN a
sig -> (VerKeyDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
rawSerialiseVerKeyDSIGN VerKeyDSIGN a
vk,
                              ByteString
message,
                              SigDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => SigDSIGN v -> ByteString
rawSerialiseSigDSIGN SigDSIGN a
sig)
    BadSig VerKeyDSIGN a
vk msg
message ByteString
sig -> (VerKeyDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
rawSerialiseVerKeyDSIGN VerKeyDSIGN a
vk, msg -> ByteString
f msg
message, ByteString
sig)
  Shouldn'tError NoErrorCase a msg
x -> case NoErrorCase a msg
x of
    WrongVerKey VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
rawSerialiseVerKeyDSIGN VerKeyDSIGN a
vk,
                                   msg -> ByteString
f msg
message,
                                   SigDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => SigDSIGN v -> ByteString
rawSerialiseSigDSIGN SigDSIGN a
sig)
    WrongSignature VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
rawSerialiseVerKeyDSIGN VerKeyDSIGN a
vk,
                                      msg -> ByteString
f msg
message,
                                      SigDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => SigDSIGN v -> ByteString
rawSerialiseSigDSIGN SigDSIGN a
sig)
    AllGood VerKeyDSIGN a
vk msg
message SigDSIGN a
sig -> (VerKeyDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
rawSerialiseVerKeyDSIGN VerKeyDSIGN a
vk,
                               msg -> ByteString
f msg
message,
                               SigDSIGN a -> ByteString
forall v. DSIGNAlgorithm v => SigDSIGN v -> ByteString
rawSerialiseSigDSIGN SigDSIGN a
sig)

-- Generators

genEcdsaErrorCase :: Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaErrorCase :: Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaErrorCase =
  Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => m a -> m a
Gen.prune (Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
 -> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> ([Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)]
    -> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)]
 -> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a b. (a -> b) -> a -> b
$ [
    AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
-> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
-> ErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey ((ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
 -> ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> GenT
     Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
mkBadVerKeyBits,
    AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> ErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, ByteString, SigDSIGN a)
  (f (VerKeyDSIGN a, ByteString, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadMessage ((VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
  SigDSIGN EcdsaSecp256k1DSIGN)
 -> ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
mkBadMessageBits,
    AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
-> ErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature ((VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
 -> ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> GenT
     Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
mkBadSignatureBits
    ]
  where
    mkBadVerKeyBits :: Gen (ByteString,
                            MessageHash,
                            SigDSIGN EcdsaSecp256k1DSIGN)
    mkBadVerKeyBits :: GenT
  Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
mkBadVerKeyBits = (,,) (ByteString
 -> MessageHash
 -> SigDSIGN EcdsaSecp256k1DSIGN
 -> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (MessageHash
      -> SigDSIGN EcdsaSecp256k1DSIGN
      -> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadVerKey @EcdsaSecp256k1DSIGN GenT
  Identity
  (MessageHash
   -> SigDSIGN EcdsaSecp256k1DSIGN
   -> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity MessageHash
-> GenT
     Identity
     (SigDSIGN EcdsaSecp256k1DSIGN
      -> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                               GenT Identity MessageHash
genEcdsaMsg GenT
  Identity
  (SigDSIGN EcdsaSecp256k1DSIGN
   -> (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
-> GenT
     Identity (ByteString, MessageHash, SigDSIGN EcdsaSecp256k1DSIGN)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                               GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
genEcdsaSig
    mkBadMessageBits :: Gen (VerKeyDSIGN EcdsaSecp256k1DSIGN,
                             ByteString,
                             SigDSIGN EcdsaSecp256k1DSIGN)
    mkBadMessageBits :: GenT
  Identity
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
   SigDSIGN EcdsaSecp256k1DSIGN)
mkBadMessageBits = (,,) (VerKeyDSIGN EcdsaSecp256k1DSIGN
 -> ByteString
 -> SigDSIGN EcdsaSecp256k1DSIGN
 -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
     SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN)
-> GenT
     Identity
     (ByteString
      -> SigDSIGN EcdsaSecp256k1DSIGN
      -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
          SigDSIGN EcdsaSecp256k1DSIGN))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey GenT
  Identity
  (ByteString
   -> SigDSIGN EcdsaSecp256k1DSIGN
   -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (SigDSIGN EcdsaSecp256k1DSIGN
      -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
          SigDSIGN EcdsaSecp256k1DSIGN))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity ByteString
genBadEcdsaMsg GenT
  Identity
  (SigDSIGN EcdsaSecp256k1DSIGN
   -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
       SigDSIGN EcdsaSecp256k1DSIGN))
-> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, ByteString,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
genEcdsaSig
    mkBadSignatureBits :: Gen (VerKeyDSIGN EcdsaSecp256k1DSIGN,
                               MessageHash,
                               ByteString)
    mkBadSignatureBits :: GenT
  Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
mkBadSignatureBits = (,,) (VerKeyDSIGN EcdsaSecp256k1DSIGN
 -> MessageHash
 -> ByteString
 -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
-> GenT Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN)
-> GenT
     Identity
     (MessageHash
      -> ByteString
      -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey GenT
  Identity
  (MessageHash
   -> ByteString
   -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
-> GenT Identity MessageHash
-> GenT
     Identity
     (ByteString
      -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  GenT Identity MessageHash
genEcdsaMsg GenT
  Identity
  (ByteString
   -> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString))
-> GenT Identity ByteString
-> GenT
     Identity (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash, ByteString)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadSig @EcdsaSecp256k1DSIGN

genSchnorrErrorCase :: Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrErrorCase :: Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrErrorCase = [Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)]
-> Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [
  AReview
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
-> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
-> ErrorCase SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey ((ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
 -> ErrorCase SchnorrSecp256k1DSIGN ByteString)
-> GenT
     Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
-> Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
mkBadVerKeyBits,
  AReview
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
-> ErrorCase SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature ((VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
 -> ErrorCase SchnorrSecp256k1DSIGN ByteString)
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
-> Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
mkBadSignatureBits
  ]
  where
    mkBadVerKeyBits :: Gen (ByteString,
                            ByteString,
                            SigDSIGN SchnorrSecp256k1DSIGN)
    mkBadVerKeyBits :: GenT
  Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
mkBadVerKeyBits = (,,) (ByteString
 -> ByteString
 -> SigDSIGN SchnorrSecp256k1DSIGN
 -> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (ByteString
      -> SigDSIGN SchnorrSecp256k1DSIGN
      -> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadVerKey @SchnorrSecp256k1DSIGN GenT
  Identity
  (ByteString
   -> SigDSIGN SchnorrSecp256k1DSIGN
   -> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (SigDSIGN SchnorrSecp256k1DSIGN
      -> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                              (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64) GenT
  Identity
  (SigDSIGN SchnorrSecp256k1DSIGN
   -> (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN))
-> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
-> GenT
     Identity (ByteString, ByteString, SigDSIGN SchnorrSecp256k1DSIGN)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                              GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
genSchnorrSig
    mkBadSignatureBits :: Gen (VerKeyDSIGN SchnorrSecp256k1DSIGN,
                               ByteString,
                               ByteString)
    mkBadSignatureBits :: GenT
  Identity
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
mkBadSignatureBits = (,,) (VerKeyDSIGN SchnorrSecp256k1DSIGN
 -> ByteString
 -> ByteString
 -> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
-> GenT Identity (VerKeyDSIGN SchnorrSecp256k1DSIGN)
-> GenT
     Identity
     (ByteString
      -> ByteString
      -> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VerKeyDSIGN SchnorrSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey GenT
  Identity
  (ByteString
   -> ByteString
   -> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
-> GenT Identity ByteString
-> GenT
     Identity
     (ByteString
      -> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64) GenT
  Identity
  (ByteString
   -> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString))
-> GenT Identity ByteString
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString, ByteString)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadSig @SchnorrSecp256k1DSIGN

genEd25519ErrorCase :: Gen (ErrorCase Ed25519DSIGN ByteString)
genEd25519ErrorCase :: Gen (ErrorCase Ed25519DSIGN ByteString)
genEd25519ErrorCase = [Gen (ErrorCase Ed25519DSIGN ByteString)]
-> Gen (ErrorCase Ed25519DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [
  AReview
  (ErrorCase Ed25519DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
-> (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
-> ErrorCase Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase Ed25519DSIGN ByteString)
  (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ByteString, msg, SigDSIGN a) (f (ByteString, msg, SigDSIGN a))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadVerKey ((ByteString, ByteString, SigDSIGN Ed25519DSIGN)
 -> ErrorCase Ed25519DSIGN ByteString)
-> GenT Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
-> Gen (ErrorCase Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
mkBadVerKeyBits,
  AReview
  (ErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
-> ErrorCase Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (ErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, ByteString)
  (f (VerKeyDSIGN a, msg, ByteString))
-> p (ErrorCase a msg) (f (ErrorCase a msg))
_BadSignature ((VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
 -> ErrorCase Ed25519DSIGN ByteString)
-> GenT Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
-> Gen (ErrorCase Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
mkBadSignatureBits
  ]
  where
    mkBadVerKeyBits :: Gen (ByteString,
                            ByteString,
                            SigDSIGN Ed25519DSIGN)
    mkBadVerKeyBits :: GenT Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
mkBadVerKeyBits = (,,) (ByteString
 -> ByteString
 -> SigDSIGN Ed25519DSIGN
 -> (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (ByteString
      -> SigDSIGN Ed25519DSIGN
      -> (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadVerKey @Ed25519DSIGN GenT
  Identity
  (ByteString
   -> SigDSIGN Ed25519DSIGN
   -> (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
-> GenT Identity ByteString
-> GenT
     Identity
     (SigDSIGN Ed25519DSIGN
      -> (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                              (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64) GenT
  Identity
  (SigDSIGN Ed25519DSIGN
   -> (ByteString, ByteString, SigDSIGN Ed25519DSIGN))
-> GenT Identity (SigDSIGN Ed25519DSIGN)
-> GenT Identity (ByteString, ByteString, SigDSIGN Ed25519DSIGN)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                              GenT Identity (SigDSIGN Ed25519DSIGN)
genEd25519Sig
    mkBadSignatureBits :: Gen (VerKeyDSIGN Ed25519DSIGN,
                               ByteString,
                               ByteString)
    mkBadSignatureBits :: GenT Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
mkBadSignatureBits = (,,) (VerKeyDSIGN Ed25519DSIGN
 -> ByteString
 -> ByteString
 -> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
-> GenT Identity (VerKeyDSIGN Ed25519DSIGN)
-> GenT
     Identity
     (ByteString
      -> ByteString
      -> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VerKeyDSIGN Ed25519DSIGN)
forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey GenT
  Identity
  (ByteString
   -> ByteString
   -> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
-> GenT Identity ByteString
-> GenT
     Identity
     (ByteString -> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64) GenT
  Identity
  (ByteString -> (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString))
-> GenT Identity ByteString
-> GenT Identity (VerKeyDSIGN Ed25519DSIGN, ByteString, ByteString)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                                  forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadSig @Ed25519DSIGN

genEcdsaNoErrorCase :: Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaNoErrorCase :: Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaNoErrorCase = do
  SignKeyDSIGN EcdsaSecp256k1DSIGN
sk <- Gen (SignKeyDSIGN EcdsaSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  let vk :: VerKeyDSIGN EcdsaSecp256k1DSIGN
vk = SignKeyDSIGN EcdsaSecp256k1DSIGN -> VerKeyDSIGN EcdsaSecp256k1DSIGN
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> VerKeyDSIGN v
deriveVerKeyDSIGN SignKeyDSIGN EcdsaSecp256k1DSIGN
sk
  MessageHash
msg <- GenT Identity MessageHash
genEcdsaMsg
  Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => m a -> m a
Gen.prune (Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
 -> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> ([Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)]
    -> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)]
 -> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a b. (a -> b) -> a -> b
$ [
    AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> NoErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey ((VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
  SigDSIGN EcdsaSecp256k1DSIGN)
 -> NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> VerKeyDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg.
(DSIGNAlgorithm a, ContextDSIGN a ~ (), Signable a msg) =>
SignKeyDSIGN a
-> VerKeyDSIGN a -> msg -> Gen (VerKeyDSIGN a, msg, SigDSIGN a)
mkWrongKeyBits SignKeyDSIGN EcdsaSecp256k1DSIGN
sk VerKeyDSIGN EcdsaSecp256k1DSIGN
vk MessageHash
msg,
    AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> NoErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature ((VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
  SigDSIGN EcdsaSecp256k1DSIGN)
 -> NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> VerKeyDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
mkWrongSignatureBits SignKeyDSIGN EcdsaSecp256k1DSIGN
sk VerKeyDSIGN EcdsaSecp256k1DSIGN
vk MessageHash
msg,
    NoErrorCase EcdsaSecp256k1DSIGN MessageHash
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NoErrorCase EcdsaSecp256k1DSIGN MessageHash
 -> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> ((VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
     SigDSIGN EcdsaSecp256k1DSIGN)
    -> NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> NoErrorCase EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
  (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
   SigDSIGN EcdsaSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood ((VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
  SigDSIGN EcdsaSecp256k1DSIGN)
 -> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash))
-> (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
    SigDSIGN EcdsaSecp256k1DSIGN)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a b. (a -> b) -> a -> b
$ (VerKeyDSIGN EcdsaSecp256k1DSIGN
vk, MessageHash
msg, ContextDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable EcdsaSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN EcdsaSecp256k1DSIGN
-> a
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
signDSIGN () MessageHash
msg SignKeyDSIGN EcdsaSecp256k1DSIGN
sk)
    ]
  where
    mkWrongSignatureBits ::
      SignKeyDSIGN EcdsaSecp256k1DSIGN ->
      VerKeyDSIGN EcdsaSecp256k1DSIGN ->
      MessageHash ->
      Gen (VerKeyDSIGN EcdsaSecp256k1DSIGN,
           MessageHash,
           SigDSIGN EcdsaSecp256k1DSIGN)
    mkWrongSignatureBits :: SignKeyDSIGN EcdsaSecp256k1DSIGN
-> VerKeyDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
mkWrongSignatureBits SignKeyDSIGN EcdsaSecp256k1DSIGN
sk VerKeyDSIGN EcdsaSecp256k1DSIGN
vk MessageHash
msg = do
      MessageHash
msgBad <- (MessageHash -> Bool)
-> GenT Identity MessageHash -> GenT Identity MessageHash
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (MessageHash -> MessageHash -> Bool
forall a. Eq a => a -> a -> Bool
/= MessageHash
msg) GenT Identity MessageHash
genEcdsaMsg
      (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
 SigDSIGN EcdsaSecp256k1DSIGN)
-> GenT
     Identity
     (VerKeyDSIGN EcdsaSecp256k1DSIGN, MessageHash,
      SigDSIGN EcdsaSecp256k1DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN EcdsaSecp256k1DSIGN
vk, MessageHash
msg, ContextDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable EcdsaSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN EcdsaSecp256k1DSIGN
-> a
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
signDSIGN () MessageHash
msgBad SignKeyDSIGN EcdsaSecp256k1DSIGN
sk)

genSchnorrNoErrorCase :: Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrNoErrorCase :: Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrNoErrorCase = do
  SignKeyDSIGN SchnorrSecp256k1DSIGN
sk <- Gen (SignKeyDSIGN SchnorrSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  let vk :: VerKeyDSIGN SchnorrSecp256k1DSIGN
vk = SignKeyDSIGN SchnorrSecp256k1DSIGN
-> VerKeyDSIGN SchnorrSecp256k1DSIGN
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> VerKeyDSIGN v
deriveVerKeyDSIGN SignKeyDSIGN SchnorrSecp256k1DSIGN
sk
  ByteString
msg <- Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64
  [Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)]
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [
    AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
-> NoErrorCase SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey ((VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
  SigDSIGN SchnorrSecp256k1DSIGN)
 -> NoErrorCase SchnorrSecp256k1DSIGN ByteString)
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> VerKeyDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
forall a msg.
(DSIGNAlgorithm a, ContextDSIGN a ~ (), Signable a msg) =>
SignKeyDSIGN a
-> VerKeyDSIGN a -> msg -> Gen (VerKeyDSIGN a, msg, SigDSIGN a)
mkWrongKeyBits SignKeyDSIGN SchnorrSecp256k1DSIGN
sk VerKeyDSIGN SchnorrSecp256k1DSIGN
vk ByteString
msg,
    AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
-> NoErrorCase SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature ((VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
  SigDSIGN SchnorrSecp256k1DSIGN)
 -> NoErrorCase SchnorrSecp256k1DSIGN ByteString)
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> VerKeyDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
mkWrongSignatureBits SignKeyDSIGN SchnorrSecp256k1DSIGN
sk VerKeyDSIGN SchnorrSecp256k1DSIGN
vk ByteString
msg,
    NoErrorCase SchnorrSecp256k1DSIGN ByteString
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NoErrorCase SchnorrSecp256k1DSIGN ByteString
 -> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
-> ((VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
     SigDSIGN SchnorrSecp256k1DSIGN)
    -> NoErrorCase SchnorrSecp256k1DSIGN ByteString)
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
-> NoErrorCase SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
  (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
   SigDSIGN SchnorrSecp256k1DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood ((VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
  SigDSIGN SchnorrSecp256k1DSIGN)
 -> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString))
-> (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
    SigDSIGN SchnorrSecp256k1DSIGN)
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall a b. (a -> b) -> a -> b
$ (VerKeyDSIGN SchnorrSecp256k1DSIGN
vk, ByteString
msg, ContextDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable SchnorrSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN SchnorrSecp256k1DSIGN
-> a
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
signDSIGN () ByteString
msg SignKeyDSIGN SchnorrSecp256k1DSIGN
sk)
    ]
  where
    mkWrongSignatureBits ::
      SignKeyDSIGN SchnorrSecp256k1DSIGN ->
      VerKeyDSIGN SchnorrSecp256k1DSIGN ->
      ByteString ->
      Gen (VerKeyDSIGN SchnorrSecp256k1DSIGN,
           ByteString,
           SigDSIGN SchnorrSecp256k1DSIGN)
    mkWrongSignatureBits :: SignKeyDSIGN SchnorrSecp256k1DSIGN
-> VerKeyDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
mkWrongSignatureBits SignKeyDSIGN SchnorrSecp256k1DSIGN
sk VerKeyDSIGN SchnorrSecp256k1DSIGN
vk ByteString
msg = do
      ByteString
msgBad <- (ByteString -> Bool)
-> GenT Identity ByteString -> GenT Identity ByteString
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
/= ByteString
msg) (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64)
      (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
 SigDSIGN SchnorrSecp256k1DSIGN)
-> GenT
     Identity
     (VerKeyDSIGN SchnorrSecp256k1DSIGN, ByteString,
      SigDSIGN SchnorrSecp256k1DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN SchnorrSecp256k1DSIGN
vk, ByteString
msg, ContextDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable SchnorrSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN SchnorrSecp256k1DSIGN
-> a
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
signDSIGN () ByteString
msgBad SignKeyDSIGN SchnorrSecp256k1DSIGN
sk)

genEd25519NoErrorCase :: Gen (NoErrorCase Ed25519DSIGN ByteString)
genEd25519NoErrorCase :: Gen (NoErrorCase Ed25519DSIGN ByteString)
genEd25519NoErrorCase = do
  SignKeyDSIGN Ed25519DSIGN
sk <- Gen (SignKeyDSIGN Ed25519DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  let vk :: VerKeyDSIGN Ed25519DSIGN
vk = SignKeyDSIGN Ed25519DSIGN -> VerKeyDSIGN Ed25519DSIGN
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> VerKeyDSIGN v
deriveVerKeyDSIGN SignKeyDSIGN Ed25519DSIGN
sk
  ByteString
msg <- Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64
  [Gen (NoErrorCase Ed25519DSIGN ByteString)]
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [
    AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> NoErrorCase Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongVerKey ((VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
 -> NoErrorCase Ed25519DSIGN ByteString)
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN Ed25519DSIGN
-> VerKeyDSIGN Ed25519DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall a msg.
(DSIGNAlgorithm a, ContextDSIGN a ~ (), Signable a msg) =>
SignKeyDSIGN a
-> VerKeyDSIGN a -> msg -> Gen (VerKeyDSIGN a, msg, SigDSIGN a)
mkWrongKeyBits SignKeyDSIGN Ed25519DSIGN
sk VerKeyDSIGN Ed25519DSIGN
vk ByteString
msg,
    AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> NoErrorCase Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_WrongSignature ((VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
 -> NoErrorCase Ed25519DSIGN ByteString)
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignKeyDSIGN Ed25519DSIGN
-> VerKeyDSIGN Ed25519DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
mkWrongSignatureBits SignKeyDSIGN Ed25519DSIGN
sk VerKeyDSIGN Ed25519DSIGN
vk ByteString
msg,
    NoErrorCase Ed25519DSIGN ByteString
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NoErrorCase Ed25519DSIGN ByteString
 -> Gen (NoErrorCase Ed25519DSIGN ByteString))
-> ((VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
    -> NoErrorCase Ed25519DSIGN ByteString)
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> NoErrorCase Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (NoErrorCase Ed25519DSIGN ByteString)
  (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (VerKeyDSIGN a, msg, SigDSIGN a)
  (f (VerKeyDSIGN a, msg, SigDSIGN a))
-> p (NoErrorCase a msg) (f (NoErrorCase a msg))
_AllGood ((VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
 -> Gen (NoErrorCase Ed25519DSIGN ByteString))
-> (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
forall a b. (a -> b) -> a -> b
$ (VerKeyDSIGN Ed25519DSIGN
vk, ByteString
msg, ContextDSIGN Ed25519DSIGN
-> ByteString -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable Ed25519DSIGN a, HasCallStack) =>
ContextDSIGN Ed25519DSIGN
-> a -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
signDSIGN () ByteString
msg SignKeyDSIGN Ed25519DSIGN
sk)
    ]
  where
    mkWrongSignatureBits ::
      SignKeyDSIGN Ed25519DSIGN ->
      VerKeyDSIGN Ed25519DSIGN ->
      ByteString ->
      Gen (VerKeyDSIGN Ed25519DSIGN,
           ByteString,
           SigDSIGN Ed25519DSIGN)
    mkWrongSignatureBits :: SignKeyDSIGN Ed25519DSIGN
-> VerKeyDSIGN Ed25519DSIGN
-> ByteString
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
mkWrongSignatureBits SignKeyDSIGN Ed25519DSIGN
sk VerKeyDSIGN Ed25519DSIGN
vk ByteString
msg = do
      ByteString
msgBad <- (ByteString -> Bool)
-> GenT Identity ByteString -> GenT Identity ByteString
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
/= ByteString
msg) (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64)
      (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
-> GenT
     Identity
     (VerKeyDSIGN Ed25519DSIGN, ByteString, SigDSIGN Ed25519DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN Ed25519DSIGN
vk, ByteString
msg, ContextDSIGN Ed25519DSIGN
-> ByteString -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable Ed25519DSIGN a, HasCallStack) =>
ContextDSIGN Ed25519DSIGN
-> a -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
signDSIGN () ByteString
msgBad SignKeyDSIGN Ed25519DSIGN
sk)

genEcdsaCase :: Gen (Case EcdsaSecp256k1DSIGN MessageHash)
genEcdsaCase :: Gen (Case EcdsaSecp256k1DSIGN MessageHash)
genEcdsaCase = Gen (Case EcdsaSecp256k1DSIGN MessageHash)
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => m a -> m a
Gen.prune (Gen (Case EcdsaSecp256k1DSIGN MessageHash)
 -> Gen (Case EcdsaSecp256k1DSIGN MessageHash))
-> ([Gen (Case EcdsaSecp256k1DSIGN MessageHash)]
    -> Gen (Case EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (Case EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Gen (Case EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([Gen (Case EcdsaSecp256k1DSIGN MessageHash)]
 -> Gen (Case EcdsaSecp256k1DSIGN MessageHash))
-> [Gen (Case EcdsaSecp256k1DSIGN MessageHash)]
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall a b. (a -> b) -> a -> b
$ [
  AReview
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> NoErrorCase EcdsaSecp256k1DSIGN MessageHash
-> Case EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (NoErrorCase EcdsaSecp256k1DSIGN MessageHash
 -> Case EcdsaSecp256k1DSIGN MessageHash)
-> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NoErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaNoErrorCase,
  AReview
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> ErrorCase EcdsaSecp256k1DSIGN MessageHash
-> Case EcdsaSecp256k1DSIGN MessageHash
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case EcdsaSecp256k1DSIGN MessageHash)
  (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (ErrorCase EcdsaSecp256k1DSIGN MessageHash
 -> Case EcdsaSecp256k1DSIGN MessageHash)
-> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
-> Gen (Case EcdsaSecp256k1DSIGN MessageHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ErrorCase EcdsaSecp256k1DSIGN MessageHash)
genEcdsaErrorCase
  ]

genSchnorrCase :: Gen (Case SchnorrSecp256k1DSIGN ByteString)
genSchnorrCase :: Gen (Case SchnorrSecp256k1DSIGN ByteString)
genSchnorrCase = Gen (Case SchnorrSecp256k1DSIGN ByteString)
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => m a -> m a
Gen.prune (Gen (Case SchnorrSecp256k1DSIGN ByteString)
 -> Gen (Case SchnorrSecp256k1DSIGN ByteString))
-> ([(Int, Gen (Case SchnorrSecp256k1DSIGN ByteString))]
    -> Gen (Case SchnorrSecp256k1DSIGN ByteString))
-> [(Int, Gen (Case SchnorrSecp256k1DSIGN ByteString))]
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Int, Gen (Case SchnorrSecp256k1DSIGN ByteString))]
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency ([(Int, Gen (Case SchnorrSecp256k1DSIGN ByteString))]
 -> Gen (Case SchnorrSecp256k1DSIGN ByteString))
-> [(Int, Gen (Case SchnorrSecp256k1DSIGN ByteString))]
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall a b. (a -> b) -> a -> b
$ [
  (Int
6, AReview
  (Case SchnorrSecp256k1DSIGN ByteString)
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
-> NoErrorCase SchnorrSecp256k1DSIGN ByteString
-> Case SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case SchnorrSecp256k1DSIGN ByteString)
  (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (NoErrorCase SchnorrSecp256k1DSIGN ByteString
 -> Case SchnorrSecp256k1DSIGN ByteString)
-> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NoErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrNoErrorCase),
  (Int
4, AReview
  (Case SchnorrSecp256k1DSIGN ByteString)
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
-> ErrorCase SchnorrSecp256k1DSIGN ByteString
-> Case SchnorrSecp256k1DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case SchnorrSecp256k1DSIGN ByteString)
  (ErrorCase SchnorrSecp256k1DSIGN ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (ErrorCase SchnorrSecp256k1DSIGN ByteString
 -> Case SchnorrSecp256k1DSIGN ByteString)
-> Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
-> Gen (Case SchnorrSecp256k1DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ErrorCase SchnorrSecp256k1DSIGN ByteString)
genSchnorrErrorCase)
  ]

genEd25519Case :: Gen (Case Ed25519DSIGN ByteString)
genEd25519Case :: Gen (Case Ed25519DSIGN ByteString)
genEd25519Case = Gen (Case Ed25519DSIGN ByteString)
-> Gen (Case Ed25519DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => m a -> m a
Gen.prune (Gen (Case Ed25519DSIGN ByteString)
 -> Gen (Case Ed25519DSIGN ByteString))
-> ([(Int, Gen (Case Ed25519DSIGN ByteString))]
    -> Gen (Case Ed25519DSIGN ByteString))
-> [(Int, Gen (Case Ed25519DSIGN ByteString))]
-> Gen (Case Ed25519DSIGN ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Int, Gen (Case Ed25519DSIGN ByteString))]
-> Gen (Case Ed25519DSIGN ByteString)
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency ([(Int, Gen (Case Ed25519DSIGN ByteString))]
 -> Gen (Case Ed25519DSIGN ByteString))
-> [(Int, Gen (Case Ed25519DSIGN ByteString))]
-> Gen (Case Ed25519DSIGN ByteString)
forall a b. (a -> b) -> a -> b
$ [
  (Int
6, AReview
  (Case Ed25519DSIGN ByteString)
  (NoErrorCase Ed25519DSIGN ByteString)
-> NoErrorCase Ed25519DSIGN ByteString
-> Case Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case Ed25519DSIGN ByteString)
  (NoErrorCase Ed25519DSIGN ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (NoErrorCase a msg) (f (NoErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_Shouldn'tError (NoErrorCase Ed25519DSIGN ByteString
 -> Case Ed25519DSIGN ByteString)
-> Gen (NoErrorCase Ed25519DSIGN ByteString)
-> Gen (Case Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (NoErrorCase Ed25519DSIGN ByteString)
genEd25519NoErrorCase),
  (Int
4, AReview
  (Case Ed25519DSIGN ByteString) (ErrorCase Ed25519DSIGN ByteString)
-> ErrorCase Ed25519DSIGN ByteString
-> Case Ed25519DSIGN ByteString
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview
  (Case Ed25519DSIGN ByteString) (ErrorCase Ed25519DSIGN ByteString)
forall a msg (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (ErrorCase a msg) (f (ErrorCase a msg))
-> p (Case a msg) (f (Case a msg))
_ShouldError (ErrorCase Ed25519DSIGN ByteString -> Case Ed25519DSIGN ByteString)
-> Gen (ErrorCase Ed25519DSIGN ByteString)
-> Gen (Case Ed25519DSIGN ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ErrorCase Ed25519DSIGN ByteString)
genEd25519ErrorCase)
  ]

mkWrongKeyBits :: forall (a :: Type) (msg :: Type) .
  (DSIGNAlgorithm a, ContextDSIGN a ~ (), Signable a msg) =>
  SignKeyDSIGN a ->
  VerKeyDSIGN a ->
  msg ->
  Gen (VerKeyDSIGN a, msg, SigDSIGN a)
mkWrongKeyBits :: forall a msg.
(DSIGNAlgorithm a, ContextDSIGN a ~ (), Signable a msg) =>
SignKeyDSIGN a
-> VerKeyDSIGN a -> msg -> Gen (VerKeyDSIGN a, msg, SigDSIGN a)
mkWrongKeyBits SignKeyDSIGN a
sk VerKeyDSIGN a
vk msg
msg = do
  VerKeyDSIGN a
vkBad <- (VerKeyDSIGN a -> Bool)
-> GenT Identity (VerKeyDSIGN a) -> GenT Identity (VerKeyDSIGN a)
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (VerKeyDSIGN a -> VerKeyDSIGN a -> Bool
forall a. Eq a => a -> a -> Bool
/= VerKeyDSIGN a
vk) GenT Identity (VerKeyDSIGN a)
forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey
  (VerKeyDSIGN a, msg, SigDSIGN a)
-> Gen (VerKeyDSIGN a, msg, SigDSIGN a)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VerKeyDSIGN a
vkBad, msg
msg, ContextDSIGN a -> msg -> SignKeyDSIGN a -> SigDSIGN a
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable a a, HasCallStack) =>
ContextDSIGN a -> a -> SignKeyDSIGN a -> SigDSIGN a
signDSIGN () msg
msg SignKeyDSIGN a
sk)

genBadVerKey :: forall (a :: Type) .
  (DSIGNAlgorithm a) => Gen ByteString
genBadVerKey :: forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadVerKey = (ByteString -> Bool)
-> GenT Identity ByteString -> GenT Identity ByteString
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (Maybe (VerKeyDSIGN a) -> Bool
forall a. Maybe a -> Bool
isNothing (Maybe (VerKeyDSIGN a) -> Bool)
-> (ByteString -> Maybe (VerKeyDSIGN a)) -> ByteString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. DSIGNAlgorithm v => ByteString -> Maybe (VerKeyDSIGN v)
rawDeserialiseVerKeyDSIGN @a)
                          (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64)

genEcdsaMsg :: Gen MessageHash
genEcdsaMsg :: GenT Identity MessageHash
genEcdsaMsg = (ByteString -> Maybe MessageHash)
-> GenT Identity ByteString -> GenT Identity MessageHash
forall (m :: * -> *) a b.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Maybe b) -> m a -> m b
Gen.mapMaybe ByteString -> Maybe MessageHash
toMessageHash (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Range Int
forall a. a -> Range a
Range.singleton (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
32)

genEcdsaSig :: Gen (SigDSIGN EcdsaSecp256k1DSIGN)
genEcdsaSig :: GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
genEcdsaSig = do
  SignKeyDSIGN EcdsaSecp256k1DSIGN
sk <- Gen (SignKeyDSIGN EcdsaSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  MessageHash
msg <- GenT Identity MessageHash
genEcdsaMsg
  SigDSIGN EcdsaSecp256k1DSIGN
-> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SigDSIGN EcdsaSecp256k1DSIGN
 -> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN))
-> (SignKeyDSIGN EcdsaSecp256k1DSIGN
    -> SigDSIGN EcdsaSecp256k1DSIGN)
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextDSIGN EcdsaSecp256k1DSIGN
-> MessageHash
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable EcdsaSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN EcdsaSecp256k1DSIGN
-> a
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> SigDSIGN EcdsaSecp256k1DSIGN
signDSIGN () MessageHash
msg (SignKeyDSIGN EcdsaSecp256k1DSIGN
 -> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN))
-> SignKeyDSIGN EcdsaSecp256k1DSIGN
-> GenT Identity (SigDSIGN EcdsaSecp256k1DSIGN)
forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN EcdsaSecp256k1DSIGN
sk

genSchnorrSig :: Gen (SigDSIGN SchnorrSecp256k1DSIGN)
genSchnorrSig :: GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
genSchnorrSig = do
  SignKeyDSIGN SchnorrSecp256k1DSIGN
sk <- Gen (SignKeyDSIGN SchnorrSecp256k1DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  ByteString
msg <- Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64
  SigDSIGN SchnorrSecp256k1DSIGN
-> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SigDSIGN SchnorrSecp256k1DSIGN
 -> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN))
-> (SignKeyDSIGN SchnorrSecp256k1DSIGN
    -> SigDSIGN SchnorrSecp256k1DSIGN)
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextDSIGN SchnorrSecp256k1DSIGN
-> ByteString
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable SchnorrSecp256k1DSIGN a, HasCallStack) =>
ContextDSIGN SchnorrSecp256k1DSIGN
-> a
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> SigDSIGN SchnorrSecp256k1DSIGN
signDSIGN () ByteString
msg (SignKeyDSIGN SchnorrSecp256k1DSIGN
 -> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN))
-> SignKeyDSIGN SchnorrSecp256k1DSIGN
-> GenT Identity (SigDSIGN SchnorrSecp256k1DSIGN)
forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN SchnorrSecp256k1DSIGN
sk

genEd25519Sig :: Gen (SigDSIGN Ed25519DSIGN)
genEd25519Sig :: GenT Identity (SigDSIGN Ed25519DSIGN)
genEd25519Sig = do
  SignKeyDSIGN Ed25519DSIGN
sk <- Gen (SignKeyDSIGN Ed25519DSIGN)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey
  ByteString
msg <- Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64
  SigDSIGN Ed25519DSIGN -> GenT Identity (SigDSIGN Ed25519DSIGN)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SigDSIGN Ed25519DSIGN -> GenT Identity (SigDSIGN Ed25519DSIGN))
-> (SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN)
-> SignKeyDSIGN Ed25519DSIGN
-> GenT Identity (SigDSIGN Ed25519DSIGN)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextDSIGN Ed25519DSIGN
-> ByteString -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
forall v a.
(DSIGNAlgorithm v, Signable v a, HasCallStack) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SigDSIGN v
forall a.
(Signable Ed25519DSIGN a, HasCallStack) =>
ContextDSIGN Ed25519DSIGN
-> a -> SignKeyDSIGN Ed25519DSIGN -> SigDSIGN Ed25519DSIGN
signDSIGN () ByteString
msg (SignKeyDSIGN Ed25519DSIGN
 -> GenT Identity (SigDSIGN Ed25519DSIGN))
-> SignKeyDSIGN Ed25519DSIGN
-> GenT Identity (SigDSIGN Ed25519DSIGN)
forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN Ed25519DSIGN
sk

genVerKey :: forall (a :: Type) . (DSIGNAlgorithm a) => Gen (VerKeyDSIGN a)
genVerKey :: forall a. DSIGNAlgorithm a => Gen (VerKeyDSIGN a)
genVerKey = SignKeyDSIGN a -> VerKeyDSIGN a
forall v. DSIGNAlgorithm v => SignKeyDSIGN v -> VerKeyDSIGN v
deriveVerKeyDSIGN (SignKeyDSIGN a -> VerKeyDSIGN a)
-> GenT Identity (SignKeyDSIGN a) -> GenT Identity (VerKeyDSIGN a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (SignKeyDSIGN a)
forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey

genBadEcdsaMsg :: Gen ByteString
genBadEcdsaMsg :: GenT Identity ByteString
genBadEcdsaMsg = (ByteString -> Bool)
-> GenT Identity ByteString -> GenT Identity ByteString
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (Maybe MessageHash -> Bool
forall a. Maybe a -> Bool
isNothing (Maybe MessageHash -> Bool)
-> (ByteString -> Maybe MessageHash) -> ByteString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Maybe MessageHash
toMessageHash) (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64)

genBadSig :: forall (a :: Type) . (DSIGNAlgorithm a) => Gen ByteString
genBadSig :: forall a. DSIGNAlgorithm a => GenT Identity ByteString
genBadSig = (ByteString -> Bool)
-> GenT Identity ByteString -> GenT Identity ByteString
forall (m :: * -> *) a.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Bool) -> m a -> m a
Gen.filter (Maybe (SigDSIGN a) -> Bool
forall a. Maybe a -> Bool
isNothing (Maybe (SigDSIGN a) -> Bool)
-> (ByteString -> Maybe (SigDSIGN a)) -> ByteString -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. DSIGNAlgorithm v => ByteString -> Maybe (SigDSIGN v)
rawDeserialiseSigDSIGN @a)
                       (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
64)

genSignKey :: forall (a :: Type) . (DSIGNAlgorithm a) => Gen (SignKeyDSIGN a)
genSignKey :: forall a. DSIGNAlgorithm a => Gen (SignKeyDSIGN a)
genSignKey = do
  Seed
seed <- ByteString -> Seed
mkSeedFromBytes (ByteString -> Seed)
-> GenT Identity ByteString -> GenT Identity Seed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Range Int -> GenT Identity ByteString)
-> (Int -> Range Int) -> Int -> GenT Identity ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
64 (Int -> GenT Identity ByteString)
-> Int -> GenT Identity ByteString
forall a b. (a -> b) -> a -> b
$ Int
128)
  SignKeyDSIGN a -> Gen (SignKeyDSIGN a)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SignKeyDSIGN a -> Gen (SignKeyDSIGN a))
-> (Seed -> SignKeyDSIGN a) -> Seed -> Gen (SignKeyDSIGN a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seed -> SignKeyDSIGN a
forall v. DSIGNAlgorithm v => Seed -> SignKeyDSIGN v
genKeyDSIGN (Seed -> Gen (SignKeyDSIGN a)) -> Seed -> Gen (SignKeyDSIGN a)
forall a b. (a -> b) -> a -> b
$ Seed
seed