{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleInstances  #-}
{-# LANGUAGE GADTs              #-}
{-# LANGUAGE LambdaCase         #-}
{-# LANGUAGE NamedFieldPuns     #-}
{-# LANGUAGE OverloadedLists    #-}
{-# LANGUAGE OverloadedStrings  #-}
{-# LANGUAGE RankNTypes         #-}
{-# LANGUAGE RecordWildCards    #-}
{-# LANGUAGE TupleSections      #-}

{-|

Interface to the transaction types from 'cardano-api'

-}
module Ledger.Tx.CardanoAPI(
  module Ledger.Tx.CardanoAPI.Internal
  , CardanoBuildTx(..)
  , SomeCardanoApiTx(..)
  , fromCardanoTxInsCollateral
  , fromCardanoTotalCollateral
  , fromCardanoReturnCollateral
  , toCardanoTxBody
  , toCardanoTxBodyContent
  , toCardanoTxInsCollateral
  , toCardanoTotalCollateral
  , toCardanoReturnCollateral
  , toCardanoTxInWitness
  , toCardanoDatumWitness
  , toCardanoTxInReferenceWitnessHeader
  , toCardanoTxInScriptWitnessHeader
  , toCardanoMintValue
  , toCardanoMintWitness
  , ToCardanoError(..)
  , FromCardanoError(..)
  , getRequiredSigners
  -- * Conversion from Plutus types
  , fromPlutusIndex
  , fromPlutusTxOut
  , fromPlutusTxOutRef
) where

import Cardano.Api qualified as C
import Cardano.Api.Shelley qualified as C
import Cardano.Ledger.Alonzo.Tx (ValidatedTx (..))
import Cardano.Ledger.Babbage qualified as Babbage
import Cardano.Ledger.Babbage.PParams qualified as Babbage
import Cardano.Ledger.Babbage.TxBody (TxBody (TxBody, reqSignerHashes))
import Cardano.Ledger.BaseTypes (mkTxIxPartial)
import Cardano.Ledger.Crypto (StandardCrypto)
import Cardano.Ledger.Shelley.API qualified as C.Ledger
import Data.Bifunctor (Bifunctor (..))
import Data.Bitraversable (bisequence, bitraverse)
import Data.Map qualified as Map
import Ledger.Address qualified as P
import Ledger.Index.Internal qualified as P
import Ledger.Scripts qualified as P
import Ledger.Tx.CardanoAPI.Internal
import Ledger.Tx.Internal qualified as P
import Plutus.V1.Ledger.Api qualified as PV1


toCardanoTxBodyContent
    :: C.NetworkId
    -> Babbage.PParams (Babbage.BabbageEra StandardCrypto)
    -> [P.PaymentPubKeyHash] -- ^ Required signers of the transaction
    -> P.Tx
    -> Either ToCardanoError CardanoBuildTx
toCardanoTxBodyContent :: NetworkId
-> PParams (BabbageEra StandardCrypto)
-> [PaymentPubKeyHash]
-> Tx
-> Either ToCardanoError CardanoBuildTx
toCardanoTxBodyContent NetworkId
networkId PParams (BabbageEra StandardCrypto)
protocolParams [PaymentPubKeyHash]
sigs tx :: Tx
tx@P.Tx{[TxOut]
[Certificate]
[Withdrawal]
[TxInput]
Maybe Value
Maybe BuiltinByteString
Maybe TxOut
ScriptsMap
Map DatumHash Datum
MintingWitnessesMap
Map PubKey Signature
Value
SlotRange
txMetadata :: Tx -> Maybe BuiltinByteString
txData :: Tx -> Map DatumHash Datum
txScripts :: Tx -> ScriptsMap
txSignatures :: Tx -> Map PubKey Signature
txCertificates :: Tx -> [Certificate]
txWithdrawals :: Tx -> [Withdrawal]
txMintingWitnesses :: Tx -> MintingWitnessesMap
txValidRange :: Tx -> SlotRange
txFee :: Tx -> Value
txMint :: Tx -> Value
txTotalCollateral :: Tx -> Maybe Value
txReturnCollateral :: Tx -> Maybe TxOut
txOutputs :: Tx -> [TxOut]
txCollateralInputs :: Tx -> [TxInput]
txReferenceInputs :: Tx -> [TxInput]
txInputs :: Tx -> [TxInput]
txMetadata :: Maybe BuiltinByteString
txData :: Map DatumHash Datum
txScripts :: ScriptsMap
txSignatures :: Map PubKey Signature
txCertificates :: [Certificate]
txWithdrawals :: [Withdrawal]
txMintingWitnesses :: MintingWitnessesMap
txValidRange :: SlotRange
txFee :: Value
txMint :: Value
txTotalCollateral :: Maybe Value
txReturnCollateral :: Maybe TxOut
txOutputs :: [TxOut]
txCollateralInputs :: [TxInput]
txReferenceInputs :: [TxInput]
txInputs :: [TxInput]
..} = do
    -- TODO: translate all fields
    [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))]
txIns <- (TxInput
 -> Either
      ToCardanoError
      (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)))
-> [TxInput]
-> Either
     ToCardanoError
     [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Tx
-> TxInput
-> Either
     ToCardanoError
     (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
toCardanoTxInBuild Tx
tx) [TxInput]
txInputs
    [TxIn]
txInsReference <- (TxInput -> Either ToCardanoError TxIn)
-> [TxInput] -> Either ToCardanoError [TxIn]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn (TxOutRef -> Either ToCardanoError TxIn)
-> (TxInput -> TxOutRef) -> TxInput -> Either ToCardanoError TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxInput -> TxOutRef
P.txInputRef) [TxInput]
txReferenceInputs
    TxInsCollateral BabbageEra
txInsCollateral <- [TxInput] -> Either ToCardanoError (TxInsCollateral BabbageEra)
toCardanoTxInsCollateral [TxInput]
txCollateralInputs
    let txOuts :: [TxOut CtxTx BabbageEra]
txOuts = TxOut -> TxOut CtxTx BabbageEra
P.getTxOut (TxOut -> TxOut CtxTx BabbageEra)
-> [TxOut] -> [TxOut CtxTx BabbageEra]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TxOut]
txOutputs
    -- Workaround for missing export https://github.com/input-output-hk/cardano-node/pull/4496
    (TxReturnCollateral CtxTx BabbageEra
returnCollateral, TxTotalCollateral BabbageEra
totalCollateral) <- case CardanoEra BabbageEra
-> Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
forall era.
CardanoEra era
-> Maybe (TxTotalAndReturnCollateralSupportedInEra era)
C.totalAndReturnCollateralSupportedInEra CardanoEra BabbageEra
C.BabbageEra of
      Just TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra ->
        (TxReturnCollateral CtxTx BabbageEra
-> (TxOut -> TxReturnCollateral CtxTx BabbageEra)
-> Maybe TxOut
-> TxReturnCollateral CtxTx BabbageEra
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TxReturnCollateral CtxTx BabbageEra
forall ctx era. TxReturnCollateral ctx era
C.TxReturnCollateralNone (TxTotalAndReturnCollateralSupportedInEra BabbageEra
-> TxOut CtxTx BabbageEra -> TxReturnCollateral CtxTx BabbageEra
forall era ctx.
TxTotalAndReturnCollateralSupportedInEra era
-> TxOut ctx era -> TxReturnCollateral ctx era
C.TxReturnCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra (TxOut CtxTx BabbageEra -> TxReturnCollateral CtxTx BabbageEra)
-> (TxOut -> TxOut CtxTx BabbageEra)
-> TxOut
-> TxReturnCollateral CtxTx BabbageEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut -> TxOut CtxTx BabbageEra
P.getTxOut) Maybe TxOut
txReturnCollateral,)
        (TxTotalCollateral BabbageEra
 -> (TxReturnCollateral CtxTx BabbageEra,
     TxTotalCollateral BabbageEra))
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
-> Either
     ToCardanoError
     (TxReturnCollateral CtxTx BabbageEra, TxTotalCollateral BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either ToCardanoError (TxTotalCollateral BabbageEra)
-> (Value -> Either ToCardanoError (TxTotalCollateral BabbageEra))
-> Maybe Value
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TxTotalCollateral BabbageEra
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxTotalCollateral BabbageEra
forall era. TxTotalCollateral era
C.TxTotalCollateralNone) ((Lovelace -> TxTotalCollateral BabbageEra)
-> Either ToCardanoError Lovelace
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TxTotalAndReturnCollateralSupportedInEra BabbageEra
-> Lovelace -> TxTotalCollateral BabbageEra
forall era.
TxTotalAndReturnCollateralSupportedInEra era
-> Lovelace -> TxTotalCollateral era
C.TxTotalCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra) (Either ToCardanoError Lovelace
 -> Either ToCardanoError (TxTotalCollateral BabbageEra))
-> (Value -> Either ToCardanoError Lovelace)
-> Value
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Either ToCardanoError Lovelace
toCardanoLovelace) Maybe Value
txTotalCollateral
      Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
Nothing -> (TxReturnCollateral CtxTx BabbageEra, TxTotalCollateral BabbageEra)
-> Either
     ToCardanoError
     (TxReturnCollateral CtxTx BabbageEra, TxTotalCollateral BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxReturnCollateral CtxTx BabbageEra
forall ctx era. TxReturnCollateral ctx era
C.TxReturnCollateralNone, TxTotalCollateral BabbageEra
forall era. TxTotalCollateral era
C.TxTotalCollateralNone)
    TxFee BabbageEra
txFee' <- Value -> Either ToCardanoError (TxFee BabbageEra)
toCardanoFee Value
txFee
    (TxValidityLowerBound BabbageEra, TxValidityUpperBound BabbageEra)
txValidityRange <- SlotRange
-> Either
     ToCardanoError
     (TxValidityLowerBound BabbageEra, TxValidityUpperBound BabbageEra)
toCardanoValidityRange SlotRange
txValidRange
    TxMintValue BuildTx BabbageEra
txMintValue <- Tx -> Either ToCardanoError (TxMintValue BuildTx BabbageEra)
toCardanoMintValue Tx
tx
    TxExtraKeyWitnesses BabbageEra
txExtraKeyWits <- TxExtraKeyWitnessesSupportedInEra BabbageEra
-> [Hash PaymentKey] -> TxExtraKeyWitnesses BabbageEra
forall era.
TxExtraKeyWitnessesSupportedInEra era
-> [Hash PaymentKey] -> TxExtraKeyWitnesses era
C.TxExtraKeyWitnesses TxExtraKeyWitnessesSupportedInEra BabbageEra
C.ExtraKeyWitnessesInBabbageEra ([Hash PaymentKey] -> TxExtraKeyWitnesses BabbageEra)
-> Either ToCardanoError [Hash PaymentKey]
-> Either ToCardanoError (TxExtraKeyWitnesses BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PaymentPubKeyHash -> Either ToCardanoError (Hash PaymentKey))
-> [PaymentPubKeyHash] -> Either ToCardanoError [Hash PaymentKey]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse PaymentPubKeyHash -> Either ToCardanoError (Hash PaymentKey)
toCardanoPaymentKeyHash [PaymentPubKeyHash]
sigs
    TxWithdrawals BuildTx BabbageEra
withdrawals <- ScriptsMap
-> NetworkId
-> [Withdrawal]
-> Either ToCardanoError (TxWithdrawals BuildTx BabbageEra)
toWithdrawals ScriptsMap
txScripts NetworkId
networkId [Withdrawal]
txWithdrawals
    CardanoBuildTx -> Either ToCardanoError CardanoBuildTx
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CardanoBuildTx -> Either ToCardanoError CardanoBuildTx)
-> CardanoBuildTx -> Either ToCardanoError CardanoBuildTx
forall a b. (a -> b) -> a -> b
$ TxBodyContent BuildTx BabbageEra -> CardanoBuildTx
CardanoBuildTx (TxBodyContent BuildTx BabbageEra -> CardanoBuildTx)
-> TxBodyContent BuildTx BabbageEra -> CardanoBuildTx
forall a b. (a -> b) -> a -> b
$ TxBodyContent :: forall build era.
TxIns build era
-> TxInsCollateral era
-> TxInsReference build era
-> [TxOut CtxTx era]
-> TxTotalCollateral era
-> TxReturnCollateral CtxTx era
-> TxFee era
-> (TxValidityLowerBound era, TxValidityUpperBound era)
-> TxMetadataInEra era
-> TxAuxScripts era
-> TxExtraKeyWitnesses era
-> BuildTxWith build (Maybe ProtocolParameters)
-> TxWithdrawals build era
-> TxCertificates build era
-> TxUpdateProposal era
-> TxMintValue build era
-> TxScriptValidity era
-> TxBodyContent build era
C.TxBodyContent
        { txIns :: [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))]
txIns = [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))]
txIns
        , txInsReference :: TxInsReference BuildTx BabbageEra
txInsReference = ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
-> [TxIn] -> TxInsReference BuildTx BabbageEra
forall era build.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> [TxIn] -> TxInsReference build era
C.TxInsReference ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
C.ReferenceTxInsScriptsInlineDatumsInBabbageEra [TxIn]
txInsReference
        , txInsCollateral :: TxInsCollateral BabbageEra
txInsCollateral = TxInsCollateral BabbageEra
txInsCollateral
        , txOuts :: [TxOut CtxTx BabbageEra]
txOuts = [TxOut CtxTx BabbageEra]
txOuts
        , txTotalCollateral :: TxTotalCollateral BabbageEra
txTotalCollateral = TxTotalCollateral BabbageEra
totalCollateral
        , txReturnCollateral :: TxReturnCollateral CtxTx BabbageEra
txReturnCollateral = TxReturnCollateral CtxTx BabbageEra
returnCollateral
        , txFee :: TxFee BabbageEra
txFee = TxFee BabbageEra
txFee'
        , txValidityRange :: (TxValidityLowerBound BabbageEra, TxValidityUpperBound BabbageEra)
txValidityRange = (TxValidityLowerBound BabbageEra, TxValidityUpperBound BabbageEra)
txValidityRange
        , txMintValue :: TxMintValue BuildTx BabbageEra
txMintValue = TxMintValue BuildTx BabbageEra
txMintValue
        , txProtocolParams :: BuildTxWith BuildTx (Maybe ProtocolParameters)
txProtocolParams = Maybe ProtocolParameters
-> BuildTxWith BuildTx (Maybe ProtocolParameters)
forall a. a -> BuildTxWith BuildTx a
C.BuildTxWith (Maybe ProtocolParameters
 -> BuildTxWith BuildTx (Maybe ProtocolParameters))
-> Maybe ProtocolParameters
-> BuildTxWith BuildTx (Maybe ProtocolParameters)
forall a b. (a -> b) -> a -> b
$ ProtocolParameters -> Maybe ProtocolParameters
forall a. a -> Maybe a
Just (ProtocolParameters -> Maybe ProtocolParameters)
-> ProtocolParameters -> Maybe ProtocolParameters
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra BabbageEra
-> PParams (ShelleyLedgerEra BabbageEra) -> ProtocolParameters
forall era.
ShelleyBasedEra era
-> PParams (ShelleyLedgerEra era) -> ProtocolParameters
C.fromLedgerPParams ShelleyBasedEra BabbageEra
C.ShelleyBasedEraBabbage PParams (BabbageEra StandardCrypto)
PParams (ShelleyLedgerEra BabbageEra)
protocolParams
        , txScriptValidity :: TxScriptValidity BabbageEra
txScriptValidity = TxScriptValidity BabbageEra
forall era. TxScriptValidity era
C.TxScriptValidityNone
        , TxExtraKeyWitnesses BabbageEra
txExtraKeyWits :: TxExtraKeyWitnesses BabbageEra
txExtraKeyWits :: TxExtraKeyWitnesses BabbageEra
txExtraKeyWits
        -- unused:
        , txMetadata :: TxMetadataInEra BabbageEra
txMetadata = TxMetadataInEra BabbageEra
forall era. TxMetadataInEra era
C.TxMetadataNone
        , txAuxScripts :: TxAuxScripts BabbageEra
txAuxScripts = TxAuxScripts BabbageEra
forall era. TxAuxScripts era
C.TxAuxScriptsNone
        , txWithdrawals :: TxWithdrawals BuildTx BabbageEra
txWithdrawals = TxWithdrawals BuildTx BabbageEra
withdrawals
        , txCertificates :: TxCertificates BuildTx BabbageEra
txCertificates = TxCertificates BuildTx BabbageEra
forall build era. TxCertificates build era
C.TxCertificatesNone
        , txUpdateProposal :: TxUpdateProposal BabbageEra
txUpdateProposal = TxUpdateProposal BabbageEra
forall era. TxUpdateProposal era
C.TxUpdateProposalNone
        }

toWithdrawals :: P.ScriptsMap
  -> C.NetworkId
  -> [P.Withdrawal]
  -> Either ToCardanoError (C.TxWithdrawals C.BuildTx C.BabbageEra)
toWithdrawals :: ScriptsMap
-> NetworkId
-> [Withdrawal]
-> Either ToCardanoError (TxWithdrawals BuildTx BabbageEra)
toWithdrawals ScriptsMap
txScripts NetworkId
networkId = \case
  [] -> TxWithdrawals BuildTx BabbageEra
-> Either ToCardanoError (TxWithdrawals BuildTx BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxWithdrawals BuildTx BabbageEra
forall build era. TxWithdrawals build era
C.TxWithdrawalsNone
  [Withdrawal]
xs -> WithdrawalsSupportedInEra BabbageEra
-> [(StakeAddress, Lovelace,
     BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))]
-> TxWithdrawals BuildTx BabbageEra
forall era build.
WithdrawalsSupportedInEra era
-> [(StakeAddress, Lovelace,
     BuildTxWith build (Witness WitCtxStake era))]
-> TxWithdrawals build era
C.TxWithdrawals WithdrawalsSupportedInEra BabbageEra
C.WithdrawalsInBabbageEra ([(StakeAddress, Lovelace,
   BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))]
 -> TxWithdrawals BuildTx BabbageEra)
-> Either
     ToCardanoError
     [(StakeAddress, Lovelace,
       BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))]
-> Either ToCardanoError (TxWithdrawals BuildTx BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Withdrawal
 -> Either
      ToCardanoError
      (StakeAddress, Lovelace,
       BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)))
-> [Withdrawal]
-> Either
     ToCardanoError
     [(StakeAddress, Lovelace,
       BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Withdrawal
-> Either
     ToCardanoError
     (StakeAddress, Lovelace,
      BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
toWithdraw [Withdrawal]
xs

  where
    toWithdraw :: Withdrawal
-> Either
     ToCardanoError
     (StakeAddress, Lovelace,
      BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
toWithdraw P.Withdrawal{Credential
withdrawalCredential :: Withdrawal -> Credential
withdrawalCredential :: Credential
withdrawalCredential, Integer
withdrawalAmount :: Withdrawal -> Integer
withdrawalAmount :: Integer
withdrawalAmount, Maybe Redeemer
withdrawalRedeemer :: Withdrawal -> Maybe Redeemer
withdrawalRedeemer :: Maybe Redeemer
withdrawalRedeemer} = do
      StakeAddress
saddr <- NetworkId -> Credential -> Either ToCardanoError StakeAddress
toCardanoStakeAddress NetworkId
networkId Credential
withdrawalCredential
      BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
witness <- Maybe Redeemer
-> Credential
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
toStakeWitness Maybe Redeemer
withdrawalRedeemer Credential
withdrawalCredential
      (StakeAddress, Lovelace,
 BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
-> Either
     ToCardanoError
     (StakeAddress, Lovelace,
      BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StakeAddress
saddr, Integer -> Lovelace
C.Lovelace Integer
withdrawalAmount, BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
witness)

    toStakeWitness :: Maybe Redeemer
-> Credential
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
toStakeWitness Maybe Redeemer
withdrawalRedeemer Credential
cred = case Credential
cred of
      PV1.PubKeyCredential PubKeyHash
_pkh -> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
 -> Either
      ToCardanoError
      (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)))
-> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
forall a b. (a -> b) -> a -> b
$ Witness WitCtxStake BabbageEra
-> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
forall a. a -> BuildTxWith BuildTx a
C.BuildTxWith (Witness WitCtxStake BabbageEra
 -> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
-> Witness WitCtxStake BabbageEra
-> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
forall a b. (a -> b) -> a -> b
$ KeyWitnessInCtx WitCtxStake -> Witness WitCtxStake BabbageEra
forall witctx era. KeyWitnessInCtx witctx -> Witness witctx era
C.KeyWitness KeyWitnessInCtx WitCtxStake
C.KeyWitnessForStakeAddr
      PV1.ScriptCredential ValidatorHash
_vh -> case (,) (Redeemer
 -> Versioned Validator -> (Redeemer, Versioned Validator))
-> Maybe Redeemer
-> Maybe (Versioned Validator -> (Redeemer, Versioned Validator))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Redeemer
withdrawalRedeemer Maybe (Versioned Validator -> (Redeemer, Versioned Validator))
-> Maybe (Versioned Validator)
-> Maybe (Redeemer, Versioned Validator)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ScriptsMap -> ValidatorHash -> Maybe (Versioned Validator)
P.lookupValidator ScriptsMap
txScripts ValidatorHash
_vh of
        Just (Redeemer
redeemer, Versioned Validator
script) -> Witness WitCtxStake BabbageEra
-> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
forall a. a -> BuildTxWith BuildTx a
C.BuildTxWith (Witness WitCtxStake BabbageEra
 -> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
-> (ScriptWitness WitCtxStake BabbageEra
    -> Witness WitCtxStake BabbageEra)
-> ScriptWitness WitCtxStake BabbageEra
-> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScriptWitnessInCtx WitCtxStake
-> ScriptWitness WitCtxStake BabbageEra
-> Witness WitCtxStake BabbageEra
forall witctx era.
ScriptWitnessInCtx witctx
-> ScriptWitness witctx era -> Witness witctx era
C.ScriptWitness ScriptWitnessInCtx WitCtxStake
C.ScriptWitnessForStakeAddr (ScriptWitness WitCtxStake BabbageEra
 -> BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
-> Either ToCardanoError (ScriptWitness WitCtxStake BabbageEra)
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ScriptDatum WitCtxStake
-> Redeemer
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness WitCtxStake BabbageEra)
forall a witctx.
ToData a =>
ScriptDatum witctx
-> a
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness witctx BabbageEra)
toCardanoScriptWitness ScriptDatum WitCtxStake
C.NoScriptDatumForStake Redeemer
redeemer (Versioned Script -> Either (Versioned Script) (Versioned TxOutRef)
forall a b. a -> Either a b
Left (Versioned Script
 -> Either (Versioned Script) (Versioned TxOutRef))
-> Versioned Script
-> Either (Versioned Script) (Versioned TxOutRef)
forall a b. (a -> b) -> a -> b
$ (Validator -> Script) -> Versioned Validator -> Versioned Script
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Validator -> Script
P.getValidator Versioned Validator
script)
        Maybe (Redeemer, Versioned Validator)
Nothing                    -> ToCardanoError
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxStake BabbageEra))
forall a b. a -> Either a b
Left ToCardanoError
MissingStakeValidator

toCardanoMintWitness :: PV1.Redeemer -> Maybe (P.Versioned PV1.TxOutRef) -> Maybe (P.Versioned PV1.MintingPolicy) -> Either ToCardanoError (C.ScriptWitness C.WitCtxMint C.BabbageEra)
toCardanoMintWitness :: Redeemer
-> Maybe (Versioned TxOutRef)
-> Maybe (Versioned MintingPolicy)
-> Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra)
toCardanoMintWitness Redeemer
_ Maybe (Versioned TxOutRef)
Nothing Maybe (Versioned MintingPolicy)
Nothing = ToCardanoError
-> Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra)
forall a b. a -> Either a b
Left ToCardanoError
MissingMintingPolicy
toCardanoMintWitness Redeemer
redeemer (Just Versioned TxOutRef
ref) Maybe (Versioned MintingPolicy)
_ =
  ScriptDatum WitCtxMint
-> Redeemer
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra)
forall a witctx.
ToData a =>
ScriptDatum witctx
-> a
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness witctx BabbageEra)
toCardanoScriptWitness ScriptDatum WitCtxMint
C.NoScriptDatumForMint Redeemer
redeemer (Versioned TxOutRef
-> Either (Versioned Script) (Versioned TxOutRef)
forall a b. b -> Either a b
Right Versioned TxOutRef
ref)
toCardanoMintWitness Redeemer
redeemer Maybe (Versioned TxOutRef)
_ (Just Versioned MintingPolicy
script) =
  ScriptDatum WitCtxMint
-> Redeemer
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra)
forall a witctx.
ToData a =>
ScriptDatum witctx
-> a
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness witctx BabbageEra)
toCardanoScriptWitness ScriptDatum WitCtxMint
C.NoScriptDatumForMint Redeemer
redeemer (Versioned Script -> Either (Versioned Script) (Versioned TxOutRef)
forall a b. a -> Either a b
Left ((MintingPolicy -> Script)
-> Versioned MintingPolicy -> Versioned Script
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MintingPolicy -> Script
P.getMintingPolicy Versioned MintingPolicy
script))

toCardanoScriptWitness :: PV1.ToData a =>
  C.ScriptDatum witctx
  -> a
  -> Either (P.Versioned PV1.Script) (P.Versioned PV1.TxOutRef)
  -> Either ToCardanoError (C.ScriptWitness witctx C.BabbageEra)
toCardanoScriptWitness :: ScriptDatum witctx
-> a
-> Either (Versioned Script) (Versioned TxOutRef)
-> Either ToCardanoError (ScriptWitness witctx BabbageEra)
toCardanoScriptWitness ScriptDatum witctx
datum a
redeemer Either (Versioned Script) (Versioned TxOutRef)
scriptOrRef = (case Language
lang of
    Language
P.PlutusV1 ->
      ScriptLanguageInEra PlutusScriptV1 BabbageEra
-> PlutusScriptVersion PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx BabbageEra
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV1 BabbageEra
C.PlutusScriptV1InBabbage PlutusScriptVersion PlutusScriptV1
C.PlutusScriptV1
          (PlutusScriptOrReferenceInput PlutusScriptV1
 -> ScriptDatum witctx
 -> ScriptRedeemer
 -> ExecutionUnits
 -> ScriptWitness witctx BabbageEra)
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV1)
-> Either
     ToCardanoError
     (ScriptDatum witctx
      -> ScriptRedeemer
      -> ExecutionUnits
      -> ScriptWitness witctx BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (case Either (Versioned Script) (Versioned TxOutRef)
scriptOrRef of
            Left (P.Versioned Script
script Language
_) -> (PlutusScript PlutusScriptV1
 -> PlutusScriptOrReferenceInput PlutusScriptV1)
-> Either ToCardanoError (PlutusScript PlutusScriptV1)
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PlutusScript PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
C.PScript (AsType (PlutusScript PlutusScriptV1)
-> Script -> Either ToCardanoError (PlutusScript PlutusScriptV1)
forall plutusScript.
SerialiseAsRawBytes plutusScript =>
AsType plutusScript -> Script -> Either ToCardanoError plutusScript
toCardanoPlutusScript (AsType PlutusScriptV1 -> AsType (PlutusScript PlutusScriptV1)
forall lang. AsType lang -> AsType (PlutusScript lang)
C.AsPlutusScript AsType PlutusScriptV1
C.AsPlutusScriptV1) Script
script)
            Right (P.Versioned TxOutRef
ref Language
_) -> (TxIn
 -> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV1)
-> Maybe ScriptHash
-> TxIn
-> PlutusScriptOrReferenceInput PlutusScriptV1
forall a b c. (a -> b -> c) -> b -> a -> c
flip TxIn
-> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV1
forall lang.
TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
C.PReferenceScript Maybe ScriptHash
forall a. Maybe a
Nothing (TxIn -> PlutusScriptOrReferenceInput PlutusScriptV1)
-> Either ToCardanoError TxIn
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn TxOutRef
ref
          )
    Language
P.PlutusV2 ->
      ScriptLanguageInEra PlutusScriptV2 BabbageEra
-> PlutusScriptVersion PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx BabbageEra
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV2 BabbageEra
C.PlutusScriptV2InBabbage PlutusScriptVersion PlutusScriptV2
C.PlutusScriptV2
          (PlutusScriptOrReferenceInput PlutusScriptV2
 -> ScriptDatum witctx
 -> ScriptRedeemer
 -> ExecutionUnits
 -> ScriptWitness witctx BabbageEra)
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV2)
-> Either
     ToCardanoError
     (ScriptDatum witctx
      -> ScriptRedeemer
      -> ExecutionUnits
      -> ScriptWitness witctx BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (case Either (Versioned Script) (Versioned TxOutRef)
scriptOrRef of
            Left (P.Versioned Script
script Language
_) -> (PlutusScript PlutusScriptV2
 -> PlutusScriptOrReferenceInput PlutusScriptV2)
-> Either ToCardanoError (PlutusScript PlutusScriptV2)
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PlutusScript PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
C.PScript (AsType (PlutusScript PlutusScriptV2)
-> Script -> Either ToCardanoError (PlutusScript PlutusScriptV2)
forall plutusScript.
SerialiseAsRawBytes plutusScript =>
AsType plutusScript -> Script -> Either ToCardanoError plutusScript
toCardanoPlutusScript (AsType PlutusScriptV2 -> AsType (PlutusScript PlutusScriptV2)
forall lang. AsType lang -> AsType (PlutusScript lang)
C.AsPlutusScript AsType PlutusScriptV2
C.AsPlutusScriptV2) Script
script)
            Right (P.Versioned TxOutRef
ref Language
_) -> (TxIn
 -> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV2)
-> Maybe ScriptHash
-> TxIn
-> PlutusScriptOrReferenceInput PlutusScriptV2
forall a b c. (a -> b -> c) -> b -> a -> c
flip TxIn
-> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV2
forall lang.
TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
C.PReferenceScript Maybe ScriptHash
forall a. Maybe a
Nothing (TxIn -> PlutusScriptOrReferenceInput PlutusScriptV2)
-> Either ToCardanoError TxIn
-> Either
     ToCardanoError (PlutusScriptOrReferenceInput PlutusScriptV2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn TxOutRef
ref
          )
  ) Either
  ToCardanoError
  (ScriptDatum witctx
   -> ScriptRedeemer
   -> ExecutionUnits
   -> ScriptWitness witctx BabbageEra)
-> Either ToCardanoError (ScriptDatum witctx)
-> Either
     ToCardanoError
     (ScriptRedeemer
      -> ExecutionUnits -> ScriptWitness witctx BabbageEra)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ScriptDatum witctx -> Either ToCardanoError (ScriptDatum witctx)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ScriptDatum witctx
datum
    Either
  ToCardanoError
  (ScriptRedeemer
   -> ExecutionUnits -> ScriptWitness witctx BabbageEra)
-> Either ToCardanoError ScriptRedeemer
-> Either
     ToCardanoError (ExecutionUnits -> ScriptWitness witctx BabbageEra)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ScriptRedeemer -> Either ToCardanoError ScriptRedeemer
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Data -> ScriptRedeemer
C.fromPlutusData (Data -> ScriptRedeemer) -> Data -> ScriptRedeemer
forall a b. (a -> b) -> a -> b
$ a -> Data
forall a. ToData a => a -> Data
PV1.toData a
redeemer)
    Either
  ToCardanoError (ExecutionUnits -> ScriptWitness witctx BabbageEra)
-> Either ToCardanoError ExecutionUnits
-> Either ToCardanoError (ScriptWitness witctx BabbageEra)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ExecutionUnits -> Either ToCardanoError ExecutionUnits
forall (f :: * -> *) a. Applicative f => a -> f a
pure ExecutionUnits
zeroExecutionUnits
  where
    lang :: Language
lang = (Versioned Script -> Language)
-> (Versioned TxOutRef -> Language)
-> Either (Versioned Script) (Versioned TxOutRef)
-> Language
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Versioned Script -> Language
forall script. Versioned script -> Language
P.version Versioned TxOutRef -> Language
forall script. Versioned script -> Language
P.version Either (Versioned Script) (Versioned TxOutRef)
scriptOrRef

toCardanoStakeAddress :: C.NetworkId -> PV1.Credential -> Either ToCardanoError C.StakeAddress
toCardanoStakeAddress :: NetworkId -> Credential -> Either ToCardanoError StakeAddress
toCardanoStakeAddress NetworkId
networkId Credential
credential =
  Network -> StakeCredential StandardCrypto -> StakeAddress
C.StakeAddress (NetworkId -> Network
C.toShelleyNetwork NetworkId
networkId) (StakeCredential StandardCrypto -> StakeAddress)
-> (StakeCredential -> StakeCredential StandardCrypto)
-> StakeCredential
-> StakeAddress
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StakeCredential -> StakeCredential StandardCrypto
C.toShelleyStakeCredential (StakeCredential -> StakeAddress)
-> Either ToCardanoError StakeCredential
-> Either ToCardanoError StakeAddress
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Credential -> Either ToCardanoError StakeCredential
toCardanoStakingCredential Credential
credential

toCardanoStakingCredential :: PV1.Credential -> Either ToCardanoError C.StakeCredential
toCardanoStakingCredential :: Credential -> Either ToCardanoError StakeCredential
toCardanoStakingCredential (PV1.PubKeyCredential PubKeyHash
pubKeyHash) = Hash StakeKey -> StakeCredential
C.StakeCredentialByKey (Hash StakeKey -> StakeCredential)
-> Either ToCardanoError (Hash StakeKey)
-> Either ToCardanoError StakeCredential
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PubKeyHash -> Either ToCardanoError (Hash StakeKey)
toCardanoStakeKeyHash PubKeyHash
pubKeyHash
toCardanoStakingCredential (PV1.ScriptCredential ValidatorHash
validatorHash) = ScriptHash -> StakeCredential
C.StakeCredentialByScript (ScriptHash -> StakeCredential)
-> Either ToCardanoError ScriptHash
-> Either ToCardanoError StakeCredential
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ValidatorHash -> Either ToCardanoError ScriptHash
toCardanoScriptHash ValidatorHash
validatorHash


toCardanoTxBody ::
    C.NetworkId
    -> Babbage.PParams (Babbage.BabbageEra StandardCrypto)
    -> [P.PaymentPubKeyHash] -- ^ Required signers of the transaction
    -> P.Tx
    -> Either ToCardanoError (C.TxBody C.BabbageEra)
toCardanoTxBody :: NetworkId
-> PParams (BabbageEra StandardCrypto)
-> [PaymentPubKeyHash]
-> Tx
-> Either ToCardanoError (TxBody BabbageEra)
toCardanoTxBody NetworkId
networkId PParams (BabbageEra StandardCrypto)
params [PaymentPubKeyHash]
sigs Tx
tx = do
    CardanoBuildTx
txBodyContent <- NetworkId
-> PParams (BabbageEra StandardCrypto)
-> [PaymentPubKeyHash]
-> Tx
-> Either ToCardanoError CardanoBuildTx
toCardanoTxBodyContent NetworkId
networkId PParams (BabbageEra StandardCrypto)
params [PaymentPubKeyHash]
sigs Tx
tx
    Maybe (PParams (BabbageEra StandardCrypto))
-> Map RdmrPtr ExUnits
-> CardanoBuildTx
-> Either ToCardanoError (TxBody BabbageEra)
makeTransactionBody (PParams (BabbageEra StandardCrypto)
-> Maybe (PParams (BabbageEra StandardCrypto))
forall a. a -> Maybe a
Just PParams (BabbageEra StandardCrypto)
params) Map RdmrPtr ExUnits
forall a. Monoid a => a
mempty CardanoBuildTx
txBodyContent

toCardanoTxInBuild :: P.Tx -> P.TxInput -> Either ToCardanoError (C.TxIn, C.BuildTxWith C.BuildTx (C.Witness C.WitCtxTxIn C.BabbageEra))
toCardanoTxInBuild :: Tx
-> TxInput
-> Either
     ToCardanoError
     (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
toCardanoTxInBuild Tx
tx (P.TxInput TxOutRef
txInRef TxInputType
txInType) = (,) (TxIn
 -> BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)
 -> (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)))
-> Either ToCardanoError TxIn
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)
      -> (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn TxOutRef
txInRef Either
  ToCardanoError
  (BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)
   -> (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)))
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
-> Either
     ToCardanoError
     (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Witness WitCtxTxIn BabbageEra
-> BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra)
forall a. a -> BuildTxWith BuildTx a
C.BuildTxWith (Witness WitCtxTxIn BabbageEra
 -> BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
-> Either
     ToCardanoError
     (BuildTxWith BuildTx (Witness WitCtxTxIn BabbageEra))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tx
-> TxInputType
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
toCardanoTxInWitness Tx
tx TxInputType
txInType)

fromCardanoTxInsCollateral :: C.TxInsCollateral era -> [P.TxIn]
fromCardanoTxInsCollateral :: TxInsCollateral era -> [TxIn]
fromCardanoTxInsCollateral TxInsCollateral era
C.TxInsCollateralNone       = []
fromCardanoTxInsCollateral (C.TxInsCollateral CollateralSupportedInEra era
_ [TxIn]
txIns) = (TxIn -> TxIn) -> [TxIn] -> [TxIn]
forall a b. (a -> b) -> [a] -> [b]
map (TxOutRef -> TxIn
P.pubKeyTxIn (TxOutRef -> TxIn) -> (TxIn -> TxOutRef) -> TxIn -> TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxIn -> TxOutRef
fromCardanoTxIn) [TxIn]
txIns

toCardanoTxInsCollateral :: [P.TxInput] -> Either ToCardanoError (C.TxInsCollateral C.BabbageEra)
toCardanoTxInsCollateral :: [TxInput] -> Either ToCardanoError (TxInsCollateral BabbageEra)
toCardanoTxInsCollateral [] = TxInsCollateral BabbageEra
-> Either ToCardanoError (TxInsCollateral BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxInsCollateral BabbageEra
forall era. TxInsCollateral era
C.TxInsCollateralNone
toCardanoTxInsCollateral [TxInput]
inputs = ([TxIn] -> TxInsCollateral BabbageEra)
-> Either ToCardanoError [TxIn]
-> Either ToCardanoError (TxInsCollateral BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CollateralSupportedInEra BabbageEra
-> [TxIn] -> TxInsCollateral BabbageEra
forall era.
CollateralSupportedInEra era -> [TxIn] -> TxInsCollateral era
C.TxInsCollateral CollateralSupportedInEra BabbageEra
C.CollateralInBabbageEra) ((TxInput -> Either ToCardanoError TxIn)
-> [TxInput] -> Either ToCardanoError [TxIn]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn (TxOutRef -> Either ToCardanoError TxIn)
-> (TxInput -> TxOutRef) -> TxInput -> Either ToCardanoError TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxInput -> TxOutRef
P.txInputRef) [TxInput]
inputs)

toCardanoTxInWitness :: P.Tx -> P.TxInputType -> Either ToCardanoError (C.Witness C.WitCtxTxIn C.BabbageEra)
toCardanoTxInWitness :: Tx
-> TxInputType
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
toCardanoTxInWitness Tx
_ TxInputType
P.TxConsumePublicKeyAddress = Witness WitCtxTxIn BabbageEra
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (KeyWitnessInCtx WitCtxTxIn -> Witness WitCtxTxIn BabbageEra
forall witctx era. KeyWitnessInCtx witctx -> Witness witctx era
C.KeyWitness KeyWitnessInCtx WitCtxTxIn
C.KeyWitnessForSpending)
toCardanoTxInWitness Tx
_ TxInputType
P.TxConsumeSimpleScriptAddress = ToCardanoError
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
forall a b. a -> Either a b
Left ToCardanoError
SimpleScriptsNotSupportedToCardano -- TODO: Better support for simple scripts
toCardanoTxInWitness Tx
tx
    (P.TxScriptAddress
        (P.Redeemer BuiltinData
redeemer)
        Either ValidatorHash (Versioned TxOutRef)
valhOrRef
        Maybe DatumHash
dh)
    = do
      Maybe Datum
mDatum <- (DatumHash -> Either ToCardanoError Datum)
-> Maybe DatumHash -> Either ToCardanoError (Maybe Datum)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Either ToCardanoError Datum
-> (Datum -> Either ToCardanoError Datum)
-> Maybe Datum
-> Either ToCardanoError Datum
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ToCardanoError -> Either ToCardanoError Datum
forall a b. a -> Either a b
Left ToCardanoError
MissingDatum) Datum -> Either ToCardanoError Datum
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Datum -> Either ToCardanoError Datum)
-> (DatumHash -> Maybe Datum)
-> DatumHash
-> Either ToCardanoError Datum
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DatumHash -> Map DatumHash Datum -> Maybe Datum
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` Tx -> Map DatumHash Datum
P.txData Tx
tx)) Maybe DatumHash
dh
      WitnessHeader
mkWitness <- case Either ValidatorHash (Versioned TxOutRef)
valhOrRef of
        Left ValidatorHash
valh -> Either ToCardanoError WitnessHeader
-> (Versioned Validator -> Either ToCardanoError WitnessHeader)
-> Maybe (Versioned Validator)
-> Either ToCardanoError WitnessHeader
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ToCardanoError -> Either ToCardanoError WitnessHeader
forall a b. a -> Either a b
Left ToCardanoError
MissingInputValidator) (Versioned Script -> Either ToCardanoError WitnessHeader
toCardanoTxInScriptWitnessHeader (Versioned Script -> Either ToCardanoError WitnessHeader)
-> (Versioned Validator -> Versioned Script)
-> Versioned Validator
-> Either ToCardanoError WitnessHeader
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Validator -> Script) -> Versioned Validator -> Versioned Script
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Validator -> Script
PV1.getValidator) (Maybe (Versioned Validator)
 -> Either ToCardanoError WitnessHeader)
-> Maybe (Versioned Validator)
-> Either ToCardanoError WitnessHeader
forall a b. (a -> b) -> a -> b
$ ScriptsMap -> ValidatorHash -> Maybe (Versioned Validator)
P.lookupValidator (Tx -> ScriptsMap
P.txScripts Tx
tx) ValidatorHash
valh
        Right Versioned TxOutRef
vref -> Versioned TxOutRef -> Either ToCardanoError WitnessHeader
toCardanoTxInReferenceWitnessHeader Versioned TxOutRef
vref
      Witness WitCtxTxIn BabbageEra
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Witness WitCtxTxIn BabbageEra
 -> Either ToCardanoError (Witness WitCtxTxIn BabbageEra))
-> Witness WitCtxTxIn BabbageEra
-> Either ToCardanoError (Witness WitCtxTxIn BabbageEra)
forall a b. (a -> b) -> a -> b
$ ScriptWitnessInCtx WitCtxTxIn
-> ScriptWitness WitCtxTxIn BabbageEra
-> Witness WitCtxTxIn BabbageEra
forall witctx era.
ScriptWitnessInCtx witctx
-> ScriptWitness witctx era -> Witness witctx era
C.ScriptWitness ScriptWitnessInCtx WitCtxTxIn
C.ScriptWitnessForSpending (ScriptWitness WitCtxTxIn BabbageEra
 -> Witness WitCtxTxIn BabbageEra)
-> ScriptWitness WitCtxTxIn BabbageEra
-> Witness WitCtxTxIn BabbageEra
forall a b. (a -> b) -> a -> b
$ WitnessHeader
mkWitness
            (Maybe Datum -> ScriptDatum WitCtxTxIn
toCardanoDatumWitness Maybe Datum
mDatum)
            (BuiltinData -> ScriptRedeemer
toCardanoScriptData BuiltinData
redeemer)
            ExecutionUnits
zeroExecutionUnits

toCardanoDatumWitness :: Maybe PV1.Datum -> C.ScriptDatum C.WitCtxTxIn
toCardanoDatumWitness :: Maybe Datum -> ScriptDatum WitCtxTxIn
toCardanoDatumWitness = ScriptDatum WitCtxTxIn
-> (Datum -> ScriptDatum WitCtxTxIn)
-> Maybe Datum
-> ScriptDatum WitCtxTxIn
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ScriptDatum WitCtxTxIn
C.InlineScriptDatum (ScriptRedeemer -> ScriptDatum WitCtxTxIn
C.ScriptDatumForTxIn (ScriptRedeemer -> ScriptDatum WitCtxTxIn)
-> (Datum -> ScriptRedeemer) -> Datum -> ScriptDatum WitCtxTxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BuiltinData -> ScriptRedeemer
toCardanoScriptData (BuiltinData -> ScriptRedeemer)
-> (Datum -> BuiltinData) -> Datum -> ScriptRedeemer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Datum -> BuiltinData
PV1.getDatum)

type WitnessHeader = C.ScriptDatum C.WitCtxTxIn -> C.ScriptRedeemer -> C.ExecutionUnits -> C.ScriptWitness C.WitCtxTxIn C.BabbageEra

toCardanoTxInReferenceWitnessHeader :: P.Versioned PV1.TxOutRef -> Either ToCardanoError WitnessHeader
toCardanoTxInReferenceWitnessHeader :: Versioned TxOutRef -> Either ToCardanoError WitnessHeader
toCardanoTxInReferenceWitnessHeader (P.Versioned TxOutRef
ref Language
lang) = do
    TxIn
txIn <- TxOutRef -> Either ToCardanoError TxIn
toCardanoTxIn TxOutRef
ref
    WitnessHeader -> Either ToCardanoError WitnessHeader
forall (f :: * -> *) a. Applicative f => a -> f a
pure (WitnessHeader -> Either ToCardanoError WitnessHeader)
-> WitnessHeader -> Either ToCardanoError WitnessHeader
forall a b. (a -> b) -> a -> b
$ case Language
lang of
        Language
P.PlutusV1 ->
            ScriptLanguageInEra PlutusScriptV1 BabbageEra
-> PlutusScriptVersion PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
-> WitnessHeader
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV1 BabbageEra
C.PlutusScriptV1InBabbage PlutusScriptVersion PlutusScriptV1
C.PlutusScriptV1 (PlutusScriptOrReferenceInput PlutusScriptV1 -> WitnessHeader)
-> PlutusScriptOrReferenceInput PlutusScriptV1 -> WitnessHeader
forall a b. (a -> b) -> a -> b
$
                TxIn
-> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV1
forall lang.
TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
C.PReferenceScript TxIn
txIn Maybe ScriptHash
forall a. Maybe a
Nothing
        Language
P.PlutusV2 ->
            ScriptLanguageInEra PlutusScriptV2 BabbageEra
-> PlutusScriptVersion PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
-> WitnessHeader
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV2 BabbageEra
C.PlutusScriptV2InBabbage PlutusScriptVersion PlutusScriptV2
C.PlutusScriptV2 (PlutusScriptOrReferenceInput PlutusScriptV2 -> WitnessHeader)
-> PlutusScriptOrReferenceInput PlutusScriptV2 -> WitnessHeader
forall a b. (a -> b) -> a -> b
$
                TxIn
-> Maybe ScriptHash -> PlutusScriptOrReferenceInput PlutusScriptV2
forall lang.
TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
C.PReferenceScript TxIn
txIn Maybe ScriptHash
forall a. Maybe a
Nothing

toCardanoTxInScriptWitnessHeader :: P.Versioned PV1.Script -> Either ToCardanoError WitnessHeader
toCardanoTxInScriptWitnessHeader :: Versioned Script -> Either ToCardanoError WitnessHeader
toCardanoTxInScriptWitnessHeader (P.Versioned Script
script Language
lang) =
    case Language
lang of
        Language
P.PlutusV1 ->
            ScriptLanguageInEra PlutusScriptV1 BabbageEra
-> PlutusScriptVersion PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
-> WitnessHeader
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV1 BabbageEra
C.PlutusScriptV1InBabbage PlutusScriptVersion PlutusScriptV1
C.PlutusScriptV1 (PlutusScriptOrReferenceInput PlutusScriptV1 -> WitnessHeader)
-> (PlutusScript PlutusScriptV1
    -> PlutusScriptOrReferenceInput PlutusScriptV1)
-> PlutusScript PlutusScriptV1
-> WitnessHeader
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScript PlutusScriptV1
-> PlutusScriptOrReferenceInput PlutusScriptV1
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
C.PScript (PlutusScript PlutusScriptV1 -> WitnessHeader)
-> Either ToCardanoError (PlutusScript PlutusScriptV1)
-> Either ToCardanoError WitnessHeader
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                AsType (PlutusScript PlutusScriptV1)
-> Script -> Either ToCardanoError (PlutusScript PlutusScriptV1)
forall plutusScript.
SerialiseAsRawBytes plutusScript =>
AsType plutusScript -> Script -> Either ToCardanoError plutusScript
toCardanoPlutusScript (AsType PlutusScriptV1 -> AsType (PlutusScript PlutusScriptV1)
forall lang. AsType lang -> AsType (PlutusScript lang)
C.AsPlutusScript AsType PlutusScriptV1
C.AsPlutusScriptV1) Script
script
        Language
P.PlutusV2 ->
            ScriptLanguageInEra PlutusScriptV2 BabbageEra
-> PlutusScriptVersion PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
-> WitnessHeader
forall lang era witctx.
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> ScriptRedeemer
-> ExecutionUnits
-> ScriptWitness witctx era
C.PlutusScriptWitness ScriptLanguageInEra PlutusScriptV2 BabbageEra
C.PlutusScriptV2InBabbage PlutusScriptVersion PlutusScriptV2
C.PlutusScriptV2 (PlutusScriptOrReferenceInput PlutusScriptV2 -> WitnessHeader)
-> (PlutusScript PlutusScriptV2
    -> PlutusScriptOrReferenceInput PlutusScriptV2)
-> PlutusScript PlutusScriptV2
-> WitnessHeader
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScript PlutusScriptV2
-> PlutusScriptOrReferenceInput PlutusScriptV2
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
C.PScript (PlutusScript PlutusScriptV2 -> WitnessHeader)
-> Either ToCardanoError (PlutusScript PlutusScriptV2)
-> Either ToCardanoError WitnessHeader
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                AsType (PlutusScript PlutusScriptV2)
-> Script -> Either ToCardanoError (PlutusScript PlutusScriptV2)
forall plutusScript.
SerialiseAsRawBytes plutusScript =>
AsType plutusScript -> Script -> Either ToCardanoError plutusScript
toCardanoPlutusScript (AsType PlutusScriptV2 -> AsType (PlutusScript PlutusScriptV2)
forall lang. AsType lang -> AsType (PlutusScript lang)
C.AsPlutusScript AsType PlutusScriptV2
C.AsPlutusScriptV2) Script
script

toCardanoMintValue :: P.Tx -> Either ToCardanoError (C.TxMintValue C.BuildTx C.BabbageEra)
toCardanoMintValue :: Tx -> Either ToCardanoError (TxMintValue BuildTx BabbageEra)
toCardanoMintValue tx :: Tx
tx@P.Tx{[TxOut]
[Certificate]
[Withdrawal]
[TxInput]
Maybe Value
Maybe BuiltinByteString
Maybe TxOut
ScriptsMap
Map DatumHash Datum
MintingWitnessesMap
Map PubKey Signature
Value
SlotRange
txMetadata :: Maybe BuiltinByteString
txData :: Map DatumHash Datum
txScripts :: ScriptsMap
txSignatures :: Map PubKey Signature
txCertificates :: [Certificate]
txWithdrawals :: [Withdrawal]
txMintingWitnesses :: MintingWitnessesMap
txValidRange :: SlotRange
txFee :: Value
txMint :: Value
txTotalCollateral :: Maybe Value
txReturnCollateral :: Maybe TxOut
txOutputs :: [TxOut]
txCollateralInputs :: [TxInput]
txReferenceInputs :: [TxInput]
txInputs :: [TxInput]
txMetadata :: Tx -> Maybe BuiltinByteString
txData :: Tx -> Map DatumHash Datum
txScripts :: Tx -> ScriptsMap
txSignatures :: Tx -> Map PubKey Signature
txCertificates :: Tx -> [Certificate]
txWithdrawals :: Tx -> [Withdrawal]
txMintingWitnesses :: Tx -> MintingWitnessesMap
txValidRange :: Tx -> SlotRange
txFee :: Tx -> Value
txMint :: Tx -> Value
txTotalCollateral :: Tx -> Maybe Value
txReturnCollateral :: Tx -> Maybe TxOut
txOutputs :: Tx -> [TxOut]
txCollateralInputs :: Tx -> [TxInput]
txReferenceInputs :: Tx -> [TxInput]
txInputs :: Tx -> [TxInput]
..} =
    let indexedMps :: [(MintingPolicyHash, (Redeemer, Maybe (Versioned TxOutRef)))]
indexedMps = MintingWitnessesMap
-> [(MintingPolicyHash, (Redeemer, Maybe (Versioned TxOutRef)))]
forall k a. Map k a -> [(k, a)]
Map.assocs MintingWitnessesMap
txMintingWitnesses
    in MultiAssetSupportedInEra BabbageEra
-> Value
-> BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
-> TxMintValue BuildTx BabbageEra
forall era build.
MultiAssetSupportedInEra era
-> Value
-> BuildTxWith build (Map PolicyId (ScriptWitness WitCtxMint era))
-> TxMintValue build era
C.TxMintValue MultiAssetSupportedInEra BabbageEra
C.MultiAssetInBabbageEra
       (Value
 -> BuildTxWith
      BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
 -> TxMintValue BuildTx BabbageEra)
-> Either ToCardanoError Value
-> Either
     ToCardanoError
     (BuildTxWith
        BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
      -> TxMintValue BuildTx BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Either ToCardanoError Value
toCardanoValue Value
txMint
       Either
  ToCardanoError
  (BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
   -> TxMintValue BuildTx BabbageEra)
-> Either
     ToCardanoError
     (BuildTxWith
        BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)))
-> Either ToCardanoError (TxMintValue BuildTx BabbageEra)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
 -> BuildTxWith
      BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)))
-> Either
     ToCardanoError [(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
-> Either
     ToCardanoError
     (BuildTxWith
        BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)
-> BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
forall a. a -> BuildTxWith BuildTx a
C.BuildTxWith (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)
 -> BuildTxWith
      BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra)))
-> ([(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
    -> Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
-> [(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
-> BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint BabbageEra))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
-> Map PolicyId (ScriptWitness WitCtxMint BabbageEra)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList)
             (((MintingPolicyHash, (Redeemer, Maybe (Versioned TxOutRef)))
 -> Either
      ToCardanoError (PolicyId, ScriptWitness WitCtxMint BabbageEra))
-> [(MintingPolicyHash, (Redeemer, Maybe (Versioned TxOutRef)))]
-> Either
     ToCardanoError [(PolicyId, ScriptWitness WitCtxMint BabbageEra)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\(MintingPolicyHash
mph, (Redeemer
rd, Maybe (Versioned TxOutRef)
mTxOutRef)) ->
                (Either ToCardanoError PolicyId,
 Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra))
-> Either
     ToCardanoError (PolicyId, ScriptWitness WitCtxMint BabbageEra)
forall (t :: * -> * -> *) (f :: * -> *) a b.
(Bitraversable t, Applicative f) =>
t (f a) (f b) -> f (t a b)
bisequence (MintingPolicyHash -> Either ToCardanoError PolicyId
toCardanoPolicyId MintingPolicyHash
mph, Redeemer
-> Maybe (Versioned TxOutRef)
-> Maybe (Versioned MintingPolicy)
-> Either ToCardanoError (ScriptWitness WitCtxMint BabbageEra)
toCardanoMintWitness Redeemer
rd Maybe (Versioned TxOutRef)
mTxOutRef (ScriptsMap -> MintingPolicyHash -> Maybe (Versioned MintingPolicy)
P.lookupMintingPolicy (Tx -> ScriptsMap
P.txScripts Tx
tx) MintingPolicyHash
mph)))
                [(MintingPolicyHash, (Redeemer, Maybe (Versioned TxOutRef)))]
indexedMps)

fromCardanoTotalCollateral :: C.TxTotalCollateral C.BabbageEra -> Maybe PV1.Value
fromCardanoTotalCollateral :: TxTotalCollateral BabbageEra -> Maybe Value
fromCardanoTotalCollateral TxTotalCollateral BabbageEra
C.TxTotalCollateralNone    = Maybe Value
forall a. Maybe a
Nothing
fromCardanoTotalCollateral (C.TxTotalCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
_ Lovelace
lv) = Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Maybe Value) -> Value -> Maybe Value
forall a b. (a -> b) -> a -> b
$ Lovelace -> Value
fromCardanoLovelace Lovelace
lv

toCardanoTotalCollateral :: Maybe PV1.Value -> Either ToCardanoError (C.TxTotalCollateral C.BabbageEra)
toCardanoTotalCollateral :: Maybe Value -> Either ToCardanoError (TxTotalCollateral BabbageEra)
toCardanoTotalCollateral Maybe Value
totalCollateral =
  case CardanoEra BabbageEra
-> Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
forall era.
CardanoEra era
-> Maybe (TxTotalAndReturnCollateralSupportedInEra era)
C.totalAndReturnCollateralSupportedInEra CardanoEra BabbageEra
C.BabbageEra of
    Just TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra ->
      Either ToCardanoError (TxTotalCollateral BabbageEra)
-> (Value -> Either ToCardanoError (TxTotalCollateral BabbageEra))
-> Maybe Value
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (TxTotalCollateral BabbageEra
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxTotalCollateral BabbageEra
forall era. TxTotalCollateral era
C.TxTotalCollateralNone) ((Lovelace -> TxTotalCollateral BabbageEra)
-> Either ToCardanoError Lovelace
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TxTotalAndReturnCollateralSupportedInEra BabbageEra
-> Lovelace -> TxTotalCollateral BabbageEra
forall era.
TxTotalAndReturnCollateralSupportedInEra era
-> Lovelace -> TxTotalCollateral era
C.TxTotalCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra) (Either ToCardanoError Lovelace
 -> Either ToCardanoError (TxTotalCollateral BabbageEra))
-> (Value -> Either ToCardanoError Lovelace)
-> Value
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Either ToCardanoError Lovelace
toCardanoLovelace) Maybe Value
totalCollateral
    Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
Nothing -> TxTotalCollateral BabbageEra
-> Either ToCardanoError (TxTotalCollateral BabbageEra)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxTotalCollateral BabbageEra
forall era. TxTotalCollateral era
C.TxTotalCollateralNone

fromCardanoReturnCollateral :: C.TxReturnCollateral C.CtxTx C.BabbageEra -> Maybe P.TxOut
fromCardanoReturnCollateral :: TxReturnCollateral CtxTx BabbageEra -> Maybe TxOut
fromCardanoReturnCollateral TxReturnCollateral CtxTx BabbageEra
C.TxReturnCollateralNone       = Maybe TxOut
forall a. Maybe a
Nothing
fromCardanoReturnCollateral (C.TxReturnCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
_ TxOut CtxTx BabbageEra
txOut) = TxOut -> Maybe TxOut
forall a. a -> Maybe a
Just (TxOut -> Maybe TxOut) -> TxOut -> Maybe TxOut
forall a b. (a -> b) -> a -> b
$ TxOut CtxTx BabbageEra -> TxOut
P.TxOut TxOut CtxTx BabbageEra
txOut

toCardanoReturnCollateral :: Maybe P.TxOut -> C.TxReturnCollateral C.CtxTx C.BabbageEra
toCardanoReturnCollateral :: Maybe TxOut -> TxReturnCollateral CtxTx BabbageEra
toCardanoReturnCollateral Maybe TxOut
returnCollateral =
  case CardanoEra BabbageEra
-> Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
forall era.
CardanoEra era
-> Maybe (TxTotalAndReturnCollateralSupportedInEra era)
C.totalAndReturnCollateralSupportedInEra CardanoEra BabbageEra
C.BabbageEra of
    Just TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra ->
      TxReturnCollateral CtxTx BabbageEra
-> (TxOut -> TxReturnCollateral CtxTx BabbageEra)
-> Maybe TxOut
-> TxReturnCollateral CtxTx BabbageEra
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TxReturnCollateral CtxTx BabbageEra
forall ctx era. TxReturnCollateral ctx era
C.TxReturnCollateralNone (TxTotalAndReturnCollateralSupportedInEra BabbageEra
-> TxOut CtxTx BabbageEra -> TxReturnCollateral CtxTx BabbageEra
forall era ctx.
TxTotalAndReturnCollateralSupportedInEra era
-> TxOut ctx era -> TxReturnCollateral ctx era
C.TxReturnCollateral TxTotalAndReturnCollateralSupportedInEra BabbageEra
txTotalAndReturnCollateralInBabbageEra (TxOut CtxTx BabbageEra -> TxReturnCollateral CtxTx BabbageEra)
-> (TxOut -> TxOut CtxTx BabbageEra)
-> TxOut
-> TxReturnCollateral CtxTx BabbageEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut -> TxOut CtxTx BabbageEra
P.getTxOut) Maybe TxOut
returnCollateral
    Maybe (TxTotalAndReturnCollateralSupportedInEra BabbageEra)
Nothing -> TxReturnCollateral CtxTx BabbageEra
forall ctx era. TxReturnCollateral ctx era
C.TxReturnCollateralNone

getRequiredSigners :: C.Tx C.BabbageEra -> [P.PaymentPubKeyHash]
getRequiredSigners :: Tx BabbageEra -> [PaymentPubKeyHash]
getRequiredSigners (C.ShelleyTx ShelleyBasedEra BabbageEra
_ (ValidatedTx TxBody { reqSignerHashes = rsq } _ _ _)) =
  (KeyHash 'Witness StandardCrypto -> [PaymentPubKeyHash])
-> Set (KeyHash 'Witness StandardCrypto) -> [PaymentPubKeyHash]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (PaymentPubKeyHash -> [PaymentPubKeyHash]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PaymentPubKeyHash -> [PaymentPubKeyHash])
-> (KeyHash 'Witness StandardCrypto -> PaymentPubKeyHash)
-> KeyHash 'Witness StandardCrypto
-> [PaymentPubKeyHash]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PubKeyHash -> PaymentPubKeyHash
P.PaymentPubKeyHash (PubKeyHash -> PaymentPubKeyHash)
-> (KeyHash 'Witness StandardCrypto -> PubKeyHash)
-> KeyHash 'Witness StandardCrypto
-> PaymentPubKeyHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash PaymentKey -> PubKeyHash
P.toPlutusPubKeyHash (Hash PaymentKey -> PubKeyHash)
-> (KeyHash 'Witness StandardCrypto -> Hash PaymentKey)
-> KeyHash 'Witness StandardCrypto
-> PubKeyHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyHash 'Payment StandardCrypto -> Hash PaymentKey
C.PaymentKeyHash (KeyHash 'Payment StandardCrypto -> Hash PaymentKey)
-> (KeyHash 'Witness StandardCrypto
    -> KeyHash 'Payment StandardCrypto)
-> KeyHash 'Witness StandardCrypto
-> Hash PaymentKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyHash 'Witness StandardCrypto -> KeyHash 'Payment StandardCrypto
forall (a :: KeyRole -> * -> *) (r :: KeyRole) crypto
       (r' :: KeyRole).
HasKeyRole a =>
a r crypto -> a r' crypto
C.Ledger.coerceKeyRole) Set (KeyHash 'Witness StandardCrypto)
Set (KeyHash 'Witness (Crypto (BabbageEra StandardCrypto)))
rsq

fromPlutusIndex :: P.UtxoIndex -> Either (Either P.ValidationErrorInPhase ToCardanoError) (C.Ledger.UTxO (Babbage.BabbageEra StandardCrypto))
fromPlutusIndex :: UtxoIndex
-> Either
     (Either ValidationErrorInPhase ToCardanoError)
     (UTxO (BabbageEra StandardCrypto))
fromPlutusIndex (P.UtxoIndex Map TxOutRef TxOut
m) =
  (ToCardanoError -> Either ValidationErrorInPhase ToCardanoError)
-> Either ToCardanoError (UTxO (BabbageEra StandardCrypto))
-> Either
     (Either ValidationErrorInPhase ToCardanoError)
     (UTxO (BabbageEra StandardCrypto))
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first ToCardanoError -> Either ValidationErrorInPhase ToCardanoError
forall a b. b -> Either a b
Right (Either ToCardanoError (UTxO (BabbageEra StandardCrypto))
 -> Either
      (Either ValidationErrorInPhase ToCardanoError)
      (UTxO (BabbageEra StandardCrypto)))
-> Either ToCardanoError (UTxO (BabbageEra StandardCrypto))
-> Either
     (Either ValidationErrorInPhase ToCardanoError)
     (UTxO (BabbageEra StandardCrypto))
forall a b. (a -> b) -> a -> b
$ Map (TxIn StandardCrypto) (TxOut (BabbageEra StandardCrypto))
-> UTxO (BabbageEra StandardCrypto)
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
C.Ledger.UTxO (Map (TxIn StandardCrypto) (TxOut (BabbageEra StandardCrypto))
 -> UTxO (BabbageEra StandardCrypto))
-> ([(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
    -> Map (TxIn StandardCrypto) (TxOut (BabbageEra StandardCrypto)))
-> [(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
-> UTxO (BabbageEra StandardCrypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
-> Map (TxIn StandardCrypto) (TxOut (BabbageEra StandardCrypto))
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
 -> UTxO (BabbageEra StandardCrypto))
-> Either
     ToCardanoError
     [(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
-> Either ToCardanoError (UTxO (BabbageEra StandardCrypto))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((TxOutRef, TxOut)
 -> Either
      ToCardanoError
      (TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto)))
-> [(TxOutRef, TxOut)]
-> Either
     ToCardanoError
     [(TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((TxOutRef -> Either ToCardanoError (TxIn StandardCrypto))
-> (TxOut
    -> Either ToCardanoError (TxOut (BabbageEra StandardCrypto)))
-> (TxOutRef, TxOut)
-> Either
     ToCardanoError
     (TxIn StandardCrypto, TxOut (BabbageEra StandardCrypto))
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse TxOutRef -> Either ToCardanoError (TxIn StandardCrypto)
fromPlutusTxOutRef (TxOut (BabbageEra StandardCrypto)
-> Either ToCardanoError (TxOut (BabbageEra StandardCrypto))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOut (BabbageEra StandardCrypto)
 -> Either ToCardanoError (TxOut (BabbageEra StandardCrypto)))
-> (TxOut -> TxOut (BabbageEra StandardCrypto))
-> TxOut
-> Either ToCardanoError (TxOut (BabbageEra StandardCrypto))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut -> TxOut (BabbageEra StandardCrypto)
fromPlutusTxOut)) (Map TxOutRef TxOut -> [(TxOutRef, TxOut)]
forall k a. Map k a -> [(k, a)]
Map.toList Map TxOutRef TxOut
m)

fromPlutusTxOutRef :: P.TxOutRef -> Either ToCardanoError (C.Ledger.TxIn StandardCrypto)
fromPlutusTxOutRef :: TxOutRef -> Either ToCardanoError (TxIn StandardCrypto)
fromPlutusTxOutRef (P.TxOutRef TxId
txId Integer
i) = TxId StandardCrypto -> TxIx -> TxIn StandardCrypto
forall crypto. TxId crypto -> TxIx -> TxIn crypto
C.Ledger.TxIn (TxId StandardCrypto -> TxIx -> TxIn StandardCrypto)
-> Either ToCardanoError (TxId StandardCrypto)
-> Either ToCardanoError (TxIx -> TxIn StandardCrypto)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxId -> Either ToCardanoError (TxId StandardCrypto)
fromPlutusTxId TxId
txId Either ToCardanoError (TxIx -> TxIn StandardCrypto)
-> Either ToCardanoError TxIx
-> Either ToCardanoError (TxIn StandardCrypto)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxIx -> Either ToCardanoError TxIx
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HasCallStack => Integer -> TxIx
Integer -> TxIx
mkTxIxPartial Integer
i)

fromPlutusTxId :: PV1.TxId -> Either ToCardanoError (C.Ledger.TxId StandardCrypto)
fromPlutusTxId :: TxId -> Either ToCardanoError (TxId StandardCrypto)
fromPlutusTxId = (TxId -> TxId StandardCrypto)
-> Either ToCardanoError TxId
-> Either ToCardanoError (TxId StandardCrypto)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TxId -> TxId StandardCrypto
C.toShelleyTxId (Either ToCardanoError TxId
 -> Either ToCardanoError (TxId StandardCrypto))
-> (TxId -> Either ToCardanoError TxId)
-> TxId
-> Either ToCardanoError (TxId StandardCrypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxId -> Either ToCardanoError TxId
toCardanoTxId

fromPlutusTxOut :: P.TxOut -> Babbage.TxOut (Babbage.BabbageEra StandardCrypto)
fromPlutusTxOut :: TxOut -> TxOut (BabbageEra StandardCrypto)
fromPlutusTxOut = ShelleyBasedEra BabbageEra
-> TxOut CtxUTxO BabbageEra -> TxOut (BabbageEra StandardCrypto)
forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut CtxUTxO era -> TxOut ledgerera
C.toShelleyTxOut ShelleyBasedEra BabbageEra
C.ShelleyBasedEraBabbage (TxOut CtxUTxO BabbageEra -> TxOut (BabbageEra StandardCrypto))
-> (TxOut -> TxOut CtxUTxO BabbageEra)
-> TxOut
-> TxOut (BabbageEra StandardCrypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut CtxTx BabbageEra -> TxOut CtxUTxO BabbageEra
forall era. TxOut CtxTx era -> TxOut CtxUTxO era
C.toCtxUTxOTxOut (TxOut CtxTx BabbageEra -> TxOut CtxUTxO BabbageEra)
-> (TxOut -> TxOut CtxTx BabbageEra)
-> TxOut
-> TxOut CtxUTxO BabbageEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut -> TxOut CtxTx BabbageEra
P.getTxOut