{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}

-- | Praos consensus key types and their 'Key' class instances
--
module Cardano.Api.Keys.Praos (

    -- * Key types
    KesKey,
    VrfKey,

    -- * Data family instances
    AsType(..),
    Hash(..),
    VerificationKey(..),
    SigningKey(..),

    -- * Signing
    signArbitraryBytesKes,
  ) where

import           Data.ByteString (ByteString)
import           Data.Either.Combinators (maybeToRight)
import           Data.String (IsString (..))

import qualified Cardano.Crypto.DSIGN.Class as Crypto
import qualified Cardano.Crypto.Hash.Class as Crypto
import qualified Cardano.Crypto.KES.Class as Crypto
import qualified Cardano.Crypto.VRF.Class as Crypto
import           Cardano.Ledger.Crypto (StandardCrypto)
import qualified Cardano.Ledger.Crypto as Shelley (KES, VRF)
import qualified Cardano.Ledger.Keys as Shelley

import           Cardano.Api.Hash
import           Cardano.Api.HasTypeProxy
import           Cardano.Api.Keys.Class
import           Cardano.Api.SerialiseBech32
import           Cardano.Api.SerialiseCBOR
import           Cardano.Api.SerialiseRaw
import           Cardano.Api.SerialiseTextEnvelope
import           Cardano.Api.SerialiseUsing

--
-- KES keys
--

data KesKey

instance HasTypeProxy KesKey where
    data AsType KesKey = AsKesKey
    proxyToAsType :: Proxy KesKey -> AsType KesKey
proxyToAsType Proxy KesKey
_ = AsType KesKey
AsKesKey

instance Key KesKey where

    newtype VerificationKey KesKey =
        KesVerificationKey (Shelley.VerKeyKES StandardCrypto)
      deriving stock (VerificationKey KesKey -> VerificationKey KesKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerificationKey KesKey -> VerificationKey KesKey -> Bool
$c/= :: VerificationKey KesKey -> VerificationKey KesKey -> Bool
== :: VerificationKey KesKey -> VerificationKey KesKey -> Bool
$c== :: VerificationKey KesKey -> VerificationKey KesKey -> Bool
Eq)
      deriving (Int -> VerificationKey KesKey -> ShowS
[VerificationKey KesKey] -> ShowS
VerificationKey KesKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerificationKey KesKey] -> ShowS
$cshowList :: [VerificationKey KesKey] -> ShowS
show :: VerificationKey KesKey -> String
$cshow :: VerificationKey KesKey -> String
showsPrec :: Int -> VerificationKey KesKey -> ShowS
$cshowsPrec :: Int -> VerificationKey KesKey -> ShowS
Show, String -> VerificationKey KesKey
forall a. (String -> a) -> IsString a
fromString :: String -> VerificationKey KesKey
$cfromString :: String -> VerificationKey KesKey
IsString) via UsingRawBytesHex (VerificationKey KesKey)
      deriving newtype (Typeable (VerificationKey KesKey)
VerificationKey KesKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey KesKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey KesKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey KesKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey KesKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey KesKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey KesKey) -> Size
toCBOR :: VerificationKey KesKey -> Encoding
$ctoCBOR :: VerificationKey KesKey -> Encoding
ToCBOR, Typeable (VerificationKey KesKey)
Proxy (VerificationKey KesKey) -> Text
forall s. Decoder s (VerificationKey KesKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (VerificationKey KesKey) -> Text
$clabel :: Proxy (VerificationKey KesKey) -> Text
fromCBOR :: forall s. Decoder s (VerificationKey KesKey)
$cfromCBOR :: forall s. Decoder s (VerificationKey KesKey)
FromCBOR)
      deriving anyclass HasTypeProxy (VerificationKey KesKey)
AsType (VerificationKey KesKey)
-> ByteString -> Either DecoderError (VerificationKey KesKey)
VerificationKey KesKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (VerificationKey KesKey)
-> ByteString -> Either DecoderError (VerificationKey KesKey)
$cdeserialiseFromCBOR :: AsType (VerificationKey KesKey)
-> ByteString -> Either DecoderError (VerificationKey KesKey)
serialiseToCBOR :: VerificationKey KesKey -> ByteString
$cserialiseToCBOR :: VerificationKey KesKey -> ByteString
SerialiseAsCBOR

    newtype SigningKey KesKey =
        KesSigningKey (Shelley.SignKeyKES StandardCrypto)
      deriving (Int -> SigningKey KesKey -> ShowS
[SigningKey KesKey] -> ShowS
SigningKey KesKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SigningKey KesKey] -> ShowS
$cshowList :: [SigningKey KesKey] -> ShowS
show :: SigningKey KesKey -> String
$cshow :: SigningKey KesKey -> String
showsPrec :: Int -> SigningKey KesKey -> ShowS
$cshowsPrec :: Int -> SigningKey KesKey -> ShowS
Show, String -> SigningKey KesKey
forall a. (String -> a) -> IsString a
fromString :: String -> SigningKey KesKey
$cfromString :: String -> SigningKey KesKey
IsString) via UsingRawBytesHex (SigningKey KesKey)
      deriving newtype (Typeable (SigningKey KesKey)
SigningKey KesKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey KesKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey KesKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey KesKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey KesKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey KesKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey KesKey) -> Size
toCBOR :: SigningKey KesKey -> Encoding
$ctoCBOR :: SigningKey KesKey -> Encoding
ToCBOR, Typeable (SigningKey KesKey)
Proxy (SigningKey KesKey) -> Text
forall s. Decoder s (SigningKey KesKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (SigningKey KesKey) -> Text
$clabel :: Proxy (SigningKey KesKey) -> Text
fromCBOR :: forall s. Decoder s (SigningKey KesKey)
$cfromCBOR :: forall s. Decoder s (SigningKey KesKey)
FromCBOR)
      deriving anyclass HasTypeProxy (SigningKey KesKey)
AsType (SigningKey KesKey)
-> ByteString -> Either DecoderError (SigningKey KesKey)
SigningKey KesKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (SigningKey KesKey)
-> ByteString -> Either DecoderError (SigningKey KesKey)
$cdeserialiseFromCBOR :: AsType (SigningKey KesKey)
-> ByteString -> Either DecoderError (SigningKey KesKey)
serialiseToCBOR :: SigningKey KesKey -> ByteString
$cserialiseToCBOR :: SigningKey KesKey -> ByteString
SerialiseAsCBOR

    --This loses the mlock safety of the seed, since it starts from a normal in-memory seed.
    deterministicSigningKey :: AsType KesKey -> Crypto.Seed -> SigningKey KesKey
    deterministicSigningKey :: AsType KesKey -> Seed -> SigningKey KesKey
deterministicSigningKey AsType KesKey
R:AsTypeKesKey
AsKesKey =
        SignKeyKES StandardCrypto -> SigningKey KesKey
KesSigningKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. KESAlgorithm v => Seed -> SignKeyKES v
Crypto.genKeyKES

    deterministicSigningKeySeedSize :: AsType KesKey -> Word
    deterministicSigningKeySeedSize :: AsType KesKey -> Word
deterministicSigningKeySeedSize AsType KesKey
R:AsTypeKesKey
AsKesKey =
        forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> Word
Crypto.seedSizeKES Proxy (KES StandardCrypto)
proxy
      where
        proxy :: Proxy (Shelley.KES StandardCrypto)
        proxy :: Proxy (KES StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy

    getVerificationKey :: SigningKey KesKey -> VerificationKey KesKey
    getVerificationKey :: SigningKey KesKey -> VerificationKey KesKey
getVerificationKey (KesSigningKey SignKeyKES StandardCrypto
sk) =
        VerKeyKES StandardCrypto -> VerificationKey KesKey
KesVerificationKey (forall v. KESAlgorithm v => SignKeyKES v -> VerKeyKES v
Crypto.deriveVerKeyKES SignKeyKES StandardCrypto
sk)

    verificationKeyHash :: VerificationKey KesKey -> Hash KesKey
    verificationKeyHash :: VerificationKey KesKey -> Hash KesKey
verificationKeyHash (KesVerificationKey VerKeyKES StandardCrypto
vkey) =
        Hash StandardCrypto (VerKeyKES StandardCrypto) -> Hash KesKey
KesKeyHash (forall v h.
(KESAlgorithm v, HashAlgorithm h) =>
VerKeyKES v -> Hash h (VerKeyKES v)
Crypto.hashVerKeyKES VerKeyKES StandardCrypto
vkey)


instance SerialiseAsRawBytes (VerificationKey KesKey) where
    serialiseToRawBytes :: VerificationKey KesKey -> ByteString
serialiseToRawBytes (KesVerificationKey VerKeyKES StandardCrypto
vk) =
      forall v. KESAlgorithm v => VerKeyKES v -> ByteString
Crypto.rawSerialiseVerKeyKES VerKeyKES StandardCrypto
vk

    deserialiseFromRawBytes :: AsType (VerificationKey KesKey)
-> ByteString
-> Either SerialiseAsRawBytesError (VerificationKey KesKey)
deserialiseFromRawBytes (AsVerificationKey AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise VerificationKey KesKey") forall a b. (a -> b) -> a -> b
$
        VerKeyKES StandardCrypto -> VerificationKey KesKey
KesVerificationKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. KESAlgorithm v => ByteString -> Maybe (VerKeyKES v)
Crypto.rawDeserialiseVerKeyKES ByteString
bs

instance SerialiseAsRawBytes (SigningKey KesKey) where
    serialiseToRawBytes :: SigningKey KesKey -> ByteString
serialiseToRawBytes (KesSigningKey SignKeyKES StandardCrypto
sk) =
      forall v. KESAlgorithm v => SignKeyKES v -> ByteString
Crypto.rawSerialiseSignKeyKES SignKeyKES StandardCrypto
sk

    deserialiseFromRawBytes :: AsType (SigningKey KesKey)
-> ByteString
-> Either SerialiseAsRawBytesError (SigningKey KesKey)
deserialiseFromRawBytes (AsSigningKey AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise SigningKey KesKey") forall a b. (a -> b) -> a -> b
$
        SignKeyKES StandardCrypto -> SigningKey KesKey
KesSigningKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. KESAlgorithm v => ByteString -> Maybe (SignKeyKES v)
Crypto.rawDeserialiseSignKeyKES ByteString
bs

instance SerialiseAsBech32 (VerificationKey KesKey) where
    bech32PrefixFor :: VerificationKey KesKey -> Text
bech32PrefixFor         VerificationKey KesKey
_ =  Text
"kes_vk"
    bech32PrefixesPermitted :: AsType (VerificationKey KesKey) -> [Text]
bech32PrefixesPermitted AsType (VerificationKey KesKey)
_ = [Text
"kes_vk"]

instance SerialiseAsBech32 (SigningKey KesKey) where
    bech32PrefixFor :: SigningKey KesKey -> Text
bech32PrefixFor         SigningKey KesKey
_ =  Text
"kes_sk"
    bech32PrefixesPermitted :: AsType (SigningKey KesKey) -> [Text]
bech32PrefixesPermitted AsType (SigningKey KesKey)
_ = [Text
"kes_sk"]


newtype instance Hash KesKey =
    KesKeyHash (Shelley.Hash StandardCrypto
                             (Shelley.VerKeyKES StandardCrypto))
  deriving stock (Hash KesKey -> Hash KesKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hash KesKey -> Hash KesKey -> Bool
$c/= :: Hash KesKey -> Hash KesKey -> Bool
== :: Hash KesKey -> Hash KesKey -> Bool
$c== :: Hash KesKey -> Hash KesKey -> Bool
Eq, Eq (Hash KesKey)
Hash KesKey -> Hash KesKey -> Bool
Hash KesKey -> Hash KesKey -> Ordering
Hash KesKey -> Hash KesKey -> Hash KesKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Hash KesKey -> Hash KesKey -> Hash KesKey
$cmin :: Hash KesKey -> Hash KesKey -> Hash KesKey
max :: Hash KesKey -> Hash KesKey -> Hash KesKey
$cmax :: Hash KesKey -> Hash KesKey -> Hash KesKey
>= :: Hash KesKey -> Hash KesKey -> Bool
$c>= :: Hash KesKey -> Hash KesKey -> Bool
> :: Hash KesKey -> Hash KesKey -> Bool
$c> :: Hash KesKey -> Hash KesKey -> Bool
<= :: Hash KesKey -> Hash KesKey -> Bool
$c<= :: Hash KesKey -> Hash KesKey -> Bool
< :: Hash KesKey -> Hash KesKey -> Bool
$c< :: Hash KesKey -> Hash KesKey -> Bool
compare :: Hash KesKey -> Hash KesKey -> Ordering
$ccompare :: Hash KesKey -> Hash KesKey -> Ordering
Ord)
  deriving (Int -> Hash KesKey -> ShowS
[Hash KesKey] -> ShowS
Hash KesKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Hash KesKey] -> ShowS
$cshowList :: [Hash KesKey] -> ShowS
show :: Hash KesKey -> String
$cshow :: Hash KesKey -> String
showsPrec :: Int -> Hash KesKey -> ShowS
$cshowsPrec :: Int -> Hash KesKey -> ShowS
Show, String -> Hash KesKey
forall a. (String -> a) -> IsString a
fromString :: String -> Hash KesKey
$cfromString :: String -> Hash KesKey
IsString) via UsingRawBytesHex (Hash KesKey)
  deriving (Typeable (Hash KesKey)
Hash KesKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash KesKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash KesKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash KesKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash KesKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash KesKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash KesKey) -> Size
toCBOR :: Hash KesKey -> Encoding
$ctoCBOR :: Hash KesKey -> Encoding
ToCBOR, Typeable (Hash KesKey)
Proxy (Hash KesKey) -> Text
forall s. Decoder s (Hash KesKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (Hash KesKey) -> Text
$clabel :: Proxy (Hash KesKey) -> Text
fromCBOR :: forall s. Decoder s (Hash KesKey)
$cfromCBOR :: forall s. Decoder s (Hash KesKey)
FromCBOR) via UsingRawBytes (Hash KesKey)
  deriving anyclass HasTypeProxy (Hash KesKey)
AsType (Hash KesKey)
-> ByteString -> Either DecoderError (Hash KesKey)
Hash KesKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (Hash KesKey)
-> ByteString -> Either DecoderError (Hash KesKey)
$cdeserialiseFromCBOR :: AsType (Hash KesKey)
-> ByteString -> Either DecoderError (Hash KesKey)
serialiseToCBOR :: Hash KesKey -> ByteString
$cserialiseToCBOR :: Hash KesKey -> ByteString
SerialiseAsCBOR

instance SerialiseAsRawBytes (Hash KesKey) where
    serialiseToRawBytes :: Hash KesKey -> ByteString
serialiseToRawBytes (KesKeyHash Hash StandardCrypto (VerKeyKES StandardCrypto)
vkh) =
      forall h a. Hash h a -> ByteString
Crypto.hashToBytes Hash StandardCrypto (VerKeyKES StandardCrypto)
vkh

    deserialiseFromRawBytes :: AsType (Hash KesKey)
-> ByteString -> Either SerialiseAsRawBytesError (Hash KesKey)
deserialiseFromRawBytes (AsHash AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise Hash KesKey") forall a b. (a -> b) -> a -> b
$
        Hash StandardCrypto (VerKeyKES StandardCrypto) -> Hash KesKey
KesKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall h a. HashAlgorithm h => ByteString -> Maybe (Hash h a)
Crypto.hashFromBytes ByteString
bs

instance HasTextEnvelope (VerificationKey KesKey) where
    textEnvelopeType :: AsType (VerificationKey KesKey) -> TextEnvelopeType
textEnvelopeType AsType (VerificationKey KesKey)
_ = TextEnvelopeType
"KesVerificationKey_"
                      forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString (forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> String
Crypto.algorithmNameKES Proxy (KES StandardCrypto)
proxy)
      where
        proxy :: Proxy (Shelley.KES StandardCrypto)
        proxy :: Proxy (KES StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy

instance HasTextEnvelope (SigningKey KesKey) where
    textEnvelopeType :: AsType (SigningKey KesKey) -> TextEnvelopeType
textEnvelopeType AsType (SigningKey KesKey)
_ = TextEnvelopeType
"KesSigningKey_"
                      forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString (forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> String
Crypto.algorithmNameKES Proxy (KES StandardCrypto)
proxy)
      where
        proxy :: Proxy (Shelley.KES StandardCrypto)
        proxy :: Proxy (KES StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy

signArbitraryBytesKes
  :: SigningKey KesKey
  -> Crypto.Period -- ^ Desired Kes period
  -> ByteString    -- ^ Message to sign
  -> Crypto.SignedKES (Shelley.KES StandardCrypto) ByteString
signArbitraryBytesKes :: SigningKey KesKey
-> Word -> ByteString -> SignedKES (KES StandardCrypto) ByteString
signArbitraryBytesKes (KesSigningKey SignKeyKES StandardCrypto
kesKey) Word
period ByteString
message =
  forall v a.
(KESAlgorithm v, Signable v a) =>
ContextKES v -> Word -> a -> SignKeyKES v -> SignedKES v a
Crypto.signedKES @(Shelley.KES StandardCrypto) () Word
period ByteString
message SignKeyKES StandardCrypto
kesKey

--
-- VRF keys
--

data VrfKey

instance HasTypeProxy VrfKey where
    data AsType VrfKey = AsVrfKey
    proxyToAsType :: Proxy VrfKey -> AsType VrfKey
proxyToAsType Proxy VrfKey
_ = AsType VrfKey
AsVrfKey

instance Key VrfKey where

    newtype VerificationKey VrfKey =
        VrfVerificationKey (Shelley.VerKeyVRF StandardCrypto)
      deriving stock (VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
$c/= :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
== :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
$c== :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
Eq)
      deriving (Int -> VerificationKey VrfKey -> ShowS
[VerificationKey VrfKey] -> ShowS
VerificationKey VrfKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerificationKey VrfKey] -> ShowS
$cshowList :: [VerificationKey VrfKey] -> ShowS
show :: VerificationKey VrfKey -> String
$cshow :: VerificationKey VrfKey -> String
showsPrec :: Int -> VerificationKey VrfKey -> ShowS
$cshowsPrec :: Int -> VerificationKey VrfKey -> ShowS
Show, String -> VerificationKey VrfKey
forall a. (String -> a) -> IsString a
fromString :: String -> VerificationKey VrfKey
$cfromString :: String -> VerificationKey VrfKey
IsString) via UsingRawBytesHex (VerificationKey VrfKey)
      deriving newtype (Typeable (VerificationKey VrfKey)
VerificationKey VrfKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey VrfKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey VrfKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey VrfKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey VrfKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey VrfKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey VrfKey) -> Size
toCBOR :: VerificationKey VrfKey -> Encoding
$ctoCBOR :: VerificationKey VrfKey -> Encoding
ToCBOR, Typeable (VerificationKey VrfKey)
Proxy (VerificationKey VrfKey) -> Text
forall s. Decoder s (VerificationKey VrfKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (VerificationKey VrfKey) -> Text
$clabel :: Proxy (VerificationKey VrfKey) -> Text
fromCBOR :: forall s. Decoder s (VerificationKey VrfKey)
$cfromCBOR :: forall s. Decoder s (VerificationKey VrfKey)
FromCBOR)
      deriving anyclass HasTypeProxy (VerificationKey VrfKey)
AsType (VerificationKey VrfKey)
-> ByteString -> Either DecoderError (VerificationKey VrfKey)
VerificationKey VrfKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (VerificationKey VrfKey)
-> ByteString -> Either DecoderError (VerificationKey VrfKey)
$cdeserialiseFromCBOR :: AsType (VerificationKey VrfKey)
-> ByteString -> Either DecoderError (VerificationKey VrfKey)
serialiseToCBOR :: VerificationKey VrfKey -> ByteString
$cserialiseToCBOR :: VerificationKey VrfKey -> ByteString
SerialiseAsCBOR

    newtype SigningKey VrfKey =
        VrfSigningKey (Shelley.SignKeyVRF StandardCrypto)
      deriving (Int -> SigningKey VrfKey -> ShowS
[SigningKey VrfKey] -> ShowS
SigningKey VrfKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SigningKey VrfKey] -> ShowS
$cshowList :: [SigningKey VrfKey] -> ShowS
show :: SigningKey VrfKey -> String
$cshow :: SigningKey VrfKey -> String
showsPrec :: Int -> SigningKey VrfKey -> ShowS
$cshowsPrec :: Int -> SigningKey VrfKey -> ShowS
Show, String -> SigningKey VrfKey
forall a. (String -> a) -> IsString a
fromString :: String -> SigningKey VrfKey
$cfromString :: String -> SigningKey VrfKey
IsString) via UsingRawBytesHex (SigningKey VrfKey)
      deriving newtype (Typeable (SigningKey VrfKey)
SigningKey VrfKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey VrfKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey VrfKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey VrfKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey VrfKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey VrfKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey VrfKey) -> Size
toCBOR :: SigningKey VrfKey -> Encoding
$ctoCBOR :: SigningKey VrfKey -> Encoding
ToCBOR, Typeable (SigningKey VrfKey)
Proxy (SigningKey VrfKey) -> Text
forall s. Decoder s (SigningKey VrfKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (SigningKey VrfKey) -> Text
$clabel :: Proxy (SigningKey VrfKey) -> Text
fromCBOR :: forall s. Decoder s (SigningKey VrfKey)
$cfromCBOR :: forall s. Decoder s (SigningKey VrfKey)
FromCBOR)
      deriving anyclass HasTypeProxy (SigningKey VrfKey)
AsType (SigningKey VrfKey)
-> ByteString -> Either DecoderError (SigningKey VrfKey)
SigningKey VrfKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (SigningKey VrfKey)
-> ByteString -> Either DecoderError (SigningKey VrfKey)
$cdeserialiseFromCBOR :: AsType (SigningKey VrfKey)
-> ByteString -> Either DecoderError (SigningKey VrfKey)
serialiseToCBOR :: SigningKey VrfKey -> ByteString
$cserialiseToCBOR :: SigningKey VrfKey -> ByteString
SerialiseAsCBOR

    deterministicSigningKey :: AsType VrfKey -> Crypto.Seed -> SigningKey VrfKey
    deterministicSigningKey :: AsType VrfKey -> Seed -> SigningKey VrfKey
deterministicSigningKey AsType VrfKey
R:AsTypeVrfKey
AsVrfKey Seed
seed =
        SignKeyVRF StandardCrypto -> SigningKey VrfKey
VrfSigningKey (forall v. VRFAlgorithm v => Seed -> SignKeyVRF v
Crypto.genKeyVRF Seed
seed)

    deterministicSigningKeySeedSize :: AsType VrfKey -> Word
    deterministicSigningKeySeedSize :: AsType VrfKey -> Word
deterministicSigningKeySeedSize AsType VrfKey
R:AsTypeVrfKey
AsVrfKey =
        forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> Word
Crypto.seedSizeVRF Proxy (VRF StandardCrypto)
proxy
      where
        proxy :: Proxy (Shelley.VRF StandardCrypto)
        proxy :: Proxy (VRF StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy

    getVerificationKey :: SigningKey VrfKey -> VerificationKey VrfKey
    getVerificationKey :: SigningKey VrfKey -> VerificationKey VrfKey
getVerificationKey (VrfSigningKey SignKeyVRF StandardCrypto
sk) =
        VerKeyVRF StandardCrypto -> VerificationKey VrfKey
VrfVerificationKey (forall v. VRFAlgorithm v => SignKeyVRF v -> VerKeyVRF v
Crypto.deriveVerKeyVRF SignKeyVRF StandardCrypto
sk)

    verificationKeyHash :: VerificationKey VrfKey -> Hash VrfKey
    verificationKeyHash :: VerificationKey VrfKey -> Hash VrfKey
verificationKeyHash (VrfVerificationKey VerKeyVRF StandardCrypto
vkey) =
        Hash StandardCrypto (VerKeyVRF StandardCrypto) -> Hash VrfKey
VrfKeyHash (forall v h.
(VRFAlgorithm v, HashAlgorithm h) =>
VerKeyVRF v -> Hash h (VerKeyVRF v)
Shelley.hashVerKeyVRF VerKeyVRF StandardCrypto
vkey)

instance SerialiseAsRawBytes (VerificationKey VrfKey) where
    serialiseToRawBytes :: VerificationKey VrfKey -> ByteString
serialiseToRawBytes (VrfVerificationKey VerKeyVRF StandardCrypto
vk) =
      forall v. VRFAlgorithm v => VerKeyVRF v -> ByteString
Crypto.rawSerialiseVerKeyVRF VerKeyVRF StandardCrypto
vk

    deserialiseFromRawBytes :: AsType (VerificationKey VrfKey)
-> ByteString
-> Either SerialiseAsRawBytesError (VerificationKey VrfKey)
deserialiseFromRawBytes (AsVerificationKey AsType VrfKey
R:AsTypeVrfKey
AsVrfKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise VerificationKey VrfKey") forall a b. (a -> b) -> a -> b
$
        VerKeyVRF StandardCrypto -> VerificationKey VrfKey
VrfVerificationKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. VRFAlgorithm v => ByteString -> Maybe (VerKeyVRF v)
Crypto.rawDeserialiseVerKeyVRF ByteString
bs

instance SerialiseAsRawBytes (SigningKey VrfKey) where
    serialiseToRawBytes :: SigningKey VrfKey -> ByteString
serialiseToRawBytes (VrfSigningKey SignKeyVRF StandardCrypto
sk) =
      forall v. VRFAlgorithm v => SignKeyVRF v -> ByteString
Crypto.rawSerialiseSignKeyVRF SignKeyVRF StandardCrypto
sk

    deserialiseFromRawBytes :: AsType (SigningKey VrfKey)
-> ByteString
-> Either SerialiseAsRawBytesError (SigningKey VrfKey)
deserialiseFromRawBytes (AsSigningKey AsType VrfKey
R:AsTypeVrfKey
AsVrfKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise SigningKey VrfKey") forall a b. (a -> b) -> a -> b
$
        SignKeyVRF StandardCrypto -> SigningKey VrfKey
VrfSigningKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v. VRFAlgorithm v => ByteString -> Maybe (SignKeyVRF v)
Crypto.rawDeserialiseSignKeyVRF ByteString
bs

instance SerialiseAsBech32 (VerificationKey VrfKey) where
    bech32PrefixFor :: VerificationKey VrfKey -> Text
bech32PrefixFor         VerificationKey VrfKey
_ =  Text
"vrf_vk"
    bech32PrefixesPermitted :: AsType (VerificationKey VrfKey) -> [Text]
bech32PrefixesPermitted AsType (VerificationKey VrfKey)
_ = [Text
"vrf_vk"]

instance SerialiseAsBech32 (SigningKey VrfKey) where
    bech32PrefixFor :: SigningKey VrfKey -> Text
bech32PrefixFor         SigningKey VrfKey
_ =  Text
"vrf_sk"
    bech32PrefixesPermitted :: AsType (SigningKey VrfKey) -> [Text]
bech32PrefixesPermitted AsType (SigningKey VrfKey)
_ = [Text
"vrf_sk"]

newtype instance Hash VrfKey =
    VrfKeyHash (Shelley.Hash StandardCrypto
                             (Shelley.VerKeyVRF StandardCrypto))
  deriving stock (Hash VrfKey -> Hash VrfKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hash VrfKey -> Hash VrfKey -> Bool
$c/= :: Hash VrfKey -> Hash VrfKey -> Bool
== :: Hash VrfKey -> Hash VrfKey -> Bool
$c== :: Hash VrfKey -> Hash VrfKey -> Bool
Eq, Eq (Hash VrfKey)
Hash VrfKey -> Hash VrfKey -> Bool
Hash VrfKey -> Hash VrfKey -> Ordering
Hash VrfKey -> Hash VrfKey -> Hash VrfKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
$cmin :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
max :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
$cmax :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
>= :: Hash VrfKey -> Hash VrfKey -> Bool
$c>= :: Hash VrfKey -> Hash VrfKey -> Bool
> :: Hash VrfKey -> Hash VrfKey -> Bool
$c> :: Hash VrfKey -> Hash VrfKey -> Bool
<= :: Hash VrfKey -> Hash VrfKey -> Bool
$c<= :: Hash VrfKey -> Hash VrfKey -> Bool
< :: Hash VrfKey -> Hash VrfKey -> Bool
$c< :: Hash VrfKey -> Hash VrfKey -> Bool
compare :: Hash VrfKey -> Hash VrfKey -> Ordering
$ccompare :: Hash VrfKey -> Hash VrfKey -> Ordering
Ord)
  deriving (Int -> Hash VrfKey -> ShowS
[Hash VrfKey] -> ShowS
Hash VrfKey -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Hash VrfKey] -> ShowS
$cshowList :: [Hash VrfKey] -> ShowS
show :: Hash VrfKey -> String
$cshow :: Hash VrfKey -> String
showsPrec :: Int -> Hash VrfKey -> ShowS
$cshowsPrec :: Int -> Hash VrfKey -> ShowS
Show, String -> Hash VrfKey
forall a. (String -> a) -> IsString a
fromString :: String -> Hash VrfKey
$cfromString :: String -> Hash VrfKey
IsString) via UsingRawBytesHex (Hash VrfKey)
  deriving (Typeable (Hash VrfKey)
Hash VrfKey -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash VrfKey] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash VrfKey) -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash VrfKey] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash VrfKey] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash VrfKey) -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash VrfKey) -> Size
toCBOR :: Hash VrfKey -> Encoding
$ctoCBOR :: Hash VrfKey -> Encoding
ToCBOR, Typeable (Hash VrfKey)
Proxy (Hash VrfKey) -> Text
forall s. Decoder s (Hash VrfKey)
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy (Hash VrfKey) -> Text
$clabel :: Proxy (Hash VrfKey) -> Text
fromCBOR :: forall s. Decoder s (Hash VrfKey)
$cfromCBOR :: forall s. Decoder s (Hash VrfKey)
FromCBOR) via UsingRawBytes (Hash VrfKey)
  deriving anyclass HasTypeProxy (Hash VrfKey)
AsType (Hash VrfKey)
-> ByteString -> Either DecoderError (Hash VrfKey)
Hash VrfKey -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType (Hash VrfKey)
-> ByteString -> Either DecoderError (Hash VrfKey)
$cdeserialiseFromCBOR :: AsType (Hash VrfKey)
-> ByteString -> Either DecoderError (Hash VrfKey)
serialiseToCBOR :: Hash VrfKey -> ByteString
$cserialiseToCBOR :: Hash VrfKey -> ByteString
SerialiseAsCBOR

instance SerialiseAsRawBytes (Hash VrfKey) where
    serialiseToRawBytes :: Hash VrfKey -> ByteString
serialiseToRawBytes (VrfKeyHash Hash StandardCrypto (VerKeyVRF StandardCrypto)
vkh) =
      forall h a. Hash h a -> ByteString
Crypto.hashToBytes Hash StandardCrypto (VerKeyVRF StandardCrypto)
vkh

    deserialiseFromRawBytes :: AsType (Hash VrfKey)
-> ByteString -> Either SerialiseAsRawBytesError (Hash VrfKey)
deserialiseFromRawBytes (AsHash AsType VrfKey
R:AsTypeVrfKey
AsVrfKey) ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise Hash VrfKey") forall a b. (a -> b) -> a -> b
$
        Hash StandardCrypto (VerKeyVRF StandardCrypto) -> Hash VrfKey
VrfKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall h a. HashAlgorithm h => ByteString -> Maybe (Hash h a)
Crypto.hashFromBytes ByteString
bs

instance HasTextEnvelope (VerificationKey VrfKey) where
    textEnvelopeType :: AsType (VerificationKey VrfKey) -> TextEnvelopeType
textEnvelopeType AsType (VerificationKey VrfKey)
_ = TextEnvelopeType
"VrfVerificationKey_" forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString (forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> String
Crypto.algorithmNameVRF Proxy (VRF StandardCrypto)
proxy)
      where
        proxy :: Proxy (Shelley.VRF StandardCrypto)
        proxy :: Proxy (VRF StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy

instance HasTextEnvelope (SigningKey VrfKey) where
    textEnvelopeType :: AsType (SigningKey VrfKey) -> TextEnvelopeType
textEnvelopeType AsType (SigningKey VrfKey)
_ = TextEnvelopeType
"VrfSigningKey_" forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString (forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> String
Crypto.algorithmNameVRF Proxy (VRF StandardCrypto)
proxy)
      where
        proxy :: Proxy (Shelley.VRF StandardCrypto)
        proxy :: Proxy (VRF StandardCrypto)
proxy = forall {k} (t :: k). Proxy t
Proxy