{-# 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           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

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           Data.ByteString (ByteString)
import           Data.Either.Combinators (maybeToRight)
import           Data.String (IsString (..))

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

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

  deterministicSigningKeySeedSize :: AsType KesKey -> Word
  deterministicSigningKeySeedSize :: AsType KesKey -> Word
deterministicSigningKeySeedSize AsType KesKey
R:AsTypeKesKey
AsKesKey =
    Proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> Word
forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> Word
forall (proxy :: * -> *).
proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> Word
Crypto.seedSizeKES Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
proxy
   where
    proxy :: Proxy (Shelley.KES StandardCrypto)
    proxy :: Proxy (KES StandardCrypto)
proxy = Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
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 (SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
-> VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
forall v. KESAlgorithm v => SignKeyKES v -> VerKeyKES v
Crypto.deriveVerKeyKES SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
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 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
-> Hash Blake2b_256 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
forall h.
HashAlgorithm h =>
VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
-> Hash h (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
forall v h.
(KESAlgorithm v, HashAlgorithm h) =>
VerKeyKES v -> Hash h (VerKeyKES v)
Crypto.hashVerKeyKES VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
VerKeyKES StandardCrypto
vkey)

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

  deserialiseFromRawBytes :: AsType (VerificationKey KesKey)
-> ByteString
-> Either SerialiseAsRawBytesError (VerificationKey KesKey)
deserialiseFromRawBytes (AsVerificationKey AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
    SerialiseAsRawBytesError
-> Maybe (VerificationKey KesKey)
-> Either SerialiseAsRawBytesError (VerificationKey KesKey)
forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise VerificationKey KesKey") (Maybe (VerificationKey KesKey)
 -> Either SerialiseAsRawBytesError (VerificationKey KesKey))
-> Maybe (VerificationKey KesKey)
-> Either SerialiseAsRawBytesError (VerificationKey KesKey)
forall a b. (a -> b) -> a -> b
$
      VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
-> VerificationKey KesKey
VerKeyKES StandardCrypto -> VerificationKey KesKey
KesVerificationKey (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
 -> VerificationKey KesKey)
-> Maybe (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
-> Maybe (VerificationKey KesKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
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) =
    SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256) -> ByteString
forall v. KESAlgorithm v => SignKeyKES v -> ByteString
Crypto.rawSerialiseSignKeyKES SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
SignKeyKES StandardCrypto
sk

  deserialiseFromRawBytes :: AsType (SigningKey KesKey)
-> ByteString
-> Either SerialiseAsRawBytesError (SigningKey KesKey)
deserialiseFromRawBytes (AsSigningKey AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
    SerialiseAsRawBytesError
-> Maybe (SigningKey KesKey)
-> Either SerialiseAsRawBytesError (SigningKey KesKey)
forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise SigningKey KesKey") (Maybe (SigningKey KesKey)
 -> Either SerialiseAsRawBytesError (SigningKey KesKey))
-> Maybe (SigningKey KesKey)
-> Either SerialiseAsRawBytesError (SigningKey KesKey)
forall a b. (a -> b) -> a -> b
$
      SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256) -> SigningKey KesKey
SignKeyKES StandardCrypto -> SigningKey KesKey
KesSigningKey (SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)
 -> SigningKey KesKey)
-> Maybe (SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
-> Maybe (SigningKey KesKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (SignKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
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
(Hash KesKey -> Hash KesKey -> Bool)
-> (Hash KesKey -> Hash KesKey -> Bool) -> Eq (Hash KesKey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Hash KesKey -> Hash KesKey -> Bool
== :: Hash KesKey -> Hash KesKey -> Bool
$c/= :: Hash KesKey -> Hash KesKey -> Bool
/= :: Hash KesKey -> Hash KesKey -> Bool
Eq, Eq (Hash KesKey)
Eq (Hash KesKey) =>
(Hash KesKey -> Hash KesKey -> Ordering)
-> (Hash KesKey -> Hash KesKey -> Bool)
-> (Hash KesKey -> Hash KesKey -> Bool)
-> (Hash KesKey -> Hash KesKey -> Bool)
-> (Hash KesKey -> Hash KesKey -> Bool)
-> (Hash KesKey -> Hash KesKey -> Hash KesKey)
-> (Hash KesKey -> Hash KesKey -> Hash KesKey)
-> Ord (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
$ccompare :: Hash KesKey -> Hash KesKey -> Ordering
compare :: Hash KesKey -> Hash KesKey -> Ordering
$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
>= :: Hash KesKey -> Hash KesKey -> Bool
$cmax :: Hash KesKey -> Hash KesKey -> Hash KesKey
max :: Hash KesKey -> Hash KesKey -> Hash KesKey
$cmin :: Hash KesKey -> Hash KesKey -> Hash KesKey
min :: Hash KesKey -> Hash KesKey -> Hash KesKey
Ord)
  deriving (Int -> Hash KesKey -> ShowS
[Hash KesKey] -> ShowS
Hash KesKey -> String
(Int -> Hash KesKey -> ShowS)
-> (Hash KesKey -> String)
-> ([Hash KesKey] -> ShowS)
-> Show (Hash KesKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Hash KesKey -> ShowS
showsPrec :: Int -> Hash KesKey -> ShowS
$cshow :: Hash KesKey -> String
show :: Hash KesKey -> String
$cshowList :: [Hash KesKey] -> ShowS
showList :: [Hash KesKey] -> ShowS
Show, String -> Hash KesKey
(String -> Hash KesKey) -> IsString (Hash KesKey)
forall a. (String -> a) -> IsString a
$cfromString :: String -> Hash KesKey
fromString :: String -> Hash KesKey
IsString) via UsingRawBytesHex (Hash KesKey)
  deriving (Typeable (Hash KesKey)
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)
-> ToCBOR (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
$ctoCBOR :: Hash KesKey -> Encoding
toCBOR :: Hash KesKey -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash KesKey) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash KesKey) -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash KesKey] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash KesKey] -> Size
ToCBOR, Typeable (Hash KesKey)
Typeable (Hash KesKey) =>
(forall s. Decoder s (Hash KesKey))
-> (Proxy (Hash KesKey) -> Text) -> FromCBOR (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
$cfromCBOR :: forall s. Decoder s (Hash KesKey)
fromCBOR :: forall s. Decoder s (Hash KesKey)
$clabel :: Proxy (Hash KesKey) -> Text
label :: Proxy (Hash KesKey) -> Text
FromCBOR) via UsingRawBytes (Hash KesKey)
  deriving anyclass HasTypeProxy (Hash KesKey)
HasTypeProxy (Hash KesKey) =>
(Hash KesKey -> ByteString)
-> (AsType (Hash KesKey)
    -> ByteString -> Either DecoderError (Hash KesKey))
-> SerialiseAsCBOR (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
$cserialiseToCBOR :: Hash KesKey -> ByteString
serialiseToCBOR :: Hash KesKey -> ByteString
$cdeserialiseFromCBOR :: AsType (Hash KesKey)
-> ByteString -> Either DecoderError (Hash KesKey)
deserialiseFromCBOR :: AsType (Hash KesKey)
-> ByteString -> Either DecoderError (Hash KesKey)
SerialiseAsCBOR

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

  deserialiseFromRawBytes :: AsType (Hash KesKey)
-> ByteString -> Either SerialiseAsRawBytesError (Hash KesKey)
deserialiseFromRawBytes (AsHash AsType KesKey
R:AsTypeKesKey
AsKesKey) ByteString
bs =
    SerialiseAsRawBytesError
-> Maybe (Hash KesKey)
-> Either SerialiseAsRawBytesError (Hash KesKey)
forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise Hash KesKey") (Maybe (Hash KesKey)
 -> Either SerialiseAsRawBytesError (Hash KesKey))
-> Maybe (Hash KesKey)
-> Either SerialiseAsRawBytesError (Hash KesKey)
forall a b. (a -> b) -> a -> b
$
      Hash Blake2b_256 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
-> Hash KesKey
Hash StandardCrypto (VerKeyKES StandardCrypto) -> Hash KesKey
KesKeyHash (Hash Blake2b_256 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256))
 -> Hash KesKey)
-> Maybe
     (Hash Blake2b_256 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)))
-> Maybe (Hash KesKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString
-> Maybe
     (Hash Blake2b_256 (VerKeyKES (Sum6KES Ed25519DSIGN Blake2b_256)))
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_"
      TextEnvelopeType -> TextEnvelopeType -> TextEnvelopeType
forall a. Semigroup a => a -> a -> a
<> String -> TextEnvelopeType
forall a. IsString a => String -> a
fromString (Proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> String
forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> String
forall (proxy :: * -> *).
proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> String
Crypto.algorithmNameKES Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
proxy)
   where
    proxy :: Proxy (Shelley.KES StandardCrypto)
    proxy :: Proxy (KES StandardCrypto)
proxy = Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
forall {k} (t :: k). Proxy t
Proxy

instance HasTextEnvelope (SigningKey KesKey) where
  textEnvelopeType :: AsType (SigningKey KesKey) -> TextEnvelopeType
textEnvelopeType AsType (SigningKey KesKey)
_ =
    TextEnvelopeType
"KesSigningKey_"
      TextEnvelopeType -> TextEnvelopeType -> TextEnvelopeType
forall a. Semigroup a => a -> a -> a
<> String -> TextEnvelopeType
forall a. IsString a => String -> a
fromString (Proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> String
forall v (proxy :: * -> *). KESAlgorithm v => proxy v -> String
forall (proxy :: * -> *).
proxy (Sum6KES Ed25519DSIGN Blake2b_256) -> String
Crypto.algorithmNameKES Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
proxy)
   where
    proxy :: Proxy (Shelley.KES StandardCrypto)
    proxy :: Proxy (KES StandardCrypto)
proxy = Proxy (Sum6KES Ed25519DSIGN Blake2b_256)
Proxy (KES StandardCrypto)
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
(VerificationKey VrfKey -> VerificationKey VrfKey -> Bool)
-> (VerificationKey VrfKey -> VerificationKey VrfKey -> Bool)
-> Eq (VerificationKey VrfKey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
== :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
$c/= :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
/= :: VerificationKey VrfKey -> VerificationKey VrfKey -> Bool
Eq
    deriving (Int -> VerificationKey VrfKey -> ShowS
[VerificationKey VrfKey] -> ShowS
VerificationKey VrfKey -> String
(Int -> VerificationKey VrfKey -> ShowS)
-> (VerificationKey VrfKey -> String)
-> ([VerificationKey VrfKey] -> ShowS)
-> Show (VerificationKey VrfKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerificationKey VrfKey -> ShowS
showsPrec :: Int -> VerificationKey VrfKey -> ShowS
$cshow :: VerificationKey VrfKey -> String
show :: VerificationKey VrfKey -> String
$cshowList :: [VerificationKey VrfKey] -> ShowS
showList :: [VerificationKey VrfKey] -> ShowS
Show, String -> VerificationKey VrfKey
(String -> VerificationKey VrfKey)
-> IsString (VerificationKey VrfKey)
forall a. (String -> a) -> IsString a
$cfromString :: String -> VerificationKey VrfKey
fromString :: String -> VerificationKey VrfKey
IsString) via UsingRawBytesHex (VerificationKey VrfKey)
    deriving newtype (Typeable (VerificationKey VrfKey)
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)
-> ToCBOR (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
$ctoCBOR :: VerificationKey VrfKey -> Encoding
toCBOR :: VerificationKey VrfKey -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey VrfKey) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (VerificationKey VrfKey) -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey VrfKey] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [VerificationKey VrfKey] -> Size
ToCBOR, Typeable (VerificationKey VrfKey)
Typeable (VerificationKey VrfKey) =>
(forall s. Decoder s (VerificationKey VrfKey))
-> (Proxy (VerificationKey VrfKey) -> Text)
-> FromCBOR (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
$cfromCBOR :: forall s. Decoder s (VerificationKey VrfKey)
fromCBOR :: forall s. Decoder s (VerificationKey VrfKey)
$clabel :: Proxy (VerificationKey VrfKey) -> Text
label :: Proxy (VerificationKey VrfKey) -> Text
FromCBOR)
    deriving anyclass HasTypeProxy (VerificationKey VrfKey)
HasTypeProxy (VerificationKey VrfKey) =>
(VerificationKey VrfKey -> ByteString)
-> (AsType (VerificationKey VrfKey)
    -> ByteString -> Either DecoderError (VerificationKey VrfKey))
-> SerialiseAsCBOR (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
$cserialiseToCBOR :: VerificationKey VrfKey -> ByteString
serialiseToCBOR :: VerificationKey VrfKey -> ByteString
$cdeserialiseFromCBOR :: AsType (VerificationKey VrfKey)
-> ByteString -> Either DecoderError (VerificationKey VrfKey)
deserialiseFromCBOR :: AsType (VerificationKey VrfKey)
-> ByteString -> Either DecoderError (VerificationKey VrfKey)
SerialiseAsCBOR

  newtype SigningKey VrfKey
    = VrfSigningKey (Shelley.SignKeyVRF StandardCrypto)
    deriving (Int -> SigningKey VrfKey -> ShowS
[SigningKey VrfKey] -> ShowS
SigningKey VrfKey -> String
(Int -> SigningKey VrfKey -> ShowS)
-> (SigningKey VrfKey -> String)
-> ([SigningKey VrfKey] -> ShowS)
-> Show (SigningKey VrfKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigningKey VrfKey -> ShowS
showsPrec :: Int -> SigningKey VrfKey -> ShowS
$cshow :: SigningKey VrfKey -> String
show :: SigningKey VrfKey -> String
$cshowList :: [SigningKey VrfKey] -> ShowS
showList :: [SigningKey VrfKey] -> ShowS
Show, String -> SigningKey VrfKey
(String -> SigningKey VrfKey) -> IsString (SigningKey VrfKey)
forall a. (String -> a) -> IsString a
$cfromString :: String -> SigningKey VrfKey
fromString :: String -> SigningKey VrfKey
IsString) via UsingRawBytesHex (SigningKey VrfKey)
    deriving newtype (Typeable (SigningKey VrfKey)
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)
-> ToCBOR (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
$ctoCBOR :: SigningKey VrfKey -> Encoding
toCBOR :: SigningKey VrfKey -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey VrfKey) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (SigningKey VrfKey) -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey VrfKey] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [SigningKey VrfKey] -> Size
ToCBOR, Typeable (SigningKey VrfKey)
Typeable (SigningKey VrfKey) =>
(forall s. Decoder s (SigningKey VrfKey))
-> (Proxy (SigningKey VrfKey) -> Text)
-> FromCBOR (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
$cfromCBOR :: forall s. Decoder s (SigningKey VrfKey)
fromCBOR :: forall s. Decoder s (SigningKey VrfKey)
$clabel :: Proxy (SigningKey VrfKey) -> Text
label :: Proxy (SigningKey VrfKey) -> Text
FromCBOR)
    deriving anyclass HasTypeProxy (SigningKey VrfKey)
HasTypeProxy (SigningKey VrfKey) =>
(SigningKey VrfKey -> ByteString)
-> (AsType (SigningKey VrfKey)
    -> ByteString -> Either DecoderError (SigningKey VrfKey))
-> SerialiseAsCBOR (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
$cserialiseToCBOR :: SigningKey VrfKey -> ByteString
serialiseToCBOR :: SigningKey VrfKey -> ByteString
$cdeserialiseFromCBOR :: AsType (SigningKey VrfKey)
-> ByteString -> Either DecoderError (SigningKey VrfKey)
deserialiseFromCBOR :: AsType (SigningKey VrfKey)
-> ByteString -> Either DecoderError (SigningKey VrfKey)
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 (Seed -> SignKeyVRF PraosVRF
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 =
    Proxy PraosVRF -> Word
forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> Word
forall (proxy :: * -> *). proxy PraosVRF -> Word
Crypto.seedSizeVRF Proxy PraosVRF
Proxy (VRF StandardCrypto)
proxy
   where
    proxy :: Proxy (Shelley.VRF StandardCrypto)
    proxy :: Proxy (VRF StandardCrypto)
proxy = Proxy PraosVRF
Proxy (VRF StandardCrypto)
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 (SignKeyVRF PraosVRF -> VerKeyVRF PraosVRF
forall v. VRFAlgorithm v => SignKeyVRF v -> VerKeyVRF v
Crypto.deriveVerKeyVRF SignKeyVRF PraosVRF
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 (VerKeyVRF PraosVRF -> Hash Blake2b_256 (VerKeyVRF PraosVRF)
forall h.
HashAlgorithm h =>
VerKeyVRF PraosVRF -> Hash h (VerKeyVRF PraosVRF)
forall v h.
(VRFAlgorithm v, HashAlgorithm h) =>
VerKeyVRF v -> Hash h (VerKeyVRF v)
Shelley.hashVerKeyVRF VerKeyVRF PraosVRF
VerKeyVRF StandardCrypto
vkey)

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

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

  deserialiseFromRawBytes :: AsType (SigningKey VrfKey)
-> ByteString
-> Either SerialiseAsRawBytesError (SigningKey VrfKey)
deserialiseFromRawBytes (AsSigningKey AsType VrfKey
R:AsTypeVrfKey
AsVrfKey) ByteString
bs =
    SerialiseAsRawBytesError
-> Maybe (SigningKey VrfKey)
-> Either SerialiseAsRawBytesError (SigningKey VrfKey)
forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise SigningKey VrfKey") (Maybe (SigningKey VrfKey)
 -> Either SerialiseAsRawBytesError (SigningKey VrfKey))
-> Maybe (SigningKey VrfKey)
-> Either SerialiseAsRawBytesError (SigningKey VrfKey)
forall a b. (a -> b) -> a -> b
$
      SignKeyVRF PraosVRF -> SigningKey VrfKey
SignKeyVRF StandardCrypto -> SigningKey VrfKey
VrfSigningKey (SignKeyVRF PraosVRF -> SigningKey VrfKey)
-> Maybe (SignKeyVRF PraosVRF) -> Maybe (SigningKey VrfKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (SignKeyVRF PraosVRF)
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
(Hash VrfKey -> Hash VrfKey -> Bool)
-> (Hash VrfKey -> Hash VrfKey -> Bool) -> Eq (Hash VrfKey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Hash VrfKey -> Hash VrfKey -> Bool
== :: Hash VrfKey -> Hash VrfKey -> Bool
$c/= :: Hash VrfKey -> Hash VrfKey -> Bool
/= :: Hash VrfKey -> Hash VrfKey -> Bool
Eq, Eq (Hash VrfKey)
Eq (Hash VrfKey) =>
(Hash VrfKey -> Hash VrfKey -> Ordering)
-> (Hash VrfKey -> Hash VrfKey -> Bool)
-> (Hash VrfKey -> Hash VrfKey -> Bool)
-> (Hash VrfKey -> Hash VrfKey -> Bool)
-> (Hash VrfKey -> Hash VrfKey -> Bool)
-> (Hash VrfKey -> Hash VrfKey -> Hash VrfKey)
-> (Hash VrfKey -> Hash VrfKey -> Hash VrfKey)
-> Ord (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
$ccompare :: Hash VrfKey -> Hash VrfKey -> Ordering
compare :: Hash VrfKey -> Hash VrfKey -> Ordering
$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
>= :: Hash VrfKey -> Hash VrfKey -> Bool
$cmax :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
max :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
$cmin :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
min :: Hash VrfKey -> Hash VrfKey -> Hash VrfKey
Ord)
  deriving (Int -> Hash VrfKey -> ShowS
[Hash VrfKey] -> ShowS
Hash VrfKey -> String
(Int -> Hash VrfKey -> ShowS)
-> (Hash VrfKey -> String)
-> ([Hash VrfKey] -> ShowS)
-> Show (Hash VrfKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Hash VrfKey -> ShowS
showsPrec :: Int -> Hash VrfKey -> ShowS
$cshow :: Hash VrfKey -> String
show :: Hash VrfKey -> String
$cshowList :: [Hash VrfKey] -> ShowS
showList :: [Hash VrfKey] -> ShowS
Show, String -> Hash VrfKey
(String -> Hash VrfKey) -> IsString (Hash VrfKey)
forall a. (String -> a) -> IsString a
$cfromString :: String -> Hash VrfKey
fromString :: String -> Hash VrfKey
IsString) via UsingRawBytesHex (Hash VrfKey)
  deriving (Typeable (Hash VrfKey)
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)
-> ToCBOR (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
$ctoCBOR :: Hash VrfKey -> Encoding
toCBOR :: Hash VrfKey -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash VrfKey) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Hash VrfKey) -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash VrfKey] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Hash VrfKey] -> Size
ToCBOR, Typeable (Hash VrfKey)
Typeable (Hash VrfKey) =>
(forall s. Decoder s (Hash VrfKey))
-> (Proxy (Hash VrfKey) -> Text) -> FromCBOR (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
$cfromCBOR :: forall s. Decoder s (Hash VrfKey)
fromCBOR :: forall s. Decoder s (Hash VrfKey)
$clabel :: Proxy (Hash VrfKey) -> Text
label :: Proxy (Hash VrfKey) -> Text
FromCBOR) via UsingRawBytes (Hash VrfKey)
  deriving anyclass HasTypeProxy (Hash VrfKey)
HasTypeProxy (Hash VrfKey) =>
(Hash VrfKey -> ByteString)
-> (AsType (Hash VrfKey)
    -> ByteString -> Either DecoderError (Hash VrfKey))
-> SerialiseAsCBOR (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
$cserialiseToCBOR :: Hash VrfKey -> ByteString
serialiseToCBOR :: Hash VrfKey -> ByteString
$cdeserialiseFromCBOR :: AsType (Hash VrfKey)
-> ByteString -> Either DecoderError (Hash VrfKey)
deserialiseFromCBOR :: AsType (Hash VrfKey)
-> ByteString -> Either DecoderError (Hash VrfKey)
SerialiseAsCBOR

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

  deserialiseFromRawBytes :: AsType (Hash VrfKey)
-> ByteString -> Either SerialiseAsRawBytesError (Hash VrfKey)
deserialiseFromRawBytes (AsHash AsType VrfKey
R:AsTypeVrfKey
AsVrfKey) ByteString
bs =
    SerialiseAsRawBytesError
-> Maybe (Hash VrfKey)
-> Either SerialiseAsRawBytesError (Hash VrfKey)
forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise Hash VrfKey") (Maybe (Hash VrfKey)
 -> Either SerialiseAsRawBytesError (Hash VrfKey))
-> Maybe (Hash VrfKey)
-> Either SerialiseAsRawBytesError (Hash VrfKey)
forall a b. (a -> b) -> a -> b
$
      Hash Blake2b_256 (VerKeyVRF PraosVRF) -> Hash VrfKey
Hash StandardCrypto (VerKeyVRF StandardCrypto) -> Hash VrfKey
VrfKeyHash (Hash Blake2b_256 (VerKeyVRF PraosVRF) -> Hash VrfKey)
-> Maybe (Hash Blake2b_256 (VerKeyVRF PraosVRF))
-> Maybe (Hash VrfKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (Hash Blake2b_256 (VerKeyVRF PraosVRF))
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_" TextEnvelopeType -> TextEnvelopeType -> TextEnvelopeType
forall a. Semigroup a => a -> a -> a
<> String -> TextEnvelopeType
forall a. IsString a => String -> a
fromString (Proxy PraosVRF -> String
forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> String
forall (proxy :: * -> *). proxy PraosVRF -> String
Crypto.algorithmNameVRF Proxy PraosVRF
Proxy (VRF StandardCrypto)
proxy)
   where
    proxy :: Proxy (Shelley.VRF StandardCrypto)
    proxy :: Proxy (VRF StandardCrypto)
proxy = Proxy PraosVRF
Proxy (VRF StandardCrypto)
forall {k} (t :: k). Proxy t
Proxy

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