{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}

module Shelley.Spec.Ledger.Address.Bootstrap
  ( BootstrapWitness
      ( BootstrapWitness,
        bwKey,
        bwSig,
        bwChainCode,
        bwAttributes
      ),
    ChainCode (..),
    bootstrapWitKeyHash,
    unpackByronVKey,
    makeBootstrapWitness,
    verifyBootstrapWit,
  )
where

import Cardano.Binary
  ( Annotator,
    FromCBOR (..),
    ToCBOR (..),
    annotatorSlice,
    encodeListLen,
    encodePreEncoded,
    serialize',
    serializeEncoding,
  )
import qualified Cardano.Chain.Common as Byron
import qualified Cardano.Crypto.DSIGN as DSIGN
import qualified Cardano.Crypto.Hash as Hash
import qualified Cardano.Crypto.Signing as Byron
import qualified Cardano.Crypto.Wallet as WC
import Cardano.Ledger.Crypto (ADDRHASH, DSIGN)
import Cardano.Ledger.Era
import Cardano.Prelude (panic)
import Data.ByteString (ByteString)
import qualified Data.ByteString.Lazy as LBS
import Data.Coerce (coerce)
import Data.Maybe (fromMaybe)
import Data.Ord (comparing)
import Data.Proxy (Proxy (..))
import GHC.Generics (Generic)
import NoThunks.Class (AllowThunksIn (..), NoThunks (..))
import Quiet
import Shelley.Spec.Ledger.Hashing (EraIndependentTxBody)
import Shelley.Spec.Ledger.Keys
  ( Hash,
    KeyHash (..),
    KeyRole (..),
    VKey (..),
    verifySignedDSIGN,
  )
import qualified Shelley.Spec.Ledger.Keys as Keys
import Shelley.Spec.Ledger.Serialization (decodeRecordNamed)

newtype ChainCode = ChainCode {ChainCode -> ByteString
unChainCode :: ByteString}
  deriving (ChainCode -> ChainCode -> Bool
(ChainCode -> ChainCode -> Bool)
-> (ChainCode -> ChainCode -> Bool) -> Eq ChainCode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChainCode -> ChainCode -> Bool
$c/= :: ChainCode -> ChainCode -> Bool
== :: ChainCode -> ChainCode -> Bool
$c== :: ChainCode -> ChainCode -> Bool
Eq, (forall x. ChainCode -> Rep ChainCode x)
-> (forall x. Rep ChainCode x -> ChainCode) -> Generic ChainCode
forall x. Rep ChainCode x -> ChainCode
forall x. ChainCode -> Rep ChainCode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChainCode x -> ChainCode
$cfrom :: forall x. ChainCode -> Rep ChainCode x
Generic)
  deriving (Int -> ChainCode -> ShowS
[ChainCode] -> ShowS
ChainCode -> String
(Int -> ChainCode -> ShowS)
-> (ChainCode -> String)
-> ([ChainCode] -> ShowS)
-> Show ChainCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChainCode] -> ShowS
$cshowList :: [ChainCode] -> ShowS
show :: ChainCode -> String
$cshow :: ChainCode -> String
showsPrec :: Int -> ChainCode -> ShowS
$cshowsPrec :: Int -> ChainCode -> ShowS
Show) via Quiet ChainCode
  deriving newtype (Context -> ChainCode -> IO (Maybe ThunkInfo)
Proxy ChainCode -> String
(Context -> ChainCode -> IO (Maybe ThunkInfo))
-> (Context -> ChainCode -> IO (Maybe ThunkInfo))
-> (Proxy ChainCode -> String)
-> NoThunks ChainCode
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
showTypeOf :: Proxy ChainCode -> String
$cshowTypeOf :: Proxy ChainCode -> String
wNoThunks :: Context -> ChainCode -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> ChainCode -> IO (Maybe ThunkInfo)
noThunks :: Context -> ChainCode -> IO (Maybe ThunkInfo)
$cnoThunks :: Context -> ChainCode -> IO (Maybe ThunkInfo)
NoThunks, Typeable ChainCode
Typeable ChainCode
-> (ChainCode -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy ChainCode -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [ChainCode] -> Size)
-> ToCBOR ChainCode
ChainCode -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [ChainCode] -> Size
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy ChainCode -> 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 [ChainCode] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [ChainCode] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy ChainCode -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy ChainCode -> Size
toCBOR :: ChainCode -> Encoding
$ctoCBOR :: ChainCode -> Encoding
$cp1ToCBOR :: Typeable ChainCode
ToCBOR, Typeable ChainCode
Decoder s ChainCode
Typeable ChainCode
-> (forall s. Decoder s ChainCode)
-> (Proxy ChainCode -> Text)
-> FromCBOR ChainCode
Proxy ChainCode -> Text
forall s. Decoder s ChainCode
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy ChainCode -> Text
$clabel :: Proxy ChainCode -> Text
fromCBOR :: Decoder s ChainCode
$cfromCBOR :: forall s. Decoder s ChainCode
$cp1FromCBOR :: Typeable ChainCode
FromCBOR)

data BootstrapWitness era = BootstrapWitness'
  { BootstrapWitness era -> VKey 'Witness (Crypto era)
bwKey' :: !(VKey 'Witness (Crypto era)),
    BootstrapWitness era
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
bwSig' ::
      !( Keys.SignedDSIGN
           (Crypto era)
           (Hash (Crypto era) EraIndependentTxBody)
       ),
    BootstrapWitness era -> ChainCode
bwChainCode' :: !ChainCode,
    BootstrapWitness era -> ByteString
bwAttributes' :: !ByteString,
    BootstrapWitness era -> ByteString
bwBytes :: LBS.ByteString
  }
  deriving ((forall x. BootstrapWitness era -> Rep (BootstrapWitness era) x)
-> (forall x. Rep (BootstrapWitness era) x -> BootstrapWitness era)
-> Generic (BootstrapWitness era)
forall x. Rep (BootstrapWitness era) x -> BootstrapWitness era
forall x. BootstrapWitness era -> Rep (BootstrapWitness era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (BootstrapWitness era) x -> BootstrapWitness era
forall era x. BootstrapWitness era -> Rep (BootstrapWitness era) x
$cto :: forall era x. Rep (BootstrapWitness era) x -> BootstrapWitness era
$cfrom :: forall era x. BootstrapWitness era -> Rep (BootstrapWitness era) x
Generic)

deriving instance (Era era) => Show (BootstrapWitness era)

deriving instance (Era era) => Eq (BootstrapWitness era)

deriving via
  (AllowThunksIn '["bwBytes"] (BootstrapWitness era))
  instance
    Era era => NoThunks (BootstrapWitness era)

pattern BootstrapWitness ::
  Era era =>
  (VKey 'Witness (Crypto era)) ->
  (Keys.SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)) ->
  ChainCode ->
  ByteString ->
  BootstrapWitness era
pattern $bBootstrapWitness :: VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> BootstrapWitness era
$mBootstrapWitness :: forall r era.
Era era =>
BootstrapWitness era
-> (VKey 'Witness (Crypto era)
    -> SignedDSIGN
         (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
    -> ChainCode
    -> ByteString
    -> r)
-> (Void# -> r)
-> r
BootstrapWitness {BootstrapWitness era -> Era era => VKey 'Witness (Crypto era)
bwKey, BootstrapWitness era
-> Era era =>
   SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
bwSig, BootstrapWitness era -> Era era => ChainCode
bwChainCode, BootstrapWitness era -> Era era => ByteString
bwAttributes} <-
  BootstrapWitness' bwKey bwSig bwChainCode bwAttributes _
  where
    BootstrapWitness VKey 'Witness (Crypto era)
key SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
sig ChainCode
cc ByteString
attributes =
      let bytes :: ByteString
bytes =
            Encoding -> ByteString
serializeEncoding (Encoding -> ByteString) -> Encoding -> ByteString
forall a b. (a -> b) -> a -> b
$
              Word -> Encoding
encodeListLen Word
4
                Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> VKey 'Witness (Crypto era) -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR VKey 'Witness (Crypto era)
key
                Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> Encoding
forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
DSIGN.encodeSignedDSIGN SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
sig
                Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> ChainCode -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR ChainCode
cc
                Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> ByteString -> Encoding
forall a. ToCBOR a => a -> Encoding
toCBOR ByteString
attributes
       in VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> ByteString
-> BootstrapWitness era
forall era.
VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> ByteString
-> BootstrapWitness era
BootstrapWitness' VKey 'Witness (Crypto era)
key SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
sig ChainCode
cc ByteString
attributes ByteString
bytes

{-# COMPLETE BootstrapWitness #-}

instance
  forall era.
  (Era era) =>
  Ord (BootstrapWitness era)
  where
  compare :: BootstrapWitness era -> BootstrapWitness era -> Ordering
compare = (BootstrapWitness era -> KeyHash 'Witness (Crypto era))
-> BootstrapWitness era -> BootstrapWitness era -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing BootstrapWitness era -> KeyHash 'Witness (Crypto era)
forall era.
Era era =>
BootstrapWitness era -> KeyHash 'Witness (Crypto era)
bootstrapWitKeyHash

instance Era era => ToCBOR (BootstrapWitness era) where
  toCBOR :: BootstrapWitness era -> Encoding
toCBOR = ByteString -> Encoding
encodePreEncoded (ByteString -> Encoding)
-> (BootstrapWitness era -> ByteString)
-> BootstrapWitness era
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.toStrict (ByteString -> ByteString)
-> (BootstrapWitness era -> ByteString)
-> BootstrapWitness era
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BootstrapWitness era -> ByteString
forall era. BootstrapWitness era -> ByteString
bwBytes

instance Era era => FromCBOR (Annotator (BootstrapWitness era)) where
  fromCBOR :: Decoder s (Annotator (BootstrapWitness era))
fromCBOR = Decoder s (Annotator (ByteString -> BootstrapWitness era))
-> Decoder s (Annotator (BootstrapWitness era))
forall s a.
Decoder s (Annotator (ByteString -> a)) -> Decoder s (Annotator a)
annotatorSlice (Decoder s (Annotator (ByteString -> BootstrapWitness era))
 -> Decoder s (Annotator (BootstrapWitness era)))
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
-> Decoder s (Annotator (BootstrapWitness era))
forall a b. (a -> b) -> a -> b
$
    Text
-> (Annotator (ByteString -> BootstrapWitness era) -> Int)
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed Text
"BootstrapWitness" (Int -> Annotator (ByteString -> BootstrapWitness era) -> Int
forall a b. a -> b -> a
const Int
4) (Decoder s (Annotator (ByteString -> BootstrapWitness era))
 -> Decoder s (Annotator (ByteString -> BootstrapWitness era)))
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
forall a b. (a -> b) -> a -> b
$
      do
        VKey 'Witness (Crypto era)
key <- Decoder s (VKey 'Witness (Crypto era))
forall a s. FromCBOR a => Decoder s a
fromCBOR
        SignedDSIGN
  (DSIGN (Crypto era))
  (Hash (HASH (Crypto era)) EraIndependentTxBody)
sig <- Decoder
  s
  (SignedDSIGN
     (DSIGN (Crypto era))
     (Hash (HASH (Crypto era)) EraIndependentTxBody))
forall v s a. DSIGNAlgorithm v => Decoder s (SignedDSIGN v a)
DSIGN.decodeSignedDSIGN
        ChainCode
cc <- Decoder s ChainCode
forall a s. FromCBOR a => Decoder s a
fromCBOR
        ByteString
attributes <- Decoder s ByteString
forall a s. FromCBOR a => Decoder s a
fromCBOR
        Annotator (ByteString -> BootstrapWitness era)
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Annotator (ByteString -> BootstrapWitness era)
 -> Decoder s (Annotator (ByteString -> BootstrapWitness era)))
-> ((ByteString -> BootstrapWitness era)
    -> Annotator (ByteString -> BootstrapWitness era))
-> (ByteString -> BootstrapWitness era)
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> BootstrapWitness era)
-> Annotator (ByteString -> BootstrapWitness era)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((ByteString -> BootstrapWitness era)
 -> Decoder s (Annotator (ByteString -> BootstrapWitness era)))
-> (ByteString -> BootstrapWitness era)
-> Decoder s (Annotator (ByteString -> BootstrapWitness era))
forall a b. (a -> b) -> a -> b
$ VKey 'Witness (Crypto era)
-> SignedDSIGN
     (DSIGN (Crypto era))
     (Hash (HASH (Crypto era)) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> ByteString
-> BootstrapWitness era
forall era.
VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> ByteString
-> BootstrapWitness era
BootstrapWitness' VKey 'Witness (Crypto era)
key SignedDSIGN
  (DSIGN (Crypto era))
  (Hash (HASH (Crypto era)) EraIndependentTxBody)
sig ChainCode
cc ByteString
attributes

-- | Rebuild the addrRoot of the corresponding address.
bootstrapWitKeyHash ::
  forall era.
  Era era =>
  BootstrapWitness era ->
  KeyHash 'Witness (Crypto era)
bootstrapWitKeyHash :: BootstrapWitness era -> KeyHash 'Witness (Crypto era)
bootstrapWitKeyHash (BootstrapWitness (VKey VerKeyDSIGN (DSIGN (Crypto era))
key) SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
_ (ChainCode ByteString
cc) ByteString
attributes) =
  Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era)))
-> KeyHash 'Witness (Crypto era)
forall (discriminator :: KeyRole) crypto.
Hash (ADDRHASH crypto) (VerKeyDSIGN (DSIGN crypto))
-> KeyHash discriminator crypto
KeyHash (Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era)))
 -> KeyHash 'Witness (Crypto era))
-> (ByteString
    -> Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era))))
-> ByteString
-> KeyHash 'Witness (Crypto era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era)))
forall a. ByteString -> Hash (ADDRHASH (Crypto era)) a
hash_crypto (ByteString
 -> Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era))))
-> (ByteString -> ByteString)
-> ByteString
-> Hash (ADDRHASH (Crypto era)) (VerKeyDSIGN (DSIGN (Crypto era)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
hash_SHA3_256 (ByteString -> KeyHash 'Witness (Crypto era))
-> ByteString -> KeyHash 'Witness (Crypto era)
forall a b. (a -> b) -> a -> b
$ ByteString
bytes
  where
    -- The payload hashed to create an addrRoot consists of the following:
    -- 1: a token indicating a list of length 3
    -- 2: the addrType
    -- 3: the key
    -- 3a: token indicating list length 2
    -- 3b: token indicating address type (which will be a vkey address)
    -- 3c: a token indicating a bytestring of length 64
    -- 3d: public key bytes (32)
    -- 3e: chain code bytes (32)
    -- 4: the addrAttributes
    -- the prefix is constant, and hard coded here:
    prefix :: ByteString
    prefix :: ByteString
prefix = ByteString
"\131\00\130\00\88\64"
    -- Here we are reserializing a key which we have previously deserialized.
    -- This is normally naughty. However, this is a blob of bytes -- serializing
    -- it amounts to wrapping the underlying byte array in a ByteString
    -- constructor.
    keyBytes :: ByteString
keyBytes = VerKeyDSIGN (DSIGN (Crypto era)) -> ByteString
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> ByteString
DSIGN.rawSerialiseVerKeyDSIGN VerKeyDSIGN (DSIGN (Crypto era))
key
    bytes :: ByteString
bytes = ByteString
prefix ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
keyBytes ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
cc ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
attributes
    hash_SHA3_256 :: ByteString -> ByteString
    hash_SHA3_256 :: ByteString -> ByteString
hash_SHA3_256 = Proxy SHA3_256 -> ByteString -> ByteString
forall h (proxy :: * -> *).
HashAlgorithm h =>
proxy h -> ByteString -> ByteString
Hash.digest (Proxy SHA3_256
forall k (t :: k). Proxy t
Proxy :: Proxy Hash.SHA3_256)
    hash_crypto :: ByteString -> Hash.Hash (ADDRHASH (Crypto era)) a
    hash_crypto :: ByteString -> Hash (ADDRHASH (Crypto era)) a
hash_crypto = Hash (ADDRHASH (Crypto era)) ByteString
-> Hash (ADDRHASH (Crypto era)) a
forall h a b. Hash h a -> Hash h b
Hash.castHash (Hash (ADDRHASH (Crypto era)) ByteString
 -> Hash (ADDRHASH (Crypto era)) a)
-> (ByteString -> Hash (ADDRHASH (Crypto era)) ByteString)
-> ByteString
-> Hash (ADDRHASH (Crypto era)) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> ByteString)
-> ByteString -> Hash (ADDRHASH (Crypto era)) ByteString
forall h a. HashAlgorithm h => (a -> ByteString) -> a -> Hash h a
Hash.hashWith @(ADDRHASH (Crypto era)) ByteString -> ByteString
forall a. a -> a
id

unpackByronVKey ::
  forall crypto.
  (DSIGN crypto ~ DSIGN.Ed25519DSIGN) =>
  Byron.VerificationKey ->
  (VKey 'Witness crypto, ChainCode)
unpackByronVKey :: VerificationKey -> (VKey 'Witness crypto, ChainCode)
unpackByronVKey
  ( Byron.VerificationKey
      (WC.XPub ByteString
vkeyBytes (WC.ChainCode ByteString
chainCodeBytes))
    ) = case ByteString -> Maybe (VerKeyDSIGN Ed25519DSIGN)
forall v. DSIGNAlgorithm v => ByteString -> Maybe (VerKeyDSIGN v)
DSIGN.rawDeserialiseVerKeyDSIGN ByteString
vkeyBytes of
    -- This maybe is produced by a check that the length of the public key
    -- is the correct one. (32 bytes). If the XPub was constructed correctly,
    -- we already know that it has this length.
    Maybe (VerKeyDSIGN Ed25519DSIGN)
Nothing -> Text -> (VKey 'Witness crypto, ChainCode)
forall a. HasCallStack => Text -> a
panic Text
"unpackByronVKey: impossible!"
    Just VerKeyDSIGN Ed25519DSIGN
vk -> (VerKeyDSIGN (DSIGN crypto) -> VKey 'Witness crypto
forall (kd :: KeyRole) crypto.
VerKeyDSIGN (DSIGN crypto) -> VKey kd crypto
VKey VerKeyDSIGN Ed25519DSIGN
VerKeyDSIGN (DSIGN crypto)
vk, ByteString -> ChainCode
ChainCode ByteString
chainCodeBytes)

verifyBootstrapWit ::
  forall era.
  ( Era era,
    DSIGN.Signable (DSIGN (Crypto era)) (Hash (Crypto era) EraIndependentTxBody)
  ) =>
  Hash (Crypto era) EraIndependentTxBody ->
  BootstrapWitness era ->
  Bool
verifyBootstrapWit :: Hash (Crypto era) EraIndependentTxBody
-> BootstrapWitness era -> Bool
verifyBootstrapWit Hash (Crypto era) EraIndependentTxBody
txbodyHash BootstrapWitness era
witness =
  VKey 'Witness (Crypto era)
-> Hash (Crypto era) EraIndependentTxBody
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> Bool
forall crypto a (kd :: KeyRole).
(Crypto crypto, Signable (DSIGN crypto) a) =>
VKey kd crypto -> a -> SignedDSIGN crypto a -> Bool
verifySignedDSIGN
    (BootstrapWitness era -> Era era => VKey 'Witness (Crypto era)
forall era.
BootstrapWitness era -> Era era => VKey 'Witness (Crypto era)
bwKey BootstrapWitness era
witness)
    Hash (Crypto era) EraIndependentTxBody
txbodyHash
    (SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
coerce (SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
 -> SignedDSIGN
      (Crypto era) (Hash (Crypto era) EraIndependentTxBody))
-> (BootstrapWitness era
    -> SignedDSIGN
         (Crypto era) (Hash (Crypto era) EraIndependentTxBody))
-> BootstrapWitness era
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BootstrapWitness era
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
forall era.
BootstrapWitness era
-> Era era =>
   SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
bwSig (BootstrapWitness era
 -> SignedDSIGN
      (Crypto era) (Hash (Crypto era) EraIndependentTxBody))
-> BootstrapWitness era
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
forall a b. (a -> b) -> a -> b
$ BootstrapWitness era
witness)

coerceSignature :: WC.XSignature -> DSIGN.SigDSIGN DSIGN.Ed25519DSIGN
coerceSignature :: XSignature -> SigDSIGN Ed25519DSIGN
coerceSignature XSignature
sig =
  SigDSIGN Ed25519DSIGN
-> Maybe (SigDSIGN Ed25519DSIGN) -> SigDSIGN Ed25519DSIGN
forall a. a -> Maybe a -> a
fromMaybe (Text -> SigDSIGN Ed25519DSIGN
forall a. HasCallStack => Text -> a
panic Text
"coerceSignature: impossible! signature size mismatch") (Maybe (SigDSIGN Ed25519DSIGN) -> SigDSIGN Ed25519DSIGN)
-> Maybe (SigDSIGN Ed25519DSIGN) -> SigDSIGN Ed25519DSIGN
forall a b. (a -> b) -> a -> b
$
    ByteString -> Maybe (SigDSIGN Ed25519DSIGN)
forall v. DSIGNAlgorithm v => ByteString -> Maybe (SigDSIGN v)
DSIGN.rawDeserialiseSigDSIGN (XSignature -> ByteString
WC.unXSignature XSignature
sig)

makeBootstrapWitness ::
  forall era.
  ( DSIGN (Crypto era) ~ DSIGN.Ed25519DSIGN,
    Era era
  ) =>
  Hash (Crypto era) EraIndependentTxBody ->
  Byron.SigningKey ->
  Byron.Attributes Byron.AddrAttributes ->
  BootstrapWitness era
makeBootstrapWitness :: Hash (Crypto era) EraIndependentTxBody
-> SigningKey -> Attributes AddrAttributes -> BootstrapWitness era
makeBootstrapWitness Hash (Crypto era) EraIndependentTxBody
txBodyHash SigningKey
byronSigningKey Attributes AddrAttributes
addrAttributes =
  VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> BootstrapWitness era
forall era.
Era era =>
VKey 'Witness (Crypto era)
-> SignedDSIGN
     (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
-> ChainCode
-> ByteString
-> BootstrapWitness era
BootstrapWitness VKey 'Witness (Crypto era)
vk SignedDSIGN Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody)
SignedDSIGN (Crypto era) (Hash (Crypto era) EraIndependentTxBody)
signature ChainCode
cc (Attributes AddrAttributes -> ByteString
forall a. ToCBOR a => a -> ByteString
serialize' Attributes AddrAttributes
addrAttributes)
  where
    (VKey 'Witness (Crypto era)
vk, ChainCode
cc) = VerificationKey -> (VKey 'Witness (Crypto era), ChainCode)
forall crypto.
(DSIGN crypto ~ Ed25519DSIGN) =>
VerificationKey -> (VKey 'Witness crypto, ChainCode)
unpackByronVKey (VerificationKey -> (VKey 'Witness (Crypto era), ChainCode))
-> VerificationKey -> (VKey 'Witness (Crypto era), ChainCode)
forall a b. (a -> b) -> a -> b
$ SigningKey -> VerificationKey
Byron.toVerification SigningKey
byronSigningKey
    signature :: SignedDSIGN Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody)
signature =
      SigDSIGN Ed25519DSIGN
-> SignedDSIGN
     Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody)
forall v a. SigDSIGN v -> SignedDSIGN v a
DSIGN.SignedDSIGN (SigDSIGN Ed25519DSIGN
 -> SignedDSIGN
      Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody))
-> (XSignature -> SigDSIGN Ed25519DSIGN)
-> XSignature
-> SignedDSIGN
     Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XSignature -> SigDSIGN Ed25519DSIGN
coerceSignature (XSignature
 -> SignedDSIGN
      Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody))
-> XSignature
-> SignedDSIGN
     Ed25519DSIGN (Hash (Crypto era) EraIndependentTxBody)
forall a b. (a -> b) -> a -> b
$
        ByteString -> XPrv -> ByteString -> XSignature
forall passPhrase msg.
(ByteArrayAccess passPhrase, ByteArrayAccess msg) =>
passPhrase -> XPrv -> msg -> XSignature
WC.sign
          (ByteString
forall a. Monoid a => a
mempty :: ByteString)
          (SigningKey -> XPrv
Byron.unSigningKey SigningKey
byronSigningKey)
          (Hash (Crypto era) EraIndependentTxBody -> ByteString
forall h a. Hash h a -> ByteString
Hash.hashToBytes Hash (Crypto era) EraIndependentTxBody
txBodyHash)