-- | This module exposes the generation of witnesses and reward account
module Cooked.MockChain.GenerateTx.Witness
  ( toRewardAccount,
    toCardanoCredential,
    toScriptWitness,
    toKeyWitness,
    toStakeCredential,
    deserialiseFromBuiltinByteString,
    toScriptHash,
    toKeyHash,
    toDRepCredential,
    toStakePoolKeyHash,
    toColdCredential,
    toHotCredential,
    toVRFVerKeyHash,
  )
where

import Cardano.Api qualified as Cardano
import Cardano.Ledger.BaseTypes qualified as C.Ledger
import Cardano.Ledger.Hashes qualified as C.Ledger
import Cardano.Ledger.Shelley.API qualified as C.Ledger
import Control.Monad.Except (throwError)
import Cooked.MockChain.BlockChain
import Cooked.MockChain.GenerateTx.Common
import Cooked.Skeleton
import Ledger.Address qualified as Ledger
import Ledger.Tx.CardanoAPI qualified as Ledger
import Optics.Core
import Plutus.Script.Utils.Scripts qualified as Script
import PlutusLedgerApi.V3 qualified as Api

-- | Translates a given credential to a reward account.
toRewardAccount :: (MonadBlockChainBalancing m) => Api.Credential -> m C.Ledger.RewardAccount
toRewardAccount :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
Credential -> m RewardAccount
toRewardAccount = (Network -> Credential 'Staking -> RewardAccount
C.Ledger.RewardAccount Network
C.Ledger.Testnet (Credential 'Staking -> RewardAccount)
-> m (Credential 'Staking) -> m RewardAccount
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (m (Credential 'Staking) -> m RewardAccount)
-> (Credential -> m (Credential 'Staking))
-> Credential
-> m RewardAccount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AsType StakeKey
-> (Hash StakeKey -> KeyHash 'Staking)
-> Credential
-> m (Credential 'Staking)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType StakeKey
Cardano.AsStakeKey Hash StakeKey -> KeyHash 'Staking
Cardano.unStakeKeyHash

-- TODO: if this works, migrate to plutus-ledger

-- | Converts an 'Api.PubKeyHash' to any kind of key
deserialiseFromBuiltinByteString ::
  (MonadBlockChainBalancing m, Cardano.SerialiseAsRawBytes a) =>
  Cardano.AsType a ->
  Api.BuiltinByteString ->
  m a
deserialiseFromBuiltinByteString :: forall (m :: * -> *) a.
(MonadBlockChainBalancing m, SerialiseAsRawBytes a) =>
AsType a -> BuiltinByteString -> m a
deserialiseFromBuiltinByteString AsType a
asType =
  String -> Either ToCardanoError a -> m a
forall (m :: * -> *) a.
MonadError MockChainError m =>
String -> Either ToCardanoError a -> m a
throwOnToCardanoError String
"deserialiseFromBuiltinByteString" (Either ToCardanoError a -> m a)
-> (BuiltinByteString -> Either ToCardanoError a)
-> BuiltinByteString
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AsType a -> ByteString -> Either ToCardanoError a
forall t.
SerialiseAsRawBytes t =>
AsType t -> ByteString -> Either ToCardanoError t
Ledger.deserialiseFromRawBytes AsType a
asType (ByteString -> Either ToCardanoError a)
-> (BuiltinByteString -> ByteString)
-> BuiltinByteString
-> Either ToCardanoError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BuiltinByteString -> ByteString
BuiltinByteString -> FromBuiltin BuiltinByteString
forall arep. HasFromBuiltin arep => arep -> FromBuiltin arep
Api.fromBuiltin

-- | Converts a plutus script hash into a cardano ledger script hash
toScriptHash :: (MonadBlockChainBalancing m) => Api.ScriptHash -> m C.Ledger.ScriptHash
toScriptHash :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
ScriptHash -> m ScriptHash
toScriptHash (Api.ScriptHash BuiltinByteString
sHash) = do
  Cardano.ScriptHash ScriptHash
cHash <- AsType ScriptHash -> BuiltinByteString -> m ScriptHash
forall (m :: * -> *) a.
(MonadBlockChainBalancing m, SerialiseAsRawBytes a) =>
AsType a -> BuiltinByteString -> m a
deserialiseFromBuiltinByteString AsType ScriptHash
Cardano.AsScriptHash BuiltinByteString
sHash
  ScriptHash -> m ScriptHash
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptHash
cHash

-- | Converts a plutus pkhash into a certain cardano ledger hash
toKeyHash ::
  (MonadBlockChainBalancing m, Cardano.SerialiseAsRawBytes (Cardano.Hash key)) =>
  Cardano.AsType key ->
  (Cardano.Hash key -> C.Ledger.KeyHash kr) ->
  Api.PubKeyHash ->
  m (C.Ledger.KeyHash kr)
toKeyHash :: forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> PubKeyHash -> m (KeyHash kr)
toKeyHash AsType key
asType Hash key -> KeyHash kr
unwrap = (Hash key -> KeyHash kr) -> m (Hash key) -> m (KeyHash kr)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Hash key -> KeyHash kr
unwrap (m (Hash key) -> m (KeyHash kr))
-> (PubKeyHash -> m (Hash key)) -> PubKeyHash -> m (KeyHash kr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AsType (Hash key) -> BuiltinByteString -> m (Hash key)
forall (m :: * -> *) a.
(MonadBlockChainBalancing m, SerialiseAsRawBytes a) =>
AsType a -> BuiltinByteString -> m a
deserialiseFromBuiltinByteString (AsType key -> AsType (Hash key)
forall a. AsType a -> AsType (Hash a)
Cardano.AsHash AsType key
asType) (BuiltinByteString -> m (Hash key))
-> (PubKeyHash -> BuiltinByteString) -> PubKeyHash -> m (Hash key)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PubKeyHash -> BuiltinByteString
Api.getPubKeyHash

-- | Converts an 'Api.PubKeyHash' into a cardano ledger stake pool key hash
toStakePoolKeyHash :: (MonadBlockChainBalancing m) => Api.PubKeyHash -> m (C.Ledger.KeyHash 'C.Ledger.StakePool)
toStakePoolKeyHash :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
PubKeyHash -> m (KeyHash 'StakePool)
toStakePoolKeyHash = AsType StakePoolKey
-> (Hash StakePoolKey -> KeyHash 'StakePool)
-> PubKeyHash
-> m (KeyHash 'StakePool)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> PubKeyHash -> m (KeyHash kr)
toKeyHash AsType StakePoolKey
Cardano.AsStakePoolKey Hash StakePoolKey -> KeyHash 'StakePool
Cardano.unStakePoolKeyHash

-- | Converts an 'Api.PubKeyHash' into a cardano ledger VRFVerKeyHash
toVRFVerKeyHash :: (MonadBlockChainBalancing m) => Api.PubKeyHash -> m (C.Ledger.VRFVerKeyHash a)
toVRFVerKeyHash :: forall (m :: * -> *) (a :: KeyRoleVRF).
MonadBlockChainBalancing m =>
PubKeyHash -> m (VRFVerKeyHash a)
toVRFVerKeyHash (Api.PubKeyHash BuiltinByteString
pkh) = do
  Cardano.VrfKeyHash Hash HASH (VerKeyVRF (VRF StandardCrypto))
key <- AsType (Hash VrfKey) -> BuiltinByteString -> m (Hash VrfKey)
forall (m :: * -> *) a.
(MonadBlockChainBalancing m, SerialiseAsRawBytes a) =>
AsType a -> BuiltinByteString -> m a
deserialiseFromBuiltinByteString (AsType VrfKey -> AsType (Hash VrfKey)
forall a. AsType a -> AsType (Hash a)
Cardano.AsHash AsType VrfKey
Cardano.AsVrfKey) BuiltinByteString
pkh
  VRFVerKeyHash a -> m (VRFVerKeyHash a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (VRFVerKeyHash a -> m (VRFVerKeyHash a))
-> VRFVerKeyHash a -> m (VRFVerKeyHash a)
forall a b. (a -> b) -> a -> b
$ Hash HASH (VerKeyVRF PraosVRF) -> VRFVerKeyHash a
forall v (r :: KeyRoleVRF).
Hash HASH (VerKeyVRF v) -> VRFVerKeyHash r
C.Ledger.toVRFVerKeyHash Hash HASH (VerKeyVRF PraosVRF)
Hash HASH (VerKeyVRF (VRF StandardCrypto))
key

-- | Converts an 'Api.Credential' to a Cardano Credential of the expected kind
toCardanoCredential ::
  (MonadBlockChainBalancing m, Cardano.SerialiseAsRawBytes (Cardano.Hash key)) =>
  Cardano.AsType key ->
  (Cardano.Hash key -> C.Ledger.KeyHash kr) ->
  Api.Credential ->
  m (C.Ledger.Credential kr)
toCardanoCredential :: forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType key
_ Hash key -> KeyHash kr
_ (Api.ScriptCredential ScriptHash
sHash) = ScriptHash -> Credential kr
forall (kr :: KeyRole). ScriptHash -> Credential kr
C.Ledger.ScriptHashObj (ScriptHash -> Credential kr) -> m ScriptHash -> m (Credential kr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ScriptHash -> m ScriptHash
forall (m :: * -> *).
MonadBlockChainBalancing m =>
ScriptHash -> m ScriptHash
toScriptHash ScriptHash
sHash
toCardanoCredential AsType key
asType Hash key -> KeyHash kr
unwrap (Api.PubKeyCredential PubKeyHash
pkHash) = KeyHash kr -> Credential kr
forall (kr :: KeyRole). KeyHash kr -> Credential kr
C.Ledger.KeyHashObj (KeyHash kr -> Credential kr)
-> m (KeyHash kr) -> m (Credential kr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType key
-> (Hash key -> KeyHash kr) -> PubKeyHash -> m (KeyHash kr)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> PubKeyHash -> m (KeyHash kr)
toKeyHash AsType key
asType Hash key -> KeyHash kr
unwrap PubKeyHash
pkHash

-- | Translates a credential into a Cardano stake credential
toStakeCredential :: (MonadBlockChainBalancing m) => Api.Credential -> m (C.Ledger.Credential 'C.Ledger.Staking)
toStakeCredential :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
Credential -> m (Credential 'Staking)
toStakeCredential = AsType StakeKey
-> (Hash StakeKey -> KeyHash 'Staking)
-> Credential
-> m (Credential 'Staking)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType StakeKey
Cardano.AsStakeKey Hash StakeKey -> KeyHash 'Staking
Cardano.unStakeKeyHash

-- | Translates a credential into a Cardano drep credential
toDRepCredential :: (MonadBlockChainBalancing m) => Api.Credential -> m (C.Ledger.Credential 'C.Ledger.DRepRole)
toDRepCredential :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
Credential -> m (Credential 'DRepRole)
toDRepCredential = AsType DRepKey
-> (Hash DRepKey -> KeyHash 'DRepRole)
-> Credential
-> m (Credential 'DRepRole)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType DRepKey
Cardano.AsDRepKey Hash DRepKey -> KeyHash 'DRepRole
Cardano.unDRepKeyHash

-- | Translates a credential into a Cardano cold committee credential
toColdCredential :: (MonadBlockChainBalancing m) => Api.Credential -> m (C.Ledger.Credential 'C.Ledger.ColdCommitteeRole)
toColdCredential :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
Credential -> m (Credential 'ColdCommitteeRole)
toColdCredential = AsType CommitteeColdKey
-> (Hash CommitteeColdKey -> KeyHash 'ColdCommitteeRole)
-> Credential
-> m (Credential 'ColdCommitteeRole)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType CommitteeColdKey
Cardano.AsCommitteeColdKey Hash CommitteeColdKey -> KeyHash 'ColdCommitteeRole
Cardano.unCommitteeColdKeyHash

-- | Translates a credential into a Cardano hot committee credential
toHotCredential :: (MonadBlockChainBalancing m) => Api.Credential -> m (C.Ledger.Credential 'C.Ledger.HotCommitteeRole)
toHotCredential :: forall (m :: * -> *).
MonadBlockChainBalancing m =>
Credential -> m (Credential 'HotCommitteeRole)
toHotCredential = AsType CommitteeHotKey
-> (Hash CommitteeHotKey -> KeyHash 'HotCommitteeRole)
-> Credential
-> m (Credential 'HotCommitteeRole)
forall (m :: * -> *) key (kr :: KeyRole).
(MonadBlockChainBalancing m, SerialiseAsRawBytes (Hash key)) =>
AsType key
-> (Hash key -> KeyHash kr) -> Credential -> m (Credential kr)
toCardanoCredential AsType CommitteeHotKey
Cardano.AsCommitteeHotKey Hash CommitteeHotKey -> KeyHash 'HotCommitteeRole
Cardano.unCommitteeHotKeyHash

-- | Translates a script and a reference script utxo into either a plutus script
-- or a reference input containing the right script
toPlutusScriptOrReferenceInput :: (MonadBlockChainBalancing m) => VScript -> Maybe Api.TxOutRef -> m (Cardano.PlutusScriptOrReferenceInput lang)
toPlutusScriptOrReferenceInput :: forall (m :: * -> *) lang.
MonadBlockChainBalancing m =>
VScript -> Maybe TxOutRef -> m (PlutusScriptOrReferenceInput lang)
toPlutusScriptOrReferenceInput (Script.Versioned (Script.Script SerialisedScript
script) Language
_) Maybe TxOutRef
Nothing = PlutusScriptOrReferenceInput lang
-> m (PlutusScriptOrReferenceInput lang)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (PlutusScriptOrReferenceInput lang
 -> m (PlutusScriptOrReferenceInput lang))
-> PlutusScriptOrReferenceInput lang
-> m (PlutusScriptOrReferenceInput lang)
forall a b. (a -> b) -> a -> b
$ PlutusScript lang -> PlutusScriptOrReferenceInput lang
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
Cardano.PScript (PlutusScript lang -> PlutusScriptOrReferenceInput lang)
-> PlutusScript lang -> PlutusScriptOrReferenceInput lang
forall a b. (a -> b) -> a -> b
$ SerialisedScript -> PlutusScript lang
forall lang. SerialisedScript -> PlutusScript lang
Cardano.PlutusScriptSerialised SerialisedScript
script
toPlutusScriptOrReferenceInput (VScript -> ScriptHash
forall a. ToScriptHash a => a -> ScriptHash
Script.toScriptHash -> ScriptHash
scriptHash) (Just TxOutRef
scriptOutRef) = do
  (Optic' An_AffineFold NoIx TxSkelOut ScriptHash
-> TxSkelOut -> Maybe ScriptHash
forall k (is :: IxList) s a.
Is k An_AffineFold =>
Optic' k is s a -> s -> Maybe a
preview Optic' An_AffineFold NoIx TxSkelOut ScriptHash
txSkelOutReferenceScriptHashAF -> Maybe ScriptHash
mScriptHash) <- TxOutRef -> m TxSkelOut
forall (m :: * -> *).
MonadBlockChainBalancing m =>
TxOutRef -> m TxSkelOut
txSkelOutByRef TxOutRef
scriptOutRef
  case Maybe ScriptHash
mScriptHash of
    Just ScriptHash
scriptHash'
      | ScriptHash
scriptHash ScriptHash -> ScriptHash -> Bool
forall a. Eq a => a -> a -> Bool
== ScriptHash
scriptHash' ->
          TxIn -> PlutusScriptOrReferenceInput lang
forall lang. TxIn -> PlutusScriptOrReferenceInput lang
Cardano.PReferenceScript
            (TxIn -> PlutusScriptOrReferenceInput lang)
-> m TxIn -> m (PlutusScriptOrReferenceInput lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Either ToCardanoError TxIn -> m TxIn
forall (m :: * -> *) a.
MonadError MockChainError m =>
String -> Either ToCardanoError a -> m a
throwOnToCardanoError
              String
"toPlutusScriptOrReferenceInput: Unable to translate reference script utxo."
              (TxOutRef -> Either ToCardanoError TxIn
Ledger.toCardanoTxIn TxOutRef
scriptOutRef)
    Maybe ScriptHash
_ -> MockChainError -> m (PlutusScriptOrReferenceInput lang)
forall a. MockChainError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (MockChainError -> m (PlutusScriptOrReferenceInput lang))
-> MockChainError -> m (PlutusScriptOrReferenceInput lang)
forall a b. (a -> b) -> a -> b
$ TxOutRef -> ScriptHash -> Maybe ScriptHash -> MockChainError
MCEWrongReferenceScriptError TxOutRef
scriptOutRef ScriptHash
scriptHash Maybe ScriptHash
mScriptHash

-- | Translates a script with its associated redeemer and datum to a script
-- witness. Note on the usage of 'Ledger.zeroExecutionUnits': at this stage of
-- the transaction create, we cannot know the execution units used by the
-- script. They will be filled out later on once the full body has been
-- generated. So, for now, we temporarily leave them to 0.
toScriptWitness :: (MonadBlockChainBalancing m, ToVScript a) => a -> TxSkelRedeemer -> Cardano.ScriptDatum b -> m (Cardano.ScriptWitness b Cardano.ConwayEra)
toScriptWitness :: forall (m :: * -> *) a b.
(MonadBlockChainBalancing m, ToVScript a) =>
a
-> TxSkelRedeemer -> ScriptDatum b -> m (ScriptWitness b ConwayEra)
toScriptWitness (a -> VScript
forall script. ToVScript script => script -> VScript
toVScript -> script :: VScript
script@(Script.Versioned Script
_ Language
version)) (TxSkelRedeemer {redeemer
Bool
Maybe TxOutRef
txSkelRedeemerContent :: redeemer
txSkelRedeemerReferenceInput :: Maybe TxOutRef
txSkelRedeemerAutoFill :: Bool
txSkelRedeemerContent :: ()
txSkelRedeemerReferenceInput :: TxSkelRedeemer -> Maybe TxOutRef
txSkelRedeemerAutoFill :: TxSkelRedeemer -> Bool
..}) ScriptDatum b
datum = do
  let scriptData :: HashableScriptData
scriptData = BuiltinData -> HashableScriptData
Ledger.toCardanoScriptData (BuiltinData -> HashableScriptData)
-> BuiltinData -> HashableScriptData
forall a b. (a -> b) -> a -> b
$ redeemer -> BuiltinData
forall a. ToData a => a -> BuiltinData
Api.toBuiltinData redeemer
txSkelRedeemerContent
  case Language
version of
    Language
Script.PlutusV1 ->
      (\PlutusScriptOrReferenceInput PlutusScriptV1
x -> ScriptLanguageInEra PlutusScriptV1 ConwayEra
-> PlutusScriptVersion PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
-> ScriptDatum b
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness b ConwayEra
forall lang era witctx.
IsPlutusScriptLanguage lang =>
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness witctx era
Cardano.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV1 ConwayEra
Cardano.PlutusScriptV1InConway PlutusScriptVersion PlutusScriptV1
Cardano.PlutusScriptV1 PlutusScriptOrReferenceInput PlutusScriptV1
x ScriptDatum b
datum HashableScriptData
scriptData ExecutionUnits
Ledger.zeroExecutionUnits)
        (PlutusScriptOrReferenceInput PlutusScriptV1
 -> ScriptWitness b ConwayEra)
-> m (PlutusScriptOrReferenceInput PlutusScriptV1)
-> m (ScriptWitness b ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VScript
-> Maybe TxOutRef
-> m (PlutusScriptOrReferenceInput PlutusScriptV1)
forall (m :: * -> *) lang.
MonadBlockChainBalancing m =>
VScript -> Maybe TxOutRef -> m (PlutusScriptOrReferenceInput lang)
toPlutusScriptOrReferenceInput VScript
script Maybe TxOutRef
txSkelRedeemerReferenceInput
    Language
Script.PlutusV2 ->
      (\PlutusScriptOrReferenceInput PlutusScriptV2
x -> ScriptLanguageInEra PlutusScriptV2 ConwayEra
-> PlutusScriptVersion PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
-> ScriptDatum b
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness b ConwayEra
forall lang era witctx.
IsPlutusScriptLanguage lang =>
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness witctx era
Cardano.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV2 ConwayEra
Cardano.PlutusScriptV2InConway PlutusScriptVersion PlutusScriptV2
Cardano.PlutusScriptV2 PlutusScriptOrReferenceInput PlutusScriptV2
x ScriptDatum b
datum HashableScriptData
scriptData ExecutionUnits
Ledger.zeroExecutionUnits)
        (PlutusScriptOrReferenceInput PlutusScriptV2
 -> ScriptWitness b ConwayEra)
-> m (PlutusScriptOrReferenceInput PlutusScriptV2)
-> m (ScriptWitness b ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VScript
-> Maybe TxOutRef
-> m (PlutusScriptOrReferenceInput PlutusScriptV2)
forall (m :: * -> *) lang.
MonadBlockChainBalancing m =>
VScript -> Maybe TxOutRef -> m (PlutusScriptOrReferenceInput lang)
toPlutusScriptOrReferenceInput VScript
script Maybe TxOutRef
txSkelRedeemerReferenceInput
    Language
Script.PlutusV3 ->
      (\PlutusScriptOrReferenceInput PlutusScriptV3
x -> ScriptLanguageInEra PlutusScriptV3 ConwayEra
-> PlutusScriptVersion PlutusScriptV3
-> PlutusScriptOrReferenceInput PlutusScriptV3
-> ScriptDatum b
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness b ConwayEra
forall lang era witctx.
IsPlutusScriptLanguage lang =>
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness witctx era
Cardano.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV3 ConwayEra
Cardano.PlutusScriptV3InConway PlutusScriptVersion PlutusScriptV3
Cardano.PlutusScriptV3 PlutusScriptOrReferenceInput PlutusScriptV3
x ScriptDatum b
datum HashableScriptData
scriptData ExecutionUnits
Ledger.zeroExecutionUnits)
        (PlutusScriptOrReferenceInput PlutusScriptV3
 -> ScriptWitness b ConwayEra)
-> m (PlutusScriptOrReferenceInput PlutusScriptV3)
-> m (ScriptWitness b ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VScript
-> Maybe TxOutRef
-> m (PlutusScriptOrReferenceInput PlutusScriptV3)
forall (m :: * -> *) lang.
MonadBlockChainBalancing m =>
VScript -> Maybe TxOutRef -> m (PlutusScriptOrReferenceInput lang)
toPlutusScriptOrReferenceInput VScript
script Maybe TxOutRef
txSkelRedeemerReferenceInput

-- | Generates a key witnesses for a given signatory and body, when the
-- signatory contains a private key.
toKeyWitness :: Cardano.TxBody Cardano.ConwayEra -> TxSkelSignatory -> Maybe (Cardano.KeyWitness Cardano.ConwayEra)
toKeyWitness :: TxBody ConwayEra -> TxSkelSignatory -> Maybe (KeyWitness ConwayEra)
toKeyWitness TxBody ConwayEra
txBody =
  (XPrv -> KeyWitness ConwayEra)
-> Maybe XPrv -> Maybe (KeyWitness ConwayEra)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
    ( ShelleyBasedEra ConwayEra
-> TxBody ConwayEra
-> ShelleyWitnessSigningKey
-> KeyWitness ConwayEra
forall era.
ShelleyBasedEra era
-> TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era
Cardano.makeShelleyKeyWitness ShelleyBasedEra ConwayEra
Cardano.ShelleyBasedEraConway TxBody ConwayEra
txBody
        (ShelleyWitnessSigningKey -> KeyWitness ConwayEra)
-> (XPrv -> ShelleyWitnessSigningKey)
-> XPrv
-> KeyWitness ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PaymentPrivateKey -> ShelleyWitnessSigningKey
forall a. ToWitness a => a -> ShelleyWitnessSigningKey
Ledger.toWitness
        (PaymentPrivateKey -> ShelleyWitnessSigningKey)
-> (XPrv -> PaymentPrivateKey) -> XPrv -> ShelleyWitnessSigningKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XPrv -> PaymentPrivateKey
Ledger.PaymentPrivateKey
    )
    (Maybe XPrv -> Maybe (KeyWitness ConwayEra))
-> (TxSkelSignatory -> Maybe XPrv)
-> TxSkelSignatory
-> Maybe (KeyWitness ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Optic' An_AffineTraversal NoIx TxSkelSignatory XPrv
-> TxSkelSignatory -> Maybe XPrv
forall k (is :: IxList) s a.
Is k An_AffineFold =>
Optic' k is s a -> s -> Maybe a
preview Optic' An_AffineTraversal NoIx TxSkelSignatory XPrv
txSkelSignatoryPrivateKeyAT