{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}

-- The Shelley ledger uses promoted data kinds which we have to use, but we do
-- not export any from this API. We also use them unticked as nature intended.
{-# LANGUAGE DataKinds #-}
{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}

-- | Complete, signed transactions
--
module Cardano.Api.Tx (

    -- * Signing transactions
    -- | Creating transaction witnesses one by one, or all in one go.
    Tx(.., Tx),
    getTxBody,
    getTxWitnesses,
    ScriptValidity(..),

    -- ** Signing in one go
    ShelleySigningKey(..),
    toShelleySigningKey,
    signByronTransaction,
    signShelleyTransaction,

    -- ** Incremental signing and separate witnesses
    makeSignedTransaction,
    KeyWitness(..),
    makeByronKeyWitness,
    ShelleyWitnessSigningKey(..),
    makeShelleyKeyWitness,
    WitnessNetworkIdOrByronAddress (..),
    makeShelleyBootstrapWitness,
    makeShelleySignature,
    getShelleyKeyWitnessVerificationKey,
    getTxBodyAndWitnesses,

    -- * Data family instances
    AsType(AsTx, AsByronTx, AsShelleyTx, AsMaryTx, AsAllegraTx, AsAlonzoTx,
           AsKeyWitness, AsByronWitness, AsShelleyWitness),
  ) where

import           Data.Maybe

import           Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS

import           Data.Functor.Identity (Identity)
import qualified Data.Map.Strict as Map
import qualified Data.Set as Set
import           Data.Type.Equality (TestEquality (..), (:~:) (Refl))
import qualified Data.Vector as Vector
import           Formatting (build, formatToString)

--
-- Common types, consensus, network
--
import           Cardano.Binary (Annotated (..))
import qualified Cardano.Binary as CBOR

--
-- Crypto API used by consensus and Shelley (and should be used by Byron)
--
import qualified Cardano.Crypto.DSIGN.Class as Crypto
import qualified Cardano.Crypto.Util as Crypto
import qualified Cardano.Crypto.Wallet as Crypto.HD

--
-- Byron imports
--
import qualified Cardano.Chain.Common as Byron
import qualified Cardano.Chain.UTxO as Byron
import qualified Cardano.Crypto.Hashing as Byron
import qualified Cardano.Crypto.ProtocolMagic as Byron
import qualified Cardano.Crypto.Signing as Byron

--
-- Shelley imports
--
import           Cardano.Ledger.BaseTypes (maybeToStrictMaybe, strictMaybeToMaybe)
import           Cardano.Ledger.Crypto (StandardCrypto)

import qualified Cardano.Ledger.Core as Ledger
import qualified Cardano.Ledger.Keys as Shelley
import qualified Cardano.Ledger.Keys.Bootstrap as Shelley
import qualified Cardano.Ledger.SafeHash as Ledger

import qualified Cardano.Ledger.Shelley.API as Ledger (ShelleyTx (..))
import qualified Cardano.Ledger.Shelley.Tx as Shelley

import           Cardano.Ledger.Alonzo (AlonzoScript)
import qualified Cardano.Ledger.Alonzo as Alonzo
import           Cardano.Ledger.Alonzo.Tx (AlonzoTx (AlonzoTx))
import qualified Cardano.Ledger.Alonzo.Tx as Alonzo
import           Cardano.Ledger.Alonzo.TxWitness (TxWitness (TxWitness))
import qualified Cardano.Ledger.Alonzo.TxWitness as Alonzo

import           Cardano.Api.Address
import           Cardano.Api.Certificate
import           Cardano.Api.Eras
import           Cardano.Api.HasTypeProxy
import           Cardano.Api.Keys.Byron
import           Cardano.Api.Keys.Class
import           Cardano.Api.Keys.Shelley
import           Cardano.Api.NetworkId
import           Cardano.Api.SerialiseCBOR
import           Cardano.Api.SerialiseTextEnvelope
import           Cardano.Api.TxBody

-- ----------------------------------------------------------------------------
-- Signed transactions
--

data Tx era where

     ByronTx
       :: Byron.ATxAux ByteString
       -> Tx ByronEra

     ShelleyTx
       :: ShelleyBasedEra era
       -> Ledger.Tx (ShelleyLedgerEra era)
       -> Tx era


instance Show (InAnyCardanoEra Tx) where
    show :: InAnyCardanoEra Tx -> String
show (InAnyCardanoEra CardanoEra era
_ Tx era
tx) = forall a. Show a => a -> String
show Tx era
tx

instance Eq (InAnyCardanoEra Tx) where
    == :: InAnyCardanoEra Tx -> InAnyCardanoEra Tx -> Bool
(==) (InAnyCardanoEra CardanoEra era
eraA Tx era
txA) (InAnyCardanoEra CardanoEra era
eraB Tx era
txB) =
      case forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality CardanoEra era
eraA CardanoEra era
eraB of
        Maybe (era :~: era)
Nothing -> Bool
False
        Just era :~: era
Refl -> Tx era
txA forall a. Eq a => a -> a -> Bool
== Tx era
txB

-- The GADT in the ShelleyTx case requires a custom instance
instance Eq (Tx era) where
    == :: Tx era -> Tx era -> Bool
(==) (ByronTx ATxAux ByteString
txA)
         (ByronTx ATxAux ByteString
txB) = ATxAux ByteString
txA forall a. Eq a => a -> a -> Bool
== ATxAux ByteString
txB

    (==) (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
txA)
         (ShelleyTx ShelleyBasedEra era
_   Tx (ShelleyLedgerEra era)
txB) =
      case ShelleyBasedEra era
era of
        ShelleyBasedEra era
ShelleyBasedEraShelley -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB
        ShelleyBasedEra era
ShelleyBasedEraAllegra -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB
        ShelleyBasedEra era
ShelleyBasedEraMary    -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB
        ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB
        ShelleyBasedEra era
ShelleyBasedEraBabbage -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB
        ShelleyBasedEra era
ShelleyBasedEraConway  -> Tx (ShelleyLedgerEra era)
txA forall a. Eq a => a -> a -> Bool
== Tx (ShelleyLedgerEra era)
txB

    (==) ByronTx{} (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
_) = case ShelleyBasedEra era
era of {}
    (==) (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
_) ByronTx{} = case ShelleyBasedEra era
era of {}

-- The GADT in the ShelleyTx case requires a custom instance
instance Show (Tx era) where
    showsPrec :: Int -> Tx era -> ShowS
showsPrec Int
p (ByronTx ATxAux ByteString
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ByronTx "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ATxAux ByteString
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraShelley Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraShelley "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraAllegra Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraAllegra "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraMary Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraMary "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraAlonzo Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraAlonzo "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraBabbage Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraBabbage "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

    showsPrec Int
p (ShelleyTx ShelleyBasedEra era
ShelleyBasedEraConway Tx (ShelleyLedgerEra era)
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyTx ShelleyBasedEraConway "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Tx (ShelleyLedgerEra era)
tx

instance HasTypeProxy era => HasTypeProxy (Tx era) where
    data AsType (Tx era) = AsTx (AsType era)
    proxyToAsType :: Proxy (Tx era) -> AsType (Tx era)
proxyToAsType Proxy (Tx era)
_ = forall era. AsType era -> AsType (Tx era)
AsTx (forall t. HasTypeProxy t => Proxy t -> AsType t
proxyToAsType (forall {k} (t :: k). Proxy t
Proxy :: Proxy era))

{-# DEPRECATED AsByronTx "Use AsTx AsByronEra instead." #-}
pattern AsByronTx :: AsType (Tx ByronEra)
pattern $bAsByronTx :: AsType (Tx ByronEra)
$mAsByronTx :: forall {r}.
AsType (Tx ByronEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsByronTx = AsTx AsByronEra
{-# COMPLETE AsByronTx #-}

{-# DEPRECATED AsShelleyTx "Use AsTx AsShelleyEra instead." #-}
pattern AsShelleyTx :: AsType (Tx ShelleyEra)
pattern $bAsShelleyTx :: AsType (Tx ShelleyEra)
$mAsShelleyTx :: forall {r}.
AsType (Tx ShelleyEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsShelleyTx = AsTx AsShelleyEra
{-# COMPLETE AsShelleyTx #-}

pattern AsMaryTx :: AsType (Tx MaryEra)
pattern $bAsMaryTx :: AsType (Tx MaryEra)
$mAsMaryTx :: forall {r}.
AsType (Tx MaryEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsMaryTx = AsTx AsMaryEra
{-# COMPLETE AsMaryTx #-}

pattern AsAllegraTx :: AsType (Tx AllegraEra)
pattern $bAsAllegraTx :: AsType (Tx AllegraEra)
$mAsAllegraTx :: forall {r}.
AsType (Tx AllegraEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsAllegraTx = AsTx AsAllegraEra
{-# COMPLETE AsAllegraTx #-}

pattern AsAlonzoTx :: AsType (Tx AlonzoEra)
pattern $bAsAlonzoTx :: AsType (Tx AlonzoEra)
$mAsAlonzoTx :: forall {r}.
AsType (Tx AlonzoEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsAlonzoTx = AsTx AsAlonzoEra
{-# COMPLETE AsAlonzoTx #-}

instance IsCardanoEra era => SerialiseAsCBOR (Tx era) where
    serialiseToCBOR :: Tx era -> ByteString
serialiseToCBOR (ByronTx ATxAux ByteString
tx) = forall t. Decoded t => t -> ByteString
CBOR.recoverBytes ATxAux ByteString
tx

    serialiseToCBOR (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
tx) =
      case ShelleyBasedEra era
era of
        ShelleyBasedEra era
ShelleyBasedEraShelley -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx
        ShelleyBasedEra era
ShelleyBasedEraAllegra -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx
        ShelleyBasedEra era
ShelleyBasedEraMary    -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx
        ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx
        ShelleyBasedEra era
ShelleyBasedEraBabbage -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx
        ShelleyBasedEra era
ShelleyBasedEraConway  -> forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx Tx (ShelleyLedgerEra era)
tx

    deserialiseFromCBOR :: AsType (Tx era) -> ByteString -> Either DecoderError (Tx era)
deserialiseFromCBOR AsType (Tx era)
_ ByteString
bs =
      case forall era. IsCardanoEra era => CardanoEra era
cardanoEra :: CardanoEra era of
        CardanoEra era
ByronEra ->
          ATxAux ByteString -> Tx ByronEra
ByronTx forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
            forall (f :: * -> *).
Functor f =>
Text
-> (forall s. Decoder s (f ByteSpan))
-> ByteString
-> Either DecoderError (f ByteString)
CBOR.decodeFullAnnotatedBytes
              Text
"Byron Tx" forall a s. FromCBOR a => Decoder s a
fromCBOR (ByteString -> ByteString
LBS.fromStrict ByteString
bs)

        -- Use the same derialisation impl, but at different types:
        CardanoEra era
ShelleyEra -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley) ByteString
bs
        CardanoEra era
AllegraEra -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra) ByteString
bs
        CardanoEra era
MaryEra    -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra MaryEra
ShelleyBasedEraMary) ByteString
bs
        CardanoEra era
AlonzoEra  -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo) ByteString
bs
        CardanoEra era
BabbageEra -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage) ByteString
bs
        CardanoEra era
ConwayEra  -> forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx
                        (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra ConwayEra
ShelleyBasedEraConway) ByteString
bs

-- | The serialisation format for the different Shelley-based eras are not the
-- same, but they can be handled generally with one overloaded implementation.
--
serialiseShelleyBasedTx :: ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx :: forall tx. ToCBOR tx => tx -> ByteString
serialiseShelleyBasedTx = forall tx. ToCBOR tx => tx -> ByteString
CBOR.serialize'

deserialiseShelleyBasedTx :: FromCBOR (CBOR.Annotator tx)
                          => (tx -> tx')
                          -> ByteString
                          -> Either CBOR.DecoderError tx'
deserialiseShelleyBasedTx :: forall tx tx'.
FromCBOR (Annotator tx) =>
(tx -> tx') -> ByteString -> Either DecoderError tx'
deserialiseShelleyBasedTx tx -> tx'
mkTx ByteString
bs =
    tx -> tx'
mkTx forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
Text
-> (forall s. Decoder s (Annotator a))
-> ByteString
-> Either DecoderError a
CBOR.decodeAnnotator Text
"Shelley Tx" forall a s. FromCBOR a => Decoder s a
fromCBOR (ByteString -> ByteString
LBS.fromStrict ByteString
bs)


instance IsCardanoEra era => HasTextEnvelope (Tx era) where
    textEnvelopeType :: AsType (Tx era) -> TextEnvelopeType
textEnvelopeType AsType (Tx era)
_ =
      case forall era. IsCardanoEra era => CardanoEra era
cardanoEra :: CardanoEra era of
        CardanoEra era
ByronEra   -> TextEnvelopeType
"TxSignedByron"
        CardanoEra era
ShelleyEra -> TextEnvelopeType
"TxSignedShelley"
        CardanoEra era
AllegraEra -> TextEnvelopeType
"Tx AllegraEra"
        CardanoEra era
MaryEra    -> TextEnvelopeType
"Tx MaryEra"
        CardanoEra era
AlonzoEra  -> TextEnvelopeType
"Tx AlonzoEra"
        CardanoEra era
BabbageEra -> TextEnvelopeType
"Tx BabbageEra"
        CardanoEra era
ConwayEra  -> TextEnvelopeType
"Tx ConwayEra"

data KeyWitness era where

     ByronKeyWitness
       :: Byron.TxInWitness
       -> KeyWitness ByronEra

     ShelleyBootstrapWitness
       :: ShelleyBasedEra era
       -> Shelley.BootstrapWitness StandardCrypto
       -> KeyWitness era

     ShelleyKeyWitness
       :: ShelleyBasedEra era
       -> Shelley.WitVKey Shelley.Witness StandardCrypto
       -> KeyWitness era


-- The GADT in the Shelley cases requires a custom instance
instance Eq (KeyWitness era) where
    == :: KeyWitness era -> KeyWitness era -> Bool
(==) (ByronKeyWitness TxInWitness
wA)
         (ByronKeyWitness TxInWitness
wB) = TxInWitness
wA forall a. Eq a => a -> a -> Bool
== TxInWitness
wB

    (==) (ShelleyBootstrapWitness ShelleyBasedEra era
era BootstrapWitness StandardCrypto
wA)
         (ShelleyBootstrapWitness ShelleyBasedEra era
_   BootstrapWitness StandardCrypto
wB) =
      case ShelleyBasedEra era
era of
        ShelleyBasedEra era
ShelleyBasedEraShelley -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraAllegra -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraMary    -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraBabbage -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraConway -> BootstrapWitness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== BootstrapWitness StandardCrypto
wB

    (==) (ShelleyKeyWitness ShelleyBasedEra era
era WitVKey 'Witness StandardCrypto
wA)
         (ShelleyKeyWitness ShelleyBasedEra era
_   WitVKey 'Witness StandardCrypto
wB) =
      case ShelleyBasedEra era
era of
        ShelleyBasedEra era
ShelleyBasedEraShelley -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraAllegra -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraMary    -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraBabbage -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB
        ShelleyBasedEra era
ShelleyBasedEraConway -> WitVKey 'Witness StandardCrypto
wA forall a. Eq a => a -> a -> Bool
== WitVKey 'Witness StandardCrypto
wB

    (==) KeyWitness era
_ KeyWitness era
_ = Bool
False

-- The GADT in the ShelleyTx case requires a custom instance
--TODO: once we start providing custom patterns we should do the show in terms
-- of those. It'll be less verbose too!
instance Show (KeyWitness era) where
    showsPrec :: Int -> KeyWitness era -> ShowS
showsPrec Int
p (ByronKeyWitness TxInWitness
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ByronKeyWitness "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxInWitness
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraShelley BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraShelley "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraAllegra BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraAllegra "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraMary BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraMary "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraAlonzo BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraAlonzo "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraBabbage BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraBabbage "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyBootstrapWitness ShelleyBasedEra era
ShelleyBasedEraConway BootstrapWitness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyBootstrapWitness ShelleyBasedEraConway "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 BootstrapWitness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraShelley WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraShelley "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraAllegra WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraAllegra "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraMary WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraMary "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraAlonzo WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraAlonzo "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraBabbage WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraBabbage "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

    showsPrec Int
p (ShelleyKeyWitness ShelleyBasedEra era
ShelleyBasedEraConway WitVKey 'Witness StandardCrypto
tx) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11) forall a b. (a -> b) -> a -> b
$
        String -> ShowS
showString String
"ShelleyKeyWitness ShelleyBasedEraConway "
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 WitVKey 'Witness StandardCrypto
tx

instance HasTypeProxy era => HasTypeProxy (KeyWitness era) where
    data AsType (KeyWitness era) = AsKeyWitness (AsType era)
    proxyToAsType :: Proxy (KeyWitness era) -> AsType (KeyWitness era)
proxyToAsType Proxy (KeyWitness era)
_ = forall era. AsType era -> AsType (KeyWitness era)
AsKeyWitness (forall t. HasTypeProxy t => Proxy t -> AsType t
proxyToAsType (forall {k} (t :: k). Proxy t
Proxy :: Proxy era))

pattern AsByronWitness :: AsType (KeyWitness ByronEra)
pattern $bAsByronWitness :: AsType (KeyWitness ByronEra)
$mAsByronWitness :: forall {r}.
AsType (KeyWitness ByronEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsByronWitness   = AsKeyWitness AsByronEra
{-# COMPLETE AsByronWitness #-}

pattern AsShelleyWitness :: AsType (KeyWitness ShelleyEra)
pattern $bAsShelleyWitness :: AsType (KeyWitness ShelleyEra)
$mAsShelleyWitness :: forall {r}.
AsType (KeyWitness ShelleyEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsShelleyWitness = AsKeyWitness AsShelleyEra
{-# COMPLETE AsShelleyWitness #-}

-- This custom instance differs from cardano-ledger
-- because we want to be able to tell the difference between
-- on disk witnesses for the cli's 'assemble' command.
instance IsCardanoEra era => SerialiseAsCBOR (KeyWitness era) where
    serialiseToCBOR :: KeyWitness era -> ByteString
serialiseToCBOR (ByronKeyWitness TxInWitness
wit) = forall tx. ToCBOR tx => tx -> ByteString
CBOR.serialize' TxInWitness
wit

    serialiseToCBOR (ShelleyKeyWitness ShelleyBasedEra era
_era WitVKey 'Witness StandardCrypto
wit) =
      Encoding -> ByteString
CBOR.serializeEncoding' forall a b. (a -> b) -> a -> b
$
      forall w. ToCBOR w => w -> Encoding
encodeShelleyBasedKeyWitness WitVKey 'Witness StandardCrypto
wit

    serialiseToCBOR (ShelleyBootstrapWitness ShelleyBasedEra era
_era BootstrapWitness StandardCrypto
wit) =
      Encoding -> ByteString
CBOR.serializeEncoding' forall a b. (a -> b) -> a -> b
$
      forall w. ToCBOR w => w -> Encoding
encodeShelleyBasedBootstrapWitness BootstrapWitness StandardCrypto
wit

    deserialiseFromCBOR :: AsType (KeyWitness era)
-> ByteString -> Either DecoderError (KeyWitness era)
deserialiseFromCBOR AsType (KeyWitness era)
_ ByteString
bs =
      case forall era. IsCardanoEra era => CardanoEra era
cardanoEra :: CardanoEra era of
        CardanoEra era
ByronEra ->
          TxInWitness -> KeyWitness ByronEra
ByronKeyWitness forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromCBOR a => ByteString -> Either DecoderError a
CBOR.decodeFull' ByteString
bs

        -- Use the same derialisation impl, but at different types:
        CardanoEra era
ShelleyEra -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley ByteString
bs
        CardanoEra era
AllegraEra -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra ByteString
bs
        CardanoEra era
MaryEra    -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra MaryEra
ShelleyBasedEraMary    ByteString
bs
        CardanoEra era
AlonzoEra  -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo  ByteString
bs
        CardanoEra era
BabbageEra -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage ByteString
bs
        CardanoEra era
ConwayEra  -> forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra ConwayEra
ShelleyBasedEraConway ByteString
bs


encodeShelleyBasedKeyWitness :: ToCBOR w => w -> CBOR.Encoding
encodeShelleyBasedKeyWitness :: forall w. ToCBOR w => w -> Encoding
encodeShelleyBasedKeyWitness w
wit =
    Word -> Encoding
CBOR.encodeListLen Word
2 forall a. Semigroup a => a -> a -> a
<> Word -> Encoding
CBOR.encodeWord Word
0 forall a. Semigroup a => a -> a -> a
<> forall w. ToCBOR w => w -> Encoding
toCBOR w
wit

encodeShelleyBasedBootstrapWitness :: ToCBOR w => w -> CBOR.Encoding
encodeShelleyBasedBootstrapWitness :: forall w. ToCBOR w => w -> Encoding
encodeShelleyBasedBootstrapWitness w
wit =
    Word -> Encoding
CBOR.encodeListLen Word
2 forall a. Semigroup a => a -> a -> a
<> Word -> Encoding
CBOR.encodeWord Word
1 forall a. Semigroup a => a -> a -> a
<> forall w. ToCBOR w => w -> Encoding
toCBOR w
wit

decodeShelleyBasedWitness :: forall era.
                             ShelleyBasedEra era
                          -> ByteString
                          -> Either CBOR.DecoderError (KeyWitness era)
decodeShelleyBasedWitness :: forall era.
ShelleyBasedEra era
-> ByteString -> Either DecoderError (KeyWitness era)
decodeShelleyBasedWitness ShelleyBasedEra era
era =
    forall a.
Text
-> (forall s. Decoder s (Annotator a))
-> ByteString
-> Either DecoderError a
CBOR.decodeAnnotator Text
"Shelley Witness" forall s. Decoder s (Annotator (KeyWitness era))
decode forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
LBS.fromStrict
  where
    decode :: CBOR.Decoder s (CBOR.Annotator (KeyWitness era))
    decode :: forall s. Decoder s (Annotator (KeyWitness era))
decode =  do
      forall s. Int -> Decoder s ()
CBOR.decodeListLenOf Int
2
      Word
t <- forall s. Decoder s Word
CBOR.decodeWord
      case Word
t of
        Word
0 -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall era.
ShelleyBasedEra era
-> WitVKey 'Witness StandardCrypto -> KeyWitness era
ShelleyKeyWitness ShelleyBasedEra era
era)) forall a s. FromCBOR a => Decoder s a
fromCBOR
        Word
1 -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall era.
ShelleyBasedEra era
-> BootstrapWitness StandardCrypto -> KeyWitness era
ShelleyBootstrapWitness ShelleyBasedEra era
era)) forall a s. FromCBOR a => Decoder s a
fromCBOR
        Word
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Format String a -> a
formatToString forall a r. Buildable a => Format r (a -> r)
build forall a b. (a -> b) -> a -> b
$ Text -> Word8 -> DecoderError
CBOR.DecoderErrorUnknownTag
                                Text
"Shelley Witness" (forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
t)


instance IsCardanoEra era => HasTextEnvelope (KeyWitness era) where
    textEnvelopeType :: AsType (KeyWitness era) -> TextEnvelopeType
textEnvelopeType AsType (KeyWitness era)
_ =
      case forall era. IsCardanoEra era => CardanoEra era
cardanoEra :: CardanoEra era of
        CardanoEra era
ByronEra   -> TextEnvelopeType
"TxWitnessByron"
        CardanoEra era
ShelleyEra -> TextEnvelopeType
"TxWitness ShelleyEra"
        CardanoEra era
AllegraEra -> TextEnvelopeType
"TxWitness AllegraEra"
        CardanoEra era
MaryEra    -> TextEnvelopeType
"TxWitness MaryEra"
        CardanoEra era
AlonzoEra  -> TextEnvelopeType
"TxWitness AlonzoEra"
        CardanoEra era
BabbageEra -> TextEnvelopeType
"TxWitness BabbageEra"
        CardanoEra era
ConwayEra  -> TextEnvelopeType
"TxWitness ConwayEra"

pattern Tx :: TxBody era -> [KeyWitness era] -> Tx era
pattern $bTx :: forall era. TxBody era -> [KeyWitness era] -> Tx era
$mTx :: forall {r} {era}.
Tx era
-> (TxBody era -> [KeyWitness era] -> r) -> ((# #) -> r) -> r
Tx txbody ws <- (getTxBodyAndWitnesses -> (txbody, ws))
  where
    Tx TxBody era
txbody [KeyWitness era]
ws = forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction [KeyWitness era]
ws TxBody era
txbody
{-# COMPLETE Tx #-}

getTxBodyAndWitnesses :: Tx era -> (TxBody era, [KeyWitness era])
getTxBodyAndWitnesses :: forall era. Tx era -> (TxBody era, [KeyWitness era])
getTxBodyAndWitnesses Tx era
tx = (forall era. Tx era -> TxBody era
getTxBody Tx era
tx, forall era. Tx era -> [KeyWitness era]
getTxWitnesses Tx era
tx)

getTxBody :: forall era. Tx era -> TxBody era
getTxBody :: forall era. Tx era -> TxBody era
getTxBody (ByronTx Byron.ATxAux { aTaTx :: forall a. ATxAux a -> Annotated Tx a
Byron.aTaTx = Annotated Tx ByteString
txbody }) =
    Annotated Tx ByteString -> TxBody ByronEra
ByronTxBody Annotated Tx ByteString
txbody

getTxBody (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
tx) =
    case ShelleyBasedEra era
era of
      ShelleyBasedEra era
ShelleyBasedEraShelley -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 EraTx ledgerera) =>
ShelleyTx ledgerera -> TxBody era
getShelleyTxBody Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraAllegra -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 EraTx ledgerera) =>
ShelleyTx ledgerera -> TxBody era
getShelleyTxBody Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraMary    -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 EraTx ledgerera) =>
ShelleyTx ledgerera -> TxBody era
getShelleyTxBody Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraAlonzo  ->
        forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera, Era ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera) =>
ScriptDataSupportedInEra era
-> TxScriptValiditySupportedInEra era
-> AlonzoTx ledgerera
-> TxBody era
getAlonzoTxBody ScriptDataSupportedInEra AlonzoEra
ScriptDataInAlonzoEra TxScriptValiditySupportedInEra AlonzoEra
TxScriptValiditySupportedInAlonzoEra Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraBabbage ->
        forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera, Era ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera) =>
ScriptDataSupportedInEra era
-> TxScriptValiditySupportedInEra era
-> AlonzoTx ledgerera
-> TxBody era
getAlonzoTxBody ScriptDataSupportedInEra BabbageEra
ScriptDataInBabbageEra TxScriptValiditySupportedInEra BabbageEra
TxScriptValiditySupportedInBabbageEra Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraConway ->
        forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera, Era ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera) =>
ScriptDataSupportedInEra era
-> TxScriptValiditySupportedInEra era
-> AlonzoTx ledgerera
-> TxBody era
getAlonzoTxBody ScriptDataSupportedInEra ConwayEra
ScriptDataInConwayEra TxScriptValiditySupportedInEra ConwayEra
TxScriptValiditySupportedInConwayEra Tx (ShelleyLedgerEra era)
tx
  where
    getShelleyTxBody :: forall ledgerera.
                        ShelleyLedgerEra era ~ ledgerera
                     => Ledger.Witnesses ledgerera ~ Shelley.WitnessSetHKD Identity ledgerera
                     => Ledger.EraTx ledgerera
                     => Ledger.ShelleyTx ledgerera
                     -> TxBody era
    getShelleyTxBody :: forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 EraTx ledgerera) =>
ShelleyTx ledgerera -> TxBody era
getShelleyTxBody Ledger.ShelleyTx {
                       body :: forall era. EraTx era => ShelleyTx era -> TxBody era
Shelley.body       = TxBody ledgerera
txbody,
                       auxiliaryData :: forall era.
EraTx era =>
ShelleyTx era -> StrictMaybe (AuxiliaryData era)
Shelley.auxiliaryData = StrictMaybe (AuxiliaryData ledgerera)
txAuxiliaryData,
                       wits :: forall era. EraTx era => ShelleyTx era -> Witnesses era
Shelley.wits = Shelley.WitnessSet
                                              Set (WitVKey 'Witness (Crypto ledgerera))
_addrWits
                                               Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
msigWits
                                              Set (BootstrapWitness (Crypto ledgerera))
_bootWits
                     } =
      forall era.
ShelleyBasedEra era
-> TxBody (ShelleyLedgerEra era)
-> [Script (ShelleyLedgerEra era)]
-> TxBodyScriptData era
-> Maybe (AuxiliaryData (ShelleyLedgerEra era))
-> TxScriptValidity era
-> TxBody era
ShelleyTxBody ShelleyBasedEra era
era TxBody ledgerera
txbody
                    (forall k a. Map k a -> [a]
Map.elems Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
msigWits)
                    forall era. TxBodyScriptData era
TxBodyNoScriptData
                    (forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe (AuxiliaryData ledgerera)
txAuxiliaryData)
                    forall era. TxScriptValidity era
TxScriptValidityNone

    getAlonzoTxBody :: forall ledgerera.
                       ShelleyLedgerEra era ~ ledgerera
                    => Ledger.Era ledgerera
                    => Ledger.Script ledgerera ~ AlonzoScript ledgerera
                    => ScriptDataSupportedInEra era
                    -> TxScriptValiditySupportedInEra era
                    -> AlonzoTx ledgerera
                    -> TxBody era
    getAlonzoTxBody :: forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera, Era ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera) =>
ScriptDataSupportedInEra era
-> TxScriptValiditySupportedInEra era
-> AlonzoTx ledgerera
-> TxBody era
getAlonzoTxBody ScriptDataSupportedInEra era
scriptDataInEra TxScriptValiditySupportedInEra era
txScriptValidityInEra
                    AlonzoTx {
                      body :: forall era. AlonzoTx era -> TxBody era
Alonzo.body = TxBody ledgerera
txbody,
                      wits :: forall era. AlonzoTx era -> TxWitness era
Alonzo.wits = TxWitness
                                     Set (WitVKey 'Witness (Crypto ledgerera))
_addrWits
                                     Set (BootstrapWitness (Crypto ledgerera))
_bootWits
                                     Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
txscripts
                                     TxDats ledgerera
txdats
                                     Redeemers ledgerera
redeemers,
                      auxiliaryData :: forall era. AlonzoTx era -> StrictMaybe (AuxiliaryData era)
Alonzo.auxiliaryData = StrictMaybe (AuxiliaryData ledgerera)
auxiliaryData,
                      isValid :: forall era. AlonzoTx era -> IsValid
Alonzo.isValid = IsValid
isValid
                    } =
      forall era.
ShelleyBasedEra era
-> TxBody (ShelleyLedgerEra era)
-> [Script (ShelleyLedgerEra era)]
-> TxBodyScriptData era
-> Maybe (AuxiliaryData (ShelleyLedgerEra era))
-> TxScriptValidity era
-> TxBody era
ShelleyTxBody ShelleyBasedEra era
era TxBody ledgerera
txbody
                    (forall k a. Map k a -> [a]
Map.elems Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
txscripts)
                    (forall era.
ScriptDataSupportedInEra era
-> TxDats (ShelleyLedgerEra era)
-> Redeemers (ShelleyLedgerEra era)
-> TxBodyScriptData era
TxBodyScriptData ScriptDataSupportedInEra era
scriptDataInEra TxDats ledgerera
txdats Redeemers ledgerera
redeemers)
                    (forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe (AuxiliaryData ledgerera)
auxiliaryData)
                    (forall era.
TxScriptValiditySupportedInEra era
-> ScriptValidity -> TxScriptValidity era
TxScriptValidity TxScriptValiditySupportedInEra era
txScriptValidityInEra (IsValid -> ScriptValidity
isValidToScriptValidity IsValid
isValid))

getTxWitnesses :: forall era. Tx era -> [KeyWitness era]
getTxWitnesses :: forall era. Tx era -> [KeyWitness era]
getTxWitnesses (ByronTx Byron.ATxAux { aTaWitness :: forall a. ATxAux a -> Annotated TxWitness a
Byron.aTaWitness = Annotated TxWitness ByteString
witnesses }) =
    forall a b. (a -> b) -> [a] -> [b]
map TxInWitness -> KeyWitness ByronEra
ByronKeyWitness
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
Vector.toList
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. Annotated b a -> b
unAnnotated
  forall a b. (a -> b) -> a -> b
$ Annotated TxWitness ByteString
witnesses

getTxWitnesses (ShelleyTx ShelleyBasedEra era
era Tx (ShelleyLedgerEra era)
tx) =
    case ShelleyBasedEra era
era of
      ShelleyBasedEra era
ShelleyBasedEraShelley -> forall ledgerera.
(EraTx ledgerera, Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera) =>
ShelleyTx ledgerera -> [KeyWitness era]
getShelleyTxWitnesses Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraAllegra -> forall ledgerera.
(EraTx ledgerera, Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera) =>
ShelleyTx ledgerera -> [KeyWitness era]
getShelleyTxWitnesses Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraMary    -> forall ledgerera.
(EraTx ledgerera, Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera) =>
ShelleyTx ledgerera -> [KeyWitness era]
getShelleyTxWitnesses Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> forall ledgerera.
(Crypto ledgerera ~ StandardCrypto,
 Script ledgerera ~ AlonzoScript ledgerera, Era ledgerera) =>
AlonzoTx ledgerera -> [KeyWitness era]
getAlonzoTxWitnesses  Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraBabbage -> forall ledgerera.
(Crypto ledgerera ~ StandardCrypto,
 Script ledgerera ~ AlonzoScript ledgerera, Era ledgerera) =>
AlonzoTx ledgerera -> [KeyWitness era]
getAlonzoTxWitnesses  Tx (ShelleyLedgerEra era)
tx
      ShelleyBasedEra era
ShelleyBasedEraConway  -> forall ledgerera.
(Crypto ledgerera ~ StandardCrypto,
 Script ledgerera ~ AlonzoScript ledgerera, Era ledgerera) =>
AlonzoTx ledgerera -> [KeyWitness era]
getAlonzoTxWitnesses  Tx (ShelleyLedgerEra era)
tx
  where
    getShelleyTxWitnesses :: forall ledgerera.
                             Ledger.EraTx ledgerera
                          => Ledger.Crypto ledgerera ~ StandardCrypto
                          => Ledger.Witnesses ledgerera ~ Shelley.WitnessSetHKD Identity ledgerera
                          => Ledger.ShelleyTx ledgerera
                          -> [KeyWitness era]
    getShelleyTxWitnesses :: forall ledgerera.
(EraTx ledgerera, Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera) =>
ShelleyTx ledgerera -> [KeyWitness era]
getShelleyTxWitnesses Ledger.ShelleyTx {
                            wits :: forall era. EraTx era => ShelleyTx era -> Witnesses era
Shelley.wits =
                              Shelley.WitnessSet
                                Set (WitVKey 'Witness (Crypto ledgerera))
addrWits
                               Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
_msigWits
                                Set (BootstrapWitness (Crypto ledgerera))
bootWits
                          } =
        forall a b. (a -> b) -> [a] -> [b]
map (forall era.
ShelleyBasedEra era
-> BootstrapWitness StandardCrypto -> KeyWitness era
ShelleyBootstrapWitness ShelleyBasedEra era
era) (forall a. Set a -> [a]
Set.elems Set (BootstrapWitness (Crypto ledgerera))
bootWits)
     forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall era.
ShelleyBasedEra era
-> WitVKey 'Witness StandardCrypto -> KeyWitness era
ShelleyKeyWitness       ShelleyBasedEra era
era) (forall a. Set a -> [a]
Set.elems Set (WitVKey 'Witness (Crypto ledgerera))
addrWits)

    getAlonzoTxWitnesses :: forall ledgerera.
                            Ledger.Crypto ledgerera ~ StandardCrypto
                         => Ledger.Script ledgerera ~ Alonzo.AlonzoScript ledgerera
                         => Ledger.Era ledgerera
                         => AlonzoTx ledgerera
                         -> [KeyWitness era]
    getAlonzoTxWitnesses :: forall ledgerera.
(Crypto ledgerera ~ StandardCrypto,
 Script ledgerera ~ AlonzoScript ledgerera, Era ledgerera) =>
AlonzoTx ledgerera -> [KeyWitness era]
getAlonzoTxWitnesses AlonzoTx {
                           wits :: forall era. AlonzoTx era -> TxWitness era
Alonzo.wits =
                             TxWitness
                               Set (WitVKey 'Witness (Crypto ledgerera))
addrWits
                               Set (BootstrapWitness (Crypto ledgerera))
bootWits
                               Map (ScriptHash (Crypto ledgerera)) (Script ledgerera)
_txscripts
                               TxDats ledgerera
_txdats
                               Redeemers ledgerera
_txrdmrs
                         } =
        forall a b. (a -> b) -> [a] -> [b]
map (forall era.
ShelleyBasedEra era
-> BootstrapWitness StandardCrypto -> KeyWitness era
ShelleyBootstrapWitness ShelleyBasedEra era
era) (forall a. Set a -> [a]
Set.elems Set (BootstrapWitness (Crypto ledgerera))
bootWits)
     forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall era.
ShelleyBasedEra era
-> WitVKey 'Witness StandardCrypto -> KeyWitness era
ShelleyKeyWitness       ShelleyBasedEra era
era) (forall a. Set a -> [a]
Set.elems Set (WitVKey 'Witness (Crypto ledgerera))
addrWits)

makeSignedTransaction :: forall era.
     [KeyWitness era]
  -> TxBody era
  -> Tx era
makeSignedTransaction :: forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction [KeyWitness era]
witnesses (ByronTxBody Annotated Tx ByteString
txbody) =
    ATxAux ByteString -> Tx ByronEra
ByronTx
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxAux -> ATxAux ByteString
Byron.annotateTxAux
  forall a b. (a -> b) -> a -> b
$ Tx -> TxWitness -> TxAux
Byron.mkTxAux
      (forall b a. Annotated b a -> b
unAnnotated Annotated Tx ByteString
txbody)
      (forall a. [a] -> Vector a
Vector.fromList [ TxInWitness
w | ByronKeyWitness TxInWitness
w <- [KeyWitness era]
witnesses ])

makeSignedTransaction [KeyWitness era]
witnesses (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
txbody
                                               [Script (ShelleyLedgerEra era)]
txscripts
                                               TxBodyScriptData era
txscriptdata
                                               Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
                                               TxScriptValidity era
scriptValidity
                                               ) =
    case ShelleyBasedEra era
era of
      ShelleyBasedEra era
ShelleyBasedEraShelley -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 Tx ledgerera ~ ShelleyTx ledgerera, EraTx ledgerera) =>
TxBody ledgerera -> Tx era
makeShelleySignedTransaction TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraAllegra -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 Tx ledgerera ~ ShelleyTx ledgerera, EraTx ledgerera) =>
TxBody ledgerera -> Tx era
makeShelleySignedTransaction TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraMary    -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 Tx ledgerera ~ ShelleyTx ledgerera, EraTx ledgerera) =>
TxBody ledgerera -> Tx era
makeShelleySignedTransaction TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Tx ledgerera ~ AlonzoTx ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera, EraScript ledgerera) =>
TxBody ledgerera -> Tx era
makeAlonzoSignedTransaction  TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraBabbage -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Tx ledgerera ~ AlonzoTx ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera, EraScript ledgerera) =>
TxBody ledgerera -> Tx era
makeAlonzoSignedTransaction  TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraConway  -> forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Tx ledgerera ~ AlonzoTx ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera, EraScript ledgerera) =>
TxBody ledgerera -> Tx era
makeAlonzoSignedTransaction  TxBody (ShelleyLedgerEra era)
txbody
  where
    makeShelleySignedTransaction
      :: forall ledgerera.
         ShelleyLedgerEra era ~ ledgerera
      => Ledger.Crypto ledgerera ~ StandardCrypto
      => Ledger.Witnesses ledgerera ~ Shelley.WitnessSetHKD Identity ledgerera
      => Ledger.Tx ledgerera ~ Ledger.ShelleyTx ledgerera
      => Ledger.EraTx ledgerera
      => Ledger.TxBody ledgerera
      -> Tx era
    makeShelleySignedTransaction :: forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Witnesses ledgerera ~ WitnessSetHKD Identity ledgerera,
 Tx ledgerera ~ ShelleyTx ledgerera, EraTx ledgerera) =>
TxBody ledgerera -> Tx era
makeShelleySignedTransaction TxBody ledgerera
txbody' =
      forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra era
era forall a b. (a -> b) -> a -> b
$
        forall era.
EraTx era =>
TxBody era
-> Witnesses era
-> StrictMaybe (AuxiliaryData era)
-> ShelleyTx era
Ledger.ShelleyTx
          TxBody ledgerera
txbody'
          (forall era.
EraScript era =>
Set (WitVKey 'Witness (Crypto era))
-> Map (ScriptHash (Crypto era)) (Script era)
-> Set (BootstrapWitness (Crypto era))
-> WitnessSet era
Shelley.WitnessSet
            (forall a. Ord a => [a] -> Set a
Set.fromList [ WitVKey 'Witness StandardCrypto
w | ShelleyKeyWitness ShelleyBasedEra era
_ WitVKey 'Witness StandardCrypto
w <- [KeyWitness era]
witnesses ])
            (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (forall era. EraScript era => Script era -> ScriptHash (Crypto era)
Ledger.hashScript @ledgerera Script ledgerera
sw, Script ledgerera
sw)
                          | Script ledgerera
sw <- [Script (ShelleyLedgerEra era)]
txscripts ])
            (forall a. Ord a => [a] -> Set a
Set.fromList [ BootstrapWitness StandardCrypto
w | ShelleyBootstrapWitness ShelleyBasedEra era
_ BootstrapWitness StandardCrypto
w <- [KeyWitness era]
witnesses ]))
          (forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata)

    makeAlonzoSignedTransaction
      :: forall ledgerera.
         ShelleyLedgerEra era ~ ledgerera
      => Ledger.Crypto ledgerera ~ StandardCrypto
      => Ledger.Tx ledgerera ~ AlonzoTx ledgerera
      => Ledger.Script ledgerera ~ AlonzoScript ledgerera
      => Ledger.EraScript ledgerera
      => Ledger.TxBody ledgerera
      -> Tx era
    makeAlonzoSignedTransaction :: forall ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto,
 Tx ledgerera ~ AlonzoTx ledgerera,
 Script ledgerera ~ AlonzoScript ledgerera, EraScript ledgerera) =>
TxBody ledgerera -> Tx era
makeAlonzoSignedTransaction TxBody ledgerera
txbody' =
      forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra era
era forall a b. (a -> b) -> a -> b
$
        forall era.
TxBody era
-> TxWitness era
-> IsValid
-> StrictMaybe (AuxiliaryData era)
-> AlonzoTx era
AlonzoTx
          TxBody ledgerera
txbody'
          (forall era.
(Era era, Script era ~ AlonzoScript era) =>
Set (WitVKey 'Witness (Crypto era))
-> Set (BootstrapWitness (Crypto era))
-> Map (ScriptHash (Crypto era)) (Script era)
-> TxDats era
-> Redeemers era
-> TxWitness era
TxWitness
            (forall a. Ord a => [a] -> Set a
Set.fromList [ WitVKey 'Witness StandardCrypto
w | ShelleyKeyWitness ShelleyBasedEra era
_ WitVKey 'Witness StandardCrypto
w <- [KeyWitness era]
witnesses ])
            (forall a. Ord a => [a] -> Set a
Set.fromList [ BootstrapWitness StandardCrypto
w | ShelleyBootstrapWitness ShelleyBasedEra era
_ BootstrapWitness StandardCrypto
w <- [KeyWitness era]
witnesses ])
            (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (forall era. EraScript era => Script era -> ScriptHash (Crypto era)
Ledger.hashScript @ledgerera AlonzoScript ledgerera
sw, AlonzoScript ledgerera
sw)
                          | AlonzoScript ledgerera
sw <- [Script (ShelleyLedgerEra era)]
txscripts ])
            TxDats ledgerera
datums
            Redeemers ledgerera
redeemers)
          (forall era. TxScriptValidity era -> IsValid
txScriptValidityToIsValid TxScriptValidity era
scriptValidity)
          (forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata)
      where
        (TxDats ledgerera
datums, Redeemers ledgerera
redeemers) =
          case TxBodyScriptData era
txscriptdata of
            TxBodyScriptData ScriptDataSupportedInEra era
_ TxDats (ShelleyLedgerEra era)
ds Redeemers (ShelleyLedgerEra era)
rs -> (TxDats (ShelleyLedgerEra era)
ds, Redeemers (ShelleyLedgerEra era)
rs)
            TxBodyScriptData era
TxBodyNoScriptData       -> (forall a. Monoid a => a
mempty, forall era.
Era era =>
Map RdmrPtr (Data era, ExUnits) -> Redeemers era
Alonzo.Redeemers forall a. Monoid a => a
mempty)

makeByronKeyWitness :: forall key.
                       IsByronKey key
                    => NetworkId
                    -> TxBody ByronEra
                    -> SigningKey key
                    -> KeyWitness ByronEra
makeByronKeyWitness :: forall key.
IsByronKey key =>
NetworkId
-> TxBody ByronEra -> SigningKey key -> KeyWitness ByronEra
makeByronKeyWitness NetworkId
_ (ShelleyTxBody ShelleyBasedEra ByronEra
era TxBody (ShelleyLedgerEra ByronEra)
_ [Script (ShelleyLedgerEra ByronEra)]
_ TxBodyScriptData ByronEra
_ Maybe (AuxiliaryData (ShelleyLedgerEra ByronEra))
_ TxScriptValidity ByronEra
_) = case ShelleyBasedEra ByronEra
era of {}
makeByronKeyWitness NetworkId
nw (ByronTxBody Annotated Tx ByteString
txbody) =
    let txhash :: Byron.Hash Byron.Tx
        txhash :: Hash Tx
txhash = forall t. Decoded t => t -> Hash (BaseType t)
Byron.hashDecoded Annotated Tx ByteString
txbody

        pm :: Byron.ProtocolMagicId
        pm :: ProtocolMagicId
pm = NetworkId -> ProtocolMagicId
toByronProtocolMagicId NetworkId
nw

        -- To allow sharing of the txhash computation across many signatures we
        -- define and share the txhash outside the lambda for the signing key:
     in case forall key. IsByronKey key => ByronKeyFormat key
byronKeyFormat :: ByronKeyFormat key of
          ByronKeyFormat key
ByronLegacyKeyFormat ->
            \(ByronSigningKeyLegacy SigningKey
sk) -> SigningKey -> ProtocolMagicId -> Hash Tx -> KeyWitness ByronEra
witness SigningKey
sk ProtocolMagicId
pm Hash Tx
txhash
          ByronKeyFormat key
ByronModernKeyFormat ->
            \(ByronSigningKey SigningKey
sk) -> SigningKey -> ProtocolMagicId -> Hash Tx -> KeyWitness ByronEra
witness SigningKey
sk ProtocolMagicId
pm Hash Tx
txhash
 where
   witness :: Byron.SigningKey
           -> Byron.ProtocolMagicId
           -> Byron.Hash Byron.Tx
           -> KeyWitness ByronEra
   witness :: SigningKey -> ProtocolMagicId -> Hash Tx -> KeyWitness ByronEra
witness SigningKey
sk ProtocolMagicId
pm Hash Tx
txHash =
     TxInWitness -> KeyWitness ByronEra
ByronKeyWitness forall a b. (a -> b) -> a -> b
$
       VerificationKey -> TxSig -> TxInWitness
Byron.VKWitness
         (SigningKey -> VerificationKey
Byron.toVerification SigningKey
sk)
         (forall a.
ToCBOR a =>
ProtocolMagicId -> SignTag -> SigningKey -> a -> Signature a
Byron.sign ProtocolMagicId
pm SignTag
Byron.SignTx SigningKey
sk (Hash Tx -> TxSigData
Byron.TxSigData Hash Tx
txHash))

-- | Either a network ID or a Byron address to be used in constructing a
-- Shelley bootstrap witness.
data WitnessNetworkIdOrByronAddress
  = WitnessNetworkId !NetworkId
  -- ^ Network ID.
  --
  -- If this value is used in the construction of a Shelley bootstrap witness,
  -- the result will not consist of a derivation path. If that is required,
  -- specify a 'WitnessByronAddress' value instead.
  | WitnessByronAddress !(Address ByronAddr)
  -- ^ Byron address.
  --
  -- If this value is used in the construction of a Shelley bootstrap witness,
  -- both the network ID and derivation path will be extracted from the
  -- address and used in the construction of the witness.

makeShelleyBootstrapWitness :: forall era.
                               IsShelleyBasedEra era
                            => WitnessNetworkIdOrByronAddress
                            -> TxBody era
                            -> SigningKey ByronKey
                            -> KeyWitness era
makeShelleyBootstrapWitness :: forall era.
IsShelleyBasedEra era =>
WitnessNetworkIdOrByronAddress
-> TxBody era -> SigningKey ByronKey -> KeyWitness era
makeShelleyBootstrapWitness WitnessNetworkIdOrByronAddress
_ ByronTxBody{} SigningKey ByronKey
_ =
    case forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of {}

makeShelleyBootstrapWitness WitnessNetworkIdOrByronAddress
nwOrAddr (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
_ TxBodyScriptData era
_ Maybe (AuxiliaryData (ShelleyLedgerEra era))
_ TxScriptValidity era
_) SigningKey ByronKey
sk =
    case ShelleyBasedEra era
era of
      ShelleyBasedEra era
ShelleyBasedEraShelley ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk
      ShelleyBasedEra era
ShelleyBasedEraAllegra ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk
      ShelleyBasedEra era
ShelleyBasedEraMary    ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk
      ShelleyBasedEra era
ShelleyBasedEraAlonzo  ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk
      ShelleyBasedEra era
ShelleyBasedEraBabbage ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk
      ShelleyBasedEra era
ShelleyBasedEraConway ->
        forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody SigningKey ByronKey
sk


makeShelleyBasedBootstrapWitness :: forall era.
                                    (Ledger.HashAnnotated
                                       (Ledger.TxBody (ShelleyLedgerEra era))
                                       Ledger.EraIndependentTxBody
                                       StandardCrypto)
                                 => ShelleyBasedEra era
                                 -> WitnessNetworkIdOrByronAddress
                                 -> Ledger.TxBody (ShelleyLedgerEra era)
                                 -> SigningKey ByronKey
                                 -> KeyWitness era
makeShelleyBasedBootstrapWitness :: forall era.
HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody (ShelleyLedgerEra era)
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBasedBootstrapWitness ShelleyBasedEra era
era WitnessNetworkIdOrByronAddress
nwOrAddr TxBody (ShelleyLedgerEra era)
txbody (ByronSigningKey SigningKey
sk) =
    forall era.
ShelleyBasedEra era
-> BootstrapWitness StandardCrypto -> KeyWitness era
ShelleyBootstrapWitness ShelleyBasedEra era
era forall a b. (a -> b) -> a -> b
$
      -- Byron era witnesses were weird. This reveals all that weirdness.
      Shelley.BootstrapWitness {
        bwKey :: VKey 'Witness StandardCrypto
Shelley.bwKey        = VKey 'Witness StandardCrypto
vk,
        bwSig :: SignedDSIGN
  StandardCrypto (Hash StandardCrypto EraIndependentTxBody)
Shelley.bwSig        = SignedDSIGN
  StandardCrypto (Hash StandardCrypto EraIndependentTxBody)
signature,
        bwChainCode :: ChainCode
Shelley.bwChainCode  = ChainCode
chainCode,
        bwAttributes :: ByteString
Shelley.bwAttributes = ByteString
attributes
      }
  where
    -- Starting with the easy bits: we /can/ convert the Byron verification key
    -- to a the pair of a Shelley verification key plus the chain code.
    --
    (VKey 'Witness StandardCrypto
vk, ChainCode
chainCode) = forall crypto.
(DSIGN crypto ~ Ed25519DSIGN) =>
VerificationKey -> (VKey 'Witness crypto, ChainCode)
Shelley.unpackByronVKey (SigningKey -> VerificationKey
Byron.toVerification SigningKey
sk)

    -- Now the hairy bits.
    --
    -- Byron era signing keys were all /extended/ ed25519 keys. We have to
    -- produce a signature using this extended signing key directly. They
    -- /cannot/ be converted to a plain (non-extended) signing keys. Since we
    -- now support extended signing keys for the Shelley too, we are able to
    -- reuse that here.
    --
    signature :: Shelley.SignedDSIGN StandardCrypto
                  (Shelley.Hash StandardCrypto Ledger.EraIndependentTxBody)
    signature :: SignedDSIGN
  StandardCrypto (Hash StandardCrypto EraIndependentTxBody)
signature = forall tosign.
SignableRepresentation tosign =>
tosign -> ShelleySigningKey -> SignedDSIGN StandardCrypto tosign
makeShelleySignature
                  Hash StandardCrypto EraIndependentTxBody
txhash
                  -- Make the signature with the extended key directly:
                  (XPrv -> ShelleySigningKey
ShelleyExtendedSigningKey (SigningKey -> XPrv
Byron.unSigningKey SigningKey
sk))

    txhash :: Shelley.Hash StandardCrypto Ledger.EraIndependentTxBody
    txhash :: Hash StandardCrypto EraIndependentTxBody
txhash = forall crypto i. SafeHash crypto i -> Hash (HASH crypto) i
Ledger.extractHash (forall c i x.
(HasAlgorithm c, HashAnnotated x i c) =>
x -> SafeHash c i
Ledger.hashAnnotated TxBody (ShelleyLedgerEra era)
txbody)
    --TODO: use Shelley.eraIndTxBodyHash txbody once that function has a
    -- suitably general type.

    -- And finally we need to provide the extra suffix bytes necessary to
    -- reconstruct the mini-Merkel tree that is a Byron address. The suffix
    -- bytes are the serialised address attributes.
    attributes :: ByteString
attributes =
      forall tx. ToCBOR tx => tx -> ByteString
CBOR.serialize' forall a b. (a -> b) -> a -> b
$
        forall h. h -> Attributes h
Byron.mkAttributes Byron.AddrAttributes {
          aaVKDerivationPath :: Maybe HDAddressPayload
Byron.aaVKDerivationPath = Maybe HDAddressPayload
derivationPath,
          aaNetworkMagic :: NetworkMagic
Byron.aaNetworkMagic     = NetworkMagic
networkMagic
        }

    -- The 'WitnessNetworkIdOrByronAddress' value converted to an 'Either'.
    eitherNwOrAddr :: Either NetworkId (Address ByronAddr)
    eitherNwOrAddr :: Either NetworkId (Address ByronAddr)
eitherNwOrAddr =
      case WitnessNetworkIdOrByronAddress
nwOrAddr of
        WitnessNetworkId NetworkId
nw -> forall a b. a -> Either a b
Left NetworkId
nw
        WitnessByronAddress Address ByronAddr
addr -> forall a b. b -> Either a b
Right Address ByronAddr
addr

    unByronAddr :: Address ByronAddr -> Byron.Address
    unByronAddr :: Address ByronAddr -> Address
unByronAddr (ByronAddress Address
addr) = Address
addr

    unAddrAttrs :: Address ByronAddr -> Byron.AddrAttributes
    unAddrAttrs :: Address ByronAddr -> AddrAttributes
unAddrAttrs = forall h. Attributes h -> h
Byron.attrData forall b c a. (b -> c) -> (a -> b) -> a -> c
. Address -> Attributes AddrAttributes
Byron.addrAttributes forall b c a. (b -> c) -> (a -> b) -> a -> c
. Address ByronAddr -> Address
unByronAddr

    derivationPath :: Maybe Byron.HDAddressPayload
    derivationPath :: Maybe HDAddressPayload
derivationPath =
      forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
        (forall a b. a -> b -> a
const forall a. Maybe a
Nothing)
        (AddrAttributes -> Maybe HDAddressPayload
Byron.aaVKDerivationPath forall b c a. (b -> c) -> (a -> b) -> a -> c
. Address ByronAddr -> AddrAttributes
unAddrAttrs)
        Either NetworkId (Address ByronAddr)
eitherNwOrAddr

    networkMagic :: Byron.NetworkMagic
    networkMagic :: NetworkMagic
networkMagic =
      forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
        NetworkId -> NetworkMagic
toByronNetworkMagic
        (AddrAttributes -> NetworkMagic
Byron.aaNetworkMagic forall b c a. (b -> c) -> (a -> b) -> a -> c
. Address ByronAddr -> AddrAttributes
unAddrAttrs)
        Either NetworkId (Address ByronAddr)
eitherNwOrAddr


data ShelleyWitnessSigningKey =
       WitnessPaymentKey         (SigningKey PaymentKey)
     | WitnessPaymentExtendedKey (SigningKey PaymentExtendedKey)
     | WitnessStakeKey           (SigningKey StakeKey)
     | WitnessStakeExtendedKey   (SigningKey StakeExtendedKey)
     | WitnessStakePoolKey       (SigningKey StakePoolKey)
     | WitnessGenesisKey         (SigningKey GenesisKey)
     | WitnessGenesisExtendedKey (SigningKey GenesisExtendedKey)
     | WitnessGenesisDelegateKey (SigningKey GenesisDelegateKey)
     | WitnessGenesisDelegateExtendedKey
                                 (SigningKey GenesisDelegateExtendedKey)
     | WitnessGenesisUTxOKey     (SigningKey GenesisUTxOKey)


makeShelleyKeyWitness :: forall era
                      .  IsShelleyBasedEra era
                      => TxBody era
                      -> ShelleyWitnessSigningKey
                      -> KeyWitness era
makeShelleyKeyWitness :: forall era.
IsShelleyBasedEra era =>
TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyKeyWitness (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
_ TxBodyScriptData era
_ Maybe (AuxiliaryData (ShelleyLedgerEra era))
_ TxScriptValidity era
_) =
    case ShelleyBasedEra era
era of
      ShelleyBasedEra era
ShelleyBasedEraShelley -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraAllegra -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraMary    -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraBabbage -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
      ShelleyBasedEra era
ShelleyBasedEraConway  -> HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody
  where
    makeShelleyBasedKeyWitness :: Ledger.HashAnnotated (Ledger.TxBody (ShelleyLedgerEra era)) Ledger.EraIndependentTxBody StandardCrypto
                               => Ledger.TxBody (ShelleyLedgerEra era)
                               -> ShelleyWitnessSigningKey
                               -> KeyWitness era
    makeShelleyBasedKeyWitness :: HashAnnotated
  (TxBody (ShelleyLedgerEra era))
  EraIndependentTxBody
  StandardCrypto =>
TxBody (ShelleyLedgerEra era)
-> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyBasedKeyWitness TxBody (ShelleyLedgerEra era)
txbody' =

     let txhash :: Shelley.Hash StandardCrypto Ledger.EraIndependentTxBody
         txhash :: Hash StandardCrypto EraIndependentTxBody
txhash = forall crypto i. SafeHash crypto i -> Hash (HASH crypto) i
Ledger.extractHash @StandardCrypto (forall c i x.
(HasAlgorithm c, HashAnnotated x i c) =>
x -> SafeHash c i
Ledger.hashAnnotated TxBody (ShelleyLedgerEra era)
txbody')

        -- To allow sharing of the txhash computation across many signatures we
        -- define and share the txhash outside the lambda for the signing key:
     in \ShelleyWitnessSigningKey
wsk ->
        let sk :: ShelleySigningKey
sk        = ShelleyWitnessSigningKey -> ShelleySigningKey
toShelleySigningKey ShelleyWitnessSigningKey
wsk
            vk :: VKey 'Witness StandardCrypto
vk        = ShelleySigningKey -> VKey 'Witness StandardCrypto
getShelleyKeyWitnessVerificationKey ShelleySigningKey
sk
            signature :: SignedDSIGN StandardCrypto (Hash Blake2b_256 EraIndependentTxBody)
signature = forall tosign.
SignableRepresentation tosign =>
tosign -> ShelleySigningKey -> SignedDSIGN StandardCrypto tosign
makeShelleySignature Hash StandardCrypto EraIndependentTxBody
txhash ShelleySigningKey
sk
         in forall era.
ShelleyBasedEra era
-> WitVKey 'Witness StandardCrypto -> KeyWitness era
ShelleyKeyWitness ShelleyBasedEra era
era forall a b. (a -> b) -> a -> b
$
              forall (kr :: KeyRole) crypto.
(Typeable kr, Crypto crypto) =>
VKey kr crypto
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> WitVKey kr crypto
Shelley.WitVKey VKey 'Witness StandardCrypto
vk SignedDSIGN StandardCrypto (Hash Blake2b_256 EraIndependentTxBody)
signature

makeShelleyKeyWitness ByronTxBody{} =
    case forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of {}


-- | We support making key witnesses with both normal and extended signing keys.
--
data ShelleySigningKey =
       -- | A normal ed25519 signing key
       ShelleyNormalSigningKey   (Shelley.SignKeyDSIGN StandardCrypto)

       -- | An extended ed25519 signing key
     | ShelleyExtendedSigningKey Crypto.HD.XPrv


toShelleySigningKey :: ShelleyWitnessSigningKey -> ShelleySigningKey
toShelleySigningKey :: ShelleyWitnessSigningKey -> ShelleySigningKey
toShelleySigningKey ShelleyWitnessSigningKey
key = case ShelleyWitnessSigningKey
key of
  WitnessPaymentKey     (PaymentSigningKey     SignKeyDSIGN StandardCrypto
sk) -> SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk
  WitnessStakeKey       (StakeSigningKey       SignKeyDSIGN StandardCrypto
sk) -> SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk
  WitnessStakePoolKey   (StakePoolSigningKey   SignKeyDSIGN StandardCrypto
sk) -> SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk
  WitnessGenesisKey     (GenesisSigningKey     SignKeyDSIGN StandardCrypto
sk) -> SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk
  WitnessGenesisUTxOKey (GenesisUTxOSigningKey SignKeyDSIGN StandardCrypto
sk) -> SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk
  WitnessGenesisDelegateKey (GenesisDelegateSigningKey SignKeyDSIGN StandardCrypto
sk) ->
    SignKeyDSIGN StandardCrypto -> ShelleySigningKey
ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk

  -- The cases for extended keys
  WitnessPaymentExtendedKey (PaymentExtendedSigningKey XPrv
sk) ->
    XPrv -> ShelleySigningKey
ShelleyExtendedSigningKey XPrv
sk

  WitnessStakeExtendedKey (StakeExtendedSigningKey XPrv
sk) ->
    XPrv -> ShelleySigningKey
ShelleyExtendedSigningKey XPrv
sk

  WitnessGenesisExtendedKey (GenesisExtendedSigningKey XPrv
sk) ->
    XPrv -> ShelleySigningKey
ShelleyExtendedSigningKey XPrv
sk

  WitnessGenesisDelegateExtendedKey (GenesisDelegateExtendedSigningKey XPrv
sk) ->
    XPrv -> ShelleySigningKey
ShelleyExtendedSigningKey XPrv
sk


getShelleyKeyWitnessVerificationKey
  :: ShelleySigningKey
  -> Shelley.VKey Shelley.Witness StandardCrypto
getShelleyKeyWitnessVerificationKey :: ShelleySigningKey -> VKey 'Witness StandardCrypto
getShelleyKeyWitnessVerificationKey (ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk) =
      (forall (a :: KeyRole -> * -> *) (r :: KeyRole) crypto
       (r' :: KeyRole).
HasKeyRole a =>
a r crypto -> a r' crypto
Shelley.coerceKeyRole :: Shelley.VKey Shelley.Payment StandardCrypto
                             -> Shelley.VKey Shelley.Witness StandardCrypto)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(PaymentVerificationKey VKey 'Payment StandardCrypto
vk) -> VKey 'Payment StandardCrypto
vk)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall keyrole.
Key keyrole =>
SigningKey keyrole -> VerificationKey keyrole
getVerificationKey
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignKeyDSIGN StandardCrypto -> SigningKey PaymentKey
PaymentSigningKey
    forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN StandardCrypto
sk

getShelleyKeyWitnessVerificationKey (ShelleyExtendedSigningKey XPrv
sk) =
      (forall (a :: KeyRole -> * -> *) (r :: KeyRole) crypto
       (r' :: KeyRole).
HasKeyRole a =>
a r crypto -> a r' crypto
Shelley.coerceKeyRole :: Shelley.VKey Shelley.Payment StandardCrypto
                             -> Shelley.VKey Shelley.Witness StandardCrypto)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(PaymentVerificationKey VKey 'Payment StandardCrypto
vk) -> VKey 'Payment StandardCrypto
vk)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall keyroleA keyroleB.
CastVerificationKeyRole keyroleA keyroleB =>
VerificationKey keyroleA -> VerificationKey keyroleB
castVerificationKey :: VerificationKey PaymentExtendedKey
                           -> VerificationKey PaymentKey)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall keyrole.
Key keyrole =>
SigningKey keyrole -> VerificationKey keyrole
getVerificationKey
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. XPrv -> SigningKey PaymentExtendedKey
PaymentExtendedSigningKey
    forall a b. (a -> b) -> a -> b
$ XPrv
sk


makeShelleySignature
  :: Crypto.SignableRepresentation tosign
  => tosign
  -> ShelleySigningKey
  -> Shelley.SignedDSIGN StandardCrypto tosign
makeShelleySignature :: forall tosign.
SignableRepresentation tosign =>
tosign -> ShelleySigningKey -> SignedDSIGN StandardCrypto tosign
makeShelleySignature tosign
tosign (ShelleyNormalSigningKey SignKeyDSIGN StandardCrypto
sk) =
    forall v a.
(DSIGNAlgorithm v, Signable v a) =>
ContextDSIGN v -> a -> SignKeyDSIGN v -> SignedDSIGN v a
Crypto.signedDSIGN () tosign
tosign SignKeyDSIGN StandardCrypto
sk

makeShelleySignature tosign
tosign (ShelleyExtendedSigningKey XPrv
sk) =
    forall b. XSignature -> SignedDSIGN StandardCrypto b
fromXSignature forall a b. (a -> b) -> a -> b
$
      forall passPhrase msg.
(ByteArrayAccess passPhrase, ByteArrayAccess msg) =>
passPhrase -> XPrv -> msg -> XSignature
Crypto.HD.sign
        ByteString
BS.empty  -- passphrase for (unused) in-memory encryption
        XPrv
sk
        (forall a. SignableRepresentation a => a -> ByteString
Crypto.getSignableRepresentation tosign
tosign)
  where
    fromXSignature :: Crypto.HD.XSignature
                   -> Shelley.SignedDSIGN StandardCrypto b
    fromXSignature :: forall b. XSignature -> SignedDSIGN StandardCrypto b
fromXSignature =
        forall v a. SigDSIGN v -> SignedDSIGN v a
Crypto.SignedDSIGN
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe forall {a}. a
impossible
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v. DSIGNAlgorithm v => ByteString -> Maybe (SigDSIGN v)
Crypto.rawDeserialiseSigDSIGN
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. XSignature -> ByteString
Crypto.HD.unXSignature

    impossible :: a
impossible =
      forall a. HasCallStack => String -> a
error String
"makeShelleyKeyWitnessSignature: byron and shelley signature sizes do not match"


-- order of signing keys must match txins
signByronTransaction :: NetworkId
                     -> TxBody ByronEra
                     -> [SigningKey ByronKey]
                     -> Tx ByronEra
signByronTransaction :: NetworkId
-> TxBody ByronEra -> [SigningKey ByronKey] -> Tx ByronEra
signByronTransaction NetworkId
nw TxBody ByronEra
txbody [SigningKey ByronKey]
sks =
    forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction [KeyWitness ByronEra]
witnesses TxBody ByronEra
txbody
  where
    witnesses :: [KeyWitness ByronEra]
witnesses = forall a b. (a -> b) -> [a] -> [b]
map (forall key.
IsByronKey key =>
NetworkId
-> TxBody ByronEra -> SigningKey key -> KeyWitness ByronEra
makeByronKeyWitness NetworkId
nw TxBody ByronEra
txbody) [SigningKey ByronKey]
sks

-- signing keys is a set
signShelleyTransaction :: IsShelleyBasedEra era
                       => TxBody era
                       -> [ShelleyWitnessSigningKey]
                       -> Tx era
signShelleyTransaction :: forall era.
IsShelleyBasedEra era =>
TxBody era -> [ShelleyWitnessSigningKey] -> Tx era
signShelleyTransaction TxBody era
txbody [ShelleyWitnessSigningKey]
sks =
    forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction [KeyWitness era]
witnesses TxBody era
txbody
  where
    witnesses :: [KeyWitness era]
witnesses = forall a b. (a -> b) -> [a] -> [b]
map (forall era.
IsShelleyBasedEra era =>
TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyKeyWitness TxBody era
txbody) [ShelleyWitnessSigningKey]
sks