{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

-- | Abstract Verifiable Random Functions.
module Cardano.Crypto.VRF.Class (
  -- * VRF algorithm class
  VRFAlgorithm (..),
  sizeVerKeyVRF,
  sizeSignKeyVRF,
  sizeCertVRF,

  -- ** VRF output
  OutputVRF (..),
  getOutputVRFBytes,
  getOutputVRFNatural,
  mkTestOutputVRF,

  -- * 'CertifiedVRF' wrapper
  CertifiedVRF (..),
  evalCertified,
  verifyCertified,

  -- * CBOR encoding and decoding
  encodeVerKeyVRF,
  decodeVerKeyVRF,
  encodeSignKeyVRF,
  decodeSignKeyVRF,
  encodeCertVRF,
  decodeCertVRF,

  -- * Encoded 'Size' expressions
  encodedVerKeyVRFSizeExpr,
  encodedSignKeyVRFSizeExpr,
  encodedCertVRFSizeExpr,
)
where

import Cardano.Binary (
  Decoder,
  Encoding,
  FromCBOR (..),
  Size,
  ToCBOR (..),
  encodeBytes,
  encodeListLen,
  enforceSize,
  withWordSize,
 )
import Cardano.Binary.FixedSizeCodec (
  FixedSizeCodec (..),
  decodeFixedSized,
  encodeFixedSized,
  fixedSize,
 )
import Cardano.Crypto.Hash.Class (Hash, HashAlgorithm, hashWith)
import Cardano.Crypto.Seed (Seed)
import Cardano.Crypto.Util (Empty, byteArrayToNatural, naturalToByteArray)
import Control.DeepSeq (NFData)
import Data.Array.Byte (ByteArray)
import Data.ByteString (ByteString)
import Data.ByteString.Short as SBS (fromShort)
import Data.Kind (Type)
import Data.MemPack.Buffer (byteArrayToShortByteString)
import Data.Proxy (Proxy (..))
import Data.Typeable (Typeable)
import GHC.Exts (Constraint)
import GHC.Generics (Generic)
import GHC.Stack
import GHC.TypeLits (ErrorMessage (..), KnownNat, Nat, TypeError)
import NoThunks.Class (NoThunks, OnlyCheckWhnfNamed (..))
import Numeric.Natural (Natural)

class
  ( Typeable v
  , Show (VerKeyVRF v)
  , Eq (VerKeyVRF v)
  , NFData (VerKeyVRF v)
  , Show (SignKeyVRF v)
  , NFData (SignKeyVRF v)
  , Show (CertVRF v)
  , Ord (CertVRF v)
  , NFData (CertVRF v)
  , NoThunks (CertVRF v)
  , NoThunks (VerKeyVRF v)
  , NoThunks (SignKeyVRF v)
  , KnownNat (VerKeySizeVRF v)
  , KnownNat (SignKeySizeVRF v)
  , KnownNat (CertSizeVRF v)
  , FixedSizeCodec (CertVRF v)
  , FixedSizeCodec (VerKeyVRF v)
  , FixedSizeCodec (SignKeyVRF v)
  ) =>
  VRFAlgorithm v
  where
  --
  -- Key and signature types
  --

  data VerKeyVRF v :: Type
  data SignKeyVRF v :: Type
  data CertVRF v :: Type

  type VerKeySizeVRF v :: Nat
  type VerKeySizeVRF v = FixedSize (VerKeyVRF v)
  type SignKeySizeVRF v :: Nat
  type SignKeySizeVRF v = FixedSize (SignKeyVRF v)
  type CertSizeVRF v :: Nat
  type CertSizeVRF v = FixedSize (CertVRF v)

  --
  -- Metadata and basic key operations
  --

  algorithmNameVRF :: proxy v -> String

  deriveVerKeyVRF :: SignKeyVRF v -> VerKeyVRF v

  hashVerKeyVRF :: HashAlgorithm h => VerKeyVRF v -> Hash h (VerKeyVRF v)
  hashVerKeyVRF = (VerKeyVRF v -> ByteString) -> VerKeyVRF v -> Hash h (VerKeyVRF v)
forall h a. HashAlgorithm h => (a -> ByteString) -> a -> Hash h a
hashWith VerKeyVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized

  --
  -- Core algorithm operations
  --

  -- | Context required to run the VRF algorithm
  --
  -- Unit by default (no context required)
  type ContextVRF v :: Type

  type ContextVRF v = ()

  type Signable v :: Type -> Constraint
  type Signable c = Empty

  evalVRF ::
    (HasCallStack, Signable v a) =>
    ContextVRF v ->
    a ->
    SignKeyVRF v ->
    (OutputVRF v, CertVRF v)

  verifyVRF ::
    (HasCallStack, Signable v a) =>
    ContextVRF v ->
    VerKeyVRF v ->
    a ->
    CertVRF v ->
    Maybe (OutputVRF v)

  --
  -- Key generation
  --

  genKeyVRF :: Seed -> SignKeyVRF v
  genKeyPairVRF :: Seed -> (SignKeyVRF v, VerKeyVRF v)

  genKeyVRF =
    (SignKeyVRF v, VerKeyVRF v) -> SignKeyVRF v
forall a b. (a, b) -> a
fst ((SignKeyVRF v, VerKeyVRF v) -> SignKeyVRF v)
-> (Seed -> (SignKeyVRF v, VerKeyVRF v)) -> Seed -> SignKeyVRF v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seed -> (SignKeyVRF v, VerKeyVRF v)
forall v. VRFAlgorithm v => Seed -> (SignKeyVRF v, VerKeyVRF v)
genKeyPairVRF

  genKeyPairVRF = \Seed
seed ->
    let sk :: SignKeyVRF v
sk = Seed -> SignKeyVRF v
forall v. VRFAlgorithm v => Seed -> SignKeyVRF v
genKeyVRF Seed
seed
     in (SignKeyVRF v
sk, SignKeyVRF v -> VerKeyVRF v
forall v. VRFAlgorithm v => SignKeyVRF v -> VerKeyVRF v
deriveVerKeyVRF SignKeyVRF v
sk)

  -- | The upper bound on the 'Seed' size needed by 'genKeyVRF', in bytes.
  seedSizeVRF :: proxy v -> Word

  --
  -- Serialisation/(de)serialisation in fixed-size raw format
  --

  sizeOutputVRF :: proxy v -> Word

  rawSerialiseVerKeyVRF :: VerKeyVRF v -> ByteString
  rawSerialiseVerKeyVRF = VerKeyVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized
  rawSerialiseSignKeyVRF :: SignKeyVRF v -> ByteString
  rawSerialiseSignKeyVRF = SignKeyVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized
  rawSerialiseCertVRF :: CertVRF v -> ByteString
  rawSerialiseCertVRF = CertVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized

  rawDeserialiseVerKeyVRF :: ByteString -> Maybe (VerKeyVRF v)
  rawDeserialiseVerKeyVRF = ByteString -> Maybe (VerKeyVRF v)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *). MonadFail m => ByteString -> m (VerKeyVRF v)
rawDecodeFixedSized
  rawDeserialiseSignKeyVRF :: ByteString -> Maybe (SignKeyVRF v)
  rawDeserialiseSignKeyVRF = ByteString -> Maybe (SignKeyVRF v)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *). MonadFail m => ByteString -> m (SignKeyVRF v)
rawDecodeFixedSized
  rawDeserialiseCertVRF :: ByteString -> Maybe (CertVRF v)
  rawDeserialiseCertVRF = ByteString -> Maybe (CertVRF v)
forall a (m :: * -> *).
(FixedSizeCodec a, MonadFail m) =>
ByteString -> m a
forall (m :: * -> *). MonadFail m => ByteString -> m (CertVRF v)
rawDecodeFixedSized

  {-# MINIMAL
    algorithmNameVRF
    , deriveVerKeyVRF
    , evalVRF
    , verifyVRF
    , seedSizeVRF
    , (genKeyVRF | genKeyPairVRF)
    , sizeOutputVRF
    #-}

{-# DEPRECATED rawSerialiseVerKeyVRF "Use `rawEncodeFixedSized` instead" #-}
{-# DEPRECATED rawSerialiseSignKeyVRF "Use `rawEncodeFixedSized` instead" #-}
{-# DEPRECATED rawSerialiseCertVRF "Use `rawEncodeFixedSized` instead" #-}
{-# DEPRECATED rawDeserialiseVerKeyVRF "Use `rawDecodeFixedSized` instead" #-}
{-# DEPRECATED rawDeserialiseSignKeyVRF "Use `rawDecodeFixedSized` instead" #-}
{-# DEPRECATED rawDeserialiseCertVRF "Use `rawDecodeFixedSized` instead" #-}

sizeVerKeyVRF ::
  forall v proxy. FixedSizeCodec (VerKeyVRF v) => proxy v -> Word
sizeVerKeyVRF :: forall v (proxy :: * -> *).
FixedSizeCodec (VerKeyVRF v) =>
proxy v -> Word
sizeVerKeyVRF proxy v
_ = Proxy (VerKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (Proxy (VerKeyVRF v) -> Word) -> Proxy (VerKeyVRF v) -> Word
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(VerKeyVRF v)
{-# DEPRECATED sizeVerKeyVRF "Use `fixedSize` instead" #-}

sizeSignKeyVRF :: forall v proxy. FixedSizeCodec (SignKeyVRF v) => proxy v -> Word
sizeSignKeyVRF :: forall v (proxy :: * -> *).
FixedSizeCodec (SignKeyVRF v) =>
proxy v -> Word
sizeSignKeyVRF proxy v
_ = Proxy (SignKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (Proxy (SignKeyVRF v) -> Word) -> Proxy (SignKeyVRF v) -> Word
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(SignKeyVRF v)
{-# DEPRECATED sizeSignKeyVRF "Use `fixedSize` instead" #-}

sizeCertVRF :: forall v proxy. FixedSizeCodec (CertVRF v) => proxy v -> Word
sizeCertVRF :: forall v (proxy :: * -> *).
FixedSizeCodec (CertVRF v) =>
proxy v -> Word
sizeCertVRF proxy v
_ = Proxy (CertVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (Proxy (CertVRF v) -> Word) -> Proxy (CertVRF v) -> Word
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CertVRF v)
{-# DEPRECATED sizeCertVRF "Use `fixedSize` instead" #-}

--
-- Do not provide Ord instances for keys, see #38
--

instance
  ( TypeError ('Text "Ord not supported for signing keys, use the hash instead")
  , Eq (SignKeyVRF v)
  ) =>
  Ord (SignKeyVRF v)
  where
  compare :: SignKeyVRF v -> SignKeyVRF v -> Ordering
compare = [Char] -> SignKeyVRF v -> SignKeyVRF v -> Ordering
forall a. HasCallStack => [Char] -> a
error [Char]
"unsupported"

instance
  ( TypeError ('Text "Ord not supported for verification keys, use the hash instead")
  , Eq (VerKeyVRF v)
  ) =>
  Ord (VerKeyVRF v)
  where
  compare :: VerKeyVRF v -> VerKeyVRF v -> Ordering
compare = [Char] -> VerKeyVRF v -> VerKeyVRF v -> Ordering
forall a. HasCallStack => [Char] -> a
error [Char]
"unsupported"

-- | The output bytes of the VRF.
--
-- The output size is a fixed number of bytes and is given by 'sizeOutputVRF'.
newtype OutputVRF v = OutputVRF {forall v. OutputVRF v -> ByteArray
getOutputVRFByteArray :: ByteArray}
  deriving (OutputVRF v -> OutputVRF v -> Bool
(OutputVRF v -> OutputVRF v -> Bool)
-> (OutputVRF v -> OutputVRF v -> Bool) -> Eq (OutputVRF v)
forall v. OutputVRF v -> OutputVRF v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall v. OutputVRF v -> OutputVRF v -> Bool
== :: OutputVRF v -> OutputVRF v -> Bool
$c/= :: forall v. OutputVRF v -> OutputVRF v -> Bool
/= :: OutputVRF v -> OutputVRF v -> Bool
Eq, Eq (OutputVRF v)
Eq (OutputVRF v) =>
(OutputVRF v -> OutputVRF v -> Ordering)
-> (OutputVRF v -> OutputVRF v -> Bool)
-> (OutputVRF v -> OutputVRF v -> Bool)
-> (OutputVRF v -> OutputVRF v -> Bool)
-> (OutputVRF v -> OutputVRF v -> Bool)
-> (OutputVRF v -> OutputVRF v -> OutputVRF v)
-> (OutputVRF v -> OutputVRF v -> OutputVRF v)
-> Ord (OutputVRF v)
OutputVRF v -> OutputVRF v -> Bool
OutputVRF v -> OutputVRF v -> Ordering
OutputVRF v -> OutputVRF v -> OutputVRF v
forall v. Eq (OutputVRF v)
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
forall v. OutputVRF v -> OutputVRF v -> Bool
forall v. OutputVRF v -> OutputVRF v -> Ordering
forall v. OutputVRF v -> OutputVRF v -> OutputVRF v
$ccompare :: forall v. OutputVRF v -> OutputVRF v -> Ordering
compare :: OutputVRF v -> OutputVRF v -> Ordering
$c< :: forall v. OutputVRF v -> OutputVRF v -> Bool
< :: OutputVRF v -> OutputVRF v -> Bool
$c<= :: forall v. OutputVRF v -> OutputVRF v -> Bool
<= :: OutputVRF v -> OutputVRF v -> Bool
$c> :: forall v. OutputVRF v -> OutputVRF v -> Bool
> :: OutputVRF v -> OutputVRF v -> Bool
$c>= :: forall v. OutputVRF v -> OutputVRF v -> Bool
>= :: OutputVRF v -> OutputVRF v -> Bool
$cmax :: forall v. OutputVRF v -> OutputVRF v -> OutputVRF v
max :: OutputVRF v -> OutputVRF v -> OutputVRF v
$cmin :: forall v. OutputVRF v -> OutputVRF v -> OutputVRF v
min :: OutputVRF v -> OutputVRF v -> OutputVRF v
Ord, Int -> OutputVRF v -> ShowS
[OutputVRF v] -> ShowS
OutputVRF v -> [Char]
(Int -> OutputVRF v -> ShowS)
-> (OutputVRF v -> [Char])
-> ([OutputVRF v] -> ShowS)
-> Show (OutputVRF v)
forall v. Int -> OutputVRF v -> ShowS
forall v. [OutputVRF v] -> ShowS
forall v. OutputVRF v -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall v. Int -> OutputVRF v -> ShowS
showsPrec :: Int -> OutputVRF v -> ShowS
$cshow :: forall v. OutputVRF v -> [Char]
show :: OutputVRF v -> [Char]
$cshowList :: forall v. [OutputVRF v] -> ShowS
showList :: [OutputVRF v] -> ShowS
Show, Typeable (OutputVRF v)
Typeable (OutputVRF v) =>
(OutputVRF v -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (OutputVRF v) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [OutputVRF v] -> Size)
-> ToCBOR (OutputVRF v)
OutputVRF v -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [OutputVRF v] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (OutputVRF v) -> Size
forall v. Typeable v => Typeable (OutputVRF v)
forall v. Typeable v => OutputVRF v -> Encoding
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
forall v.
Typeable v =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [OutputVRF v] -> Size
forall v.
Typeable v =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (OutputVRF v) -> Size
$ctoCBOR :: forall v. Typeable v => OutputVRF v -> Encoding
toCBOR :: OutputVRF v -> Encoding
$cencodedSizeExpr :: forall v.
Typeable v =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (OutputVRF v) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (OutputVRF v) -> Size
$cencodedListSizeExpr :: forall v.
Typeable v =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [OutputVRF v] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [OutputVRF v] -> Size
ToCBOR, Typeable (OutputVRF v)
Typeable (OutputVRF v) =>
(forall s. Decoder s (OutputVRF v))
-> (Proxy (OutputVRF v) -> Text) -> FromCBOR (OutputVRF v)
Proxy (OutputVRF v) -> Text
forall s. Decoder s (OutputVRF v)
forall v. Typeable v => Typeable (OutputVRF v)
forall v. Typeable v => Proxy (OutputVRF v) -> Text
forall a.
Typeable a =>
(forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
forall v s. Typeable v => Decoder s (OutputVRF v)
$cfromCBOR :: forall v s. Typeable v => Decoder s (OutputVRF v)
fromCBOR :: forall s. Decoder s (OutputVRF v)
$clabel :: forall v. Typeable v => Proxy (OutputVRF v) -> Text
label :: Proxy (OutputVRF v) -> Text
FromCBOR)
  deriving newtype (OutputVRF v -> ()
(OutputVRF v -> ()) -> NFData (OutputVRF v)
forall v. OutputVRF v -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall v. OutputVRF v -> ()
rnf :: OutputVRF v -> ()
NFData)

-- ByteArray is already in NF
deriving via
  OnlyCheckWhnfNamed "OutputVRF" (OutputVRF v)
  instance
    NoThunks (OutputVRF v)

getOutputVRFBytes :: OutputVRF v -> ByteString
getOutputVRFBytes :: forall v. OutputVRF v -> ByteString
getOutputVRFBytes = ShortByteString -> ByteString
SBS.fromShort (ShortByteString -> ByteString)
-> (OutputVRF v -> ShortByteString) -> OutputVRF v -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteArray -> ShortByteString
byteArrayToShortByteString (ByteArray -> ShortByteString)
-> (OutputVRF v -> ByteArray) -> OutputVRF v -> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OutputVRF v -> ByteArray
forall v. OutputVRF v -> ByteArray
getOutputVRFByteArray

-- | The output bytes of the VRF interpreted as a big endian natural number.
--
-- The range of this number is determined by the size of the VRF output bytes.
-- It is thus in the range @0 ..  2 ^ (8 * sizeOutputVRF proxy) - 1@.
getOutputVRFNatural :: OutputVRF v -> Natural
getOutputVRFNatural :: forall v. OutputVRF v -> Natural
getOutputVRFNatural = ByteArray -> Natural
byteArrayToNatural (ByteArray -> Natural)
-> (OutputVRF v -> ByteArray) -> OutputVRF v -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OutputVRF v -> ByteArray
forall v. OutputVRF v -> ByteArray
getOutputVRFByteArray

-- | For testing purposes, make an 'OutputVRF' from a 'Natural'.
--
-- The 'OutputVRF' will be of the appropriate size for the 'VRFAlgorithm'.
mkTestOutputVRF :: forall v. VRFAlgorithm v => Natural -> OutputVRF v
mkTestOutputVRF :: forall v. VRFAlgorithm v => Natural -> OutputVRF v
mkTestOutputVRF = ByteArray -> OutputVRF v
forall v. ByteArray -> OutputVRF v
OutputVRF (ByteArray -> OutputVRF v)
-> (Natural -> ByteArray) -> Natural -> OutputVRF v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural -> ByteArray
naturalToByteArray Int
sz
  where
    sz :: Int
sz = forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Int (Proxy v -> Word
forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> Word
forall (proxy :: * -> *). proxy v -> Word
sizeOutputVRF (Proxy v
forall {k} (t :: k). Proxy t
Proxy :: Proxy v))

--
-- Convenient CBOR encoding/decoding
--
-- Implementations in terms of the raw (de)serialise
--

encodeVerKeyVRF :: VRFAlgorithm v => VerKeyVRF v -> Encoding
encodeVerKeyVRF :: forall v. VRFAlgorithm v => VerKeyVRF v -> Encoding
encodeVerKeyVRF = ByteString -> Encoding
encodeBytes (ByteString -> Encoding)
-> (VerKeyVRF v -> ByteString) -> VerKeyVRF v -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VerKeyVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized
{-# DEPRECATED encodeVerKeyVRF "Use `encodeFixedSized` instead" #-}

encodeSignKeyVRF :: VRFAlgorithm v => SignKeyVRF v -> Encoding
encodeSignKeyVRF :: forall v. VRFAlgorithm v => SignKeyVRF v -> Encoding
encodeSignKeyVRF = ByteString -> Encoding
encodeBytes (ByteString -> Encoding)
-> (SignKeyVRF v -> ByteString) -> SignKeyVRF v -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignKeyVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized
{-# DEPRECATED encodeSignKeyVRF "Use `encodeFixedSized` instead" #-}

encodeCertVRF :: VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF :: forall v. VRFAlgorithm v => CertVRF v -> Encoding
encodeCertVRF = ByteString -> Encoding
encodeBytes (ByteString -> Encoding)
-> (CertVRF v -> ByteString) -> CertVRF v -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CertVRF v -> ByteString
forall a. FixedSizeCodec a => a -> ByteString
rawEncodeFixedSized
{-# DEPRECATED encodeCertVRF "Use `encodeFixedSized` instead" #-}

decodeVerKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (VerKeyVRF v)
decodeVerKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (VerKeyVRF v)
decodeVerKeyVRF = Decoder s (VerKeyVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeVerKeyVRF #-}
{-# DEPRECATED decodeVerKeyVRF "Use `decodeFixedSized` instead" #-}

decodeSignKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (SignKeyVRF v)
decodeSignKeyVRF :: forall v s. VRFAlgorithm v => Decoder s (SignKeyVRF v)
decodeSignKeyVRF = Decoder s (SignKeyVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeSignKeyVRF #-}
{-# DEPRECATED decodeSignKeyVRF "Use `decodeFixedSized` instead" #-}

decodeCertVRF :: forall v s. VRFAlgorithm v => Decoder s (CertVRF v)
decodeCertVRF :: forall v s. VRFAlgorithm v => Decoder s (CertVRF v)
decodeCertVRF = Decoder s (CertVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
{-# INLINE decodeCertVRF #-}
{-# DEPRECATED decodeCertVRF "Use `decodeFixedSized` instead" #-}

data CertifiedVRF v a = CertifiedVRF
  { forall v a. CertifiedVRF v a -> OutputVRF v
certifiedOutput :: !(OutputVRF v)
  , forall v a. CertifiedVRF v a -> CertVRF v
certifiedProof :: !(CertVRF v)
  }
  deriving ((forall x. CertifiedVRF v a -> Rep (CertifiedVRF v a) x)
-> (forall x. Rep (CertifiedVRF v a) x -> CertifiedVRF v a)
-> Generic (CertifiedVRF v a)
forall x. Rep (CertifiedVRF v a) x -> CertifiedVRF v a
forall x. CertifiedVRF v a -> Rep (CertifiedVRF v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v a x. Rep (CertifiedVRF v a) x -> CertifiedVRF v a
forall v a x. CertifiedVRF v a -> Rep (CertifiedVRF v a) x
$cfrom :: forall v a x. CertifiedVRF v a -> Rep (CertifiedVRF v a) x
from :: forall x. CertifiedVRF v a -> Rep (CertifiedVRF v a) x
$cto :: forall v a x. Rep (CertifiedVRF v a) x -> CertifiedVRF v a
to :: forall x. Rep (CertifiedVRF v a) x -> CertifiedVRF v a
Generic)

deriving instance VRFAlgorithm v => Eq (CertifiedVRF v a)
deriving instance VRFAlgorithm v => Ord (CertifiedVRF v a)
deriving instance VRFAlgorithm v => Show (CertifiedVRF v a)

instance VRFAlgorithm v => NoThunks (CertifiedVRF v a)

-- use generic instance

instance (VRFAlgorithm v, Typeable a) => ToCBOR (CertifiedVRF v a) where
  toCBOR :: CertifiedVRF v a -> Encoding
toCBOR CertifiedVRF v a
cvrf =
    Word -> Encoding
encodeListLen Word
2
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> OutputVRF v -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR (CertifiedVRF v a -> OutputVRF v
forall v a. CertifiedVRF v a -> OutputVRF v
certifiedOutput CertifiedVRF v a
cvrf)
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CertVRF v -> Encoding
forall a. FixedSizeCodec a => a -> Encoding
encodeFixedSized (CertifiedVRF v a -> CertVRF v
forall v a. CertifiedVRF v a -> CertVRF v
certifiedProof CertifiedVRF v a
cvrf)

  encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (CertifiedVRF v a) -> Size
encodedSizeExpr forall t. ToCBOR t => Proxy t -> Size
_size Proxy (CertifiedVRF v a)
proxy =
    Size
1
      Size -> Size -> Size
forall a. Num a => a -> a -> a
+ Proxy (OutputVRF v) -> Size
certifiedOutputSize (CertifiedVRF v a -> OutputVRF v
forall v a. CertifiedVRF v a -> OutputVRF v
certifiedOutput (CertifiedVRF v a -> OutputVRF v)
-> Proxy (CertifiedVRF v a) -> Proxy (OutputVRF v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy (CertifiedVRF v a)
proxy)
      Size -> Size -> Size
forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Size (Proxy (CertVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CertVRF v)))
    where
      certifiedOutputSize :: Proxy (OutputVRF v) -> Size
      certifiedOutputSize :: Proxy (OutputVRF v) -> Size
certifiedOutputSize Proxy (OutputVRF v)
_proxy =
        forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Size (Proxy v -> Word
forall v (proxy :: * -> *). VRFAlgorithm v => proxy v -> Word
forall (proxy :: * -> *). proxy v -> Word
sizeOutputVRF (Proxy v
forall {k} (t :: k). Proxy t
Proxy :: Proxy v))

instance (VRFAlgorithm v, Typeable a) => FromCBOR (CertifiedVRF v a) where
  fromCBOR :: forall s. Decoder s (CertifiedVRF v a)
fromCBOR =
    OutputVRF v -> CertVRF v -> CertifiedVRF v a
forall v a. OutputVRF v -> CertVRF v -> CertifiedVRF v a
CertifiedVRF
      (OutputVRF v -> CertVRF v -> CertifiedVRF v a)
-> Decoder s ()
-> Decoder s (OutputVRF v -> CertVRF v -> CertifiedVRF v a)
forall a b. a -> Decoder s b -> Decoder s a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Text -> Int -> Decoder s ()
forall s. Text -> Int -> Decoder s ()
enforceSize Text
"CertifiedVRF" Int
2
      Decoder s (OutputVRF v -> CertVRF v -> CertifiedVRF v a)
-> Decoder s (OutputVRF v)
-> Decoder s (CertVRF v -> CertifiedVRF v a)
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s (OutputVRF v)
forall s. Decoder s (OutputVRF v)
forall a s. FromCBOR a => Decoder s a
fromCBOR
      Decoder s (CertVRF v -> CertifiedVRF v a)
-> Decoder s (CertVRF v) -> Decoder s (CertifiedVRF v a)
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s (CertVRF v)
forall a s. FixedSizeCodec a => Decoder s a
decodeFixedSized
  {-# INLINE fromCBOR #-}

evalCertified ::
  (VRFAlgorithm v, Signable v a) =>
  ContextVRF v ->
  a ->
  SignKeyVRF v ->
  CertifiedVRF v a
evalCertified :: forall v a.
(VRFAlgorithm v, Signable v a) =>
ContextVRF v -> a -> SignKeyVRF v -> CertifiedVRF v a
evalCertified ContextVRF v
ctxt a
a SignKeyVRF v
key = (OutputVRF v -> CertVRF v -> CertifiedVRF v a)
-> (OutputVRF v, CertVRF v) -> CertifiedVRF v a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry OutputVRF v -> CertVRF v -> CertifiedVRF v a
forall v a. OutputVRF v -> CertVRF v -> CertifiedVRF v a
CertifiedVRF ((OutputVRF v, CertVRF v) -> CertifiedVRF v a)
-> (OutputVRF v, CertVRF v) -> CertifiedVRF v a
forall a b. (a -> b) -> a -> b
$ ContextVRF v -> a -> SignKeyVRF v -> (OutputVRF v, CertVRF v)
forall a.
(HasCallStack, Signable v a) =>
ContextVRF v -> a -> SignKeyVRF v -> (OutputVRF v, CertVRF v)
forall v a.
(VRFAlgorithm v, HasCallStack, Signable v a) =>
ContextVRF v -> a -> SignKeyVRF v -> (OutputVRF v, CertVRF v)
evalVRF ContextVRF v
ctxt a
a SignKeyVRF v
key

verifyCertified ::
  (VRFAlgorithm v, Signable v a) =>
  ContextVRF v ->
  VerKeyVRF v ->
  a ->
  CertifiedVRF v a ->
  Bool
verifyCertified :: forall v a.
(VRFAlgorithm v, Signable v a) =>
ContextVRF v -> VerKeyVRF v -> a -> CertifiedVRF v a -> Bool
verifyCertified ContextVRF v
ctxt VerKeyVRF v
vk a
a CertifiedVRF {OutputVRF v
certifiedOutput :: forall v a. CertifiedVRF v a -> OutputVRF v
certifiedOutput :: OutputVRF v
certifiedOutput, CertVRF v
certifiedProof :: forall v a. CertifiedVRF v a -> CertVRF v
certifiedProof :: CertVRF v
certifiedProof} =
  case ContextVRF v
-> VerKeyVRF v -> a -> CertVRF v -> Maybe (OutputVRF v)
forall a.
(HasCallStack, Signable v a) =>
ContextVRF v
-> VerKeyVRF v -> a -> CertVRF v -> Maybe (OutputVRF v)
forall v a.
(VRFAlgorithm v, HasCallStack, Signable v a) =>
ContextVRF v
-> VerKeyVRF v -> a -> CertVRF v -> Maybe (OutputVRF v)
verifyVRF ContextVRF v
ctxt VerKeyVRF v
vk a
a CertVRF v
certifiedProof of
    Maybe (OutputVRF v)
Nothing -> Bool
False
    Just OutputVRF v
output -> OutputVRF v
output OutputVRF v -> OutputVRF v -> Bool
forall a. Eq a => a -> a -> Bool
== OutputVRF v
certifiedOutput

--
-- 'Size' expressions for 'ToCBOR' instances
--

encodedVerKeyVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (VerKeyVRF v) -> Size
encodedVerKeyVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (VerKeyVRF v) -> Size
encodedVerKeyVRFSizeExpr Proxy (VerKeyVRF v)
_proxy =
  -- 'encodeBytes' envelope
  forall a b. (Integral a, Num b) => a -> b
fromIntegral @Integer @Size (Word -> Integer
forall s a. (Integral s, Integral a) => s -> a
withWordSize (Proxy (VerKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(VerKeyVRF v))))
    -- payload
    Size -> Size -> Size
forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Size (Proxy (VerKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(VerKeyVRF v)))

encodedSignKeyVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (SignKeyVRF v) -> Size
encodedSignKeyVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (SignKeyVRF v) -> Size
encodedSignKeyVRFSizeExpr Proxy (SignKeyVRF v)
_proxy =
  -- 'encodeBytes' envelope
  forall a b. (Integral a, Num b) => a -> b
fromIntegral @Integer @Size (Word -> Integer
forall s a. (Integral s, Integral a) => s -> a
withWordSize (Proxy (SignKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(SignKeyVRF v))))
    -- payload
    Size -> Size -> Size
forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Size (Proxy (SignKeyVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(SignKeyVRF v)))

encodedCertVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (CertVRF v) -> Size
encodedCertVRFSizeExpr :: forall v. VRFAlgorithm v => Proxy (CertVRF v) -> Size
encodedCertVRFSizeExpr Proxy (CertVRF v)
_proxy =
  -- 'encodeBytes' envelope
  forall a b. (Integral a, Num b) => a -> b
fromIntegral @Integer @Size (Word -> Integer
forall s a. (Integral s, Integral a) => s -> a
withWordSize (Proxy (CertVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CertVRF v))))
    -- payload
    Size -> Size -> Size
forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word @Size (Proxy (CertVRF v) -> Word
forall a (proxy :: * -> *). FixedSizeCodec a => proxy a -> Word
fixedSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(CertVRF v)))