{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Mary.TxBody (
  MaryEraTxBody (..),
  MaryTxBody (
    MkMaryTxBody,
    MaryTxBody,
    mtbAuxDataHash,
    mtbCerts,
    mtbInputs,
    mtbOutputs,
    mtbTxFee,
    mtbUpdate,
    mtbValidityInterval,
    mtbWithdrawals,
    mtbMint
  ),
  MaryTxBodyRaw,
)
where

import Cardano.Ledger.Allegra.Core
import Cardano.Ledger.Allegra.TxBody
import Cardano.Ledger.Binary (DecCBOR (..), EncCBOR (..), ToCBOR (..))
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Mary.Era (MaryEra)
import Cardano.Ledger.Mary.TxCert ()
import Cardano.Ledger.Mary.TxOut ()
import Cardano.Ledger.Mary.Value
import Cardano.Ledger.MemoBytes (
  EqRaw,
  MemoBytes,
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.PParams (Update, upgradeUpdate)
import Cardano.Ledger.Shelley.TxBody (getShelleyGenesisKeyHashCountTxBody)
import Cardano.Ledger.TxIn (TxIn (..))
import Control.DeepSeq (NFData (..))
import Data.Sequence.Strict (StrictSeq)
import Data.Set (Set)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks (..))

class AllegraEraTxBody era => MaryEraTxBody era where
  mintTxBodyL :: Lens' (TxBody era) MultiAsset

  mintedTxBodyF :: SimpleGetter (TxBody era) (Set PolicyID)

  mintValueTxBodyF :: SimpleGetter (TxBody era) (Value era)
  default mintValueTxBodyF :: Value era ~ MaryValue => SimpleGetter (TxBody era) (Value era)
  mintValueTxBodyF = forall era. MaryEraTxBody era => Lens' (TxBody era) MultiAsset
mintTxBodyL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. (s -> a) -> SimpleGetter s a
to (Coin -> MultiAsset -> MaryValue
MaryValue forall a. Monoid a => a
mempty)
  {-# INLINE mintValueTxBodyF #-}

-- ===========================================================================
-- Wrap it all up in a newtype, hiding the insides with a pattern constructor.

type MaryTxBodyRaw era = AllegraTxBodyRaw MultiAsset era

newtype MaryTxBody era = MkMaryTxBody (MemoBytes (MaryTxBodyRaw era))
  deriving newtype (MaryTxBody era -> Int
MaryTxBody era -> ByteString
forall i. Proxy i -> MaryTxBody era -> SafeHash i
forall era. MaryTxBody era -> Int
forall era. MaryTxBody era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall era i. Proxy i -> MaryTxBody era -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> MaryTxBody era -> SafeHash i
$cmakeHashWithExplicitProxys :: forall era i. Proxy i -> MaryTxBody era -> SafeHash i
originalBytesSize :: MaryTxBody era -> Int
$coriginalBytesSize :: forall era. MaryTxBody era -> Int
originalBytes :: MaryTxBody era -> ByteString
$coriginalBytes :: forall era. MaryTxBody era -> ByteString
SafeToHash, MaryTxBody era -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [MaryTxBody era] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (MaryTxBody era) -> Size
forall {era}. Typeable era => Typeable (MaryTxBody era)
forall era. Typeable era => MaryTxBody era -> Encoding
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [MaryTxBody era] -> Size
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (MaryTxBody era) -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [MaryTxBody era] -> Size
$cencodedListSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [MaryTxBody era] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (MaryTxBody era) -> Size
$cencodedSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (MaryTxBody era) -> Size
toCBOR :: MaryTxBody era -> Encoding
$ctoCBOR :: forall era. Typeable era => MaryTxBody era -> Encoding
ToCBOR)

-- | Encodes memoized bytes created upon construction.
instance Era era => EncCBOR (MaryTxBody era)

instance
  (Era era, Eq (PParamsUpdate era), Eq (TxOut era), Eq (TxCert era)) =>
  EqRaw (MaryTxBody era)

instance Memoized (MaryTxBody era) where
  type RawType (MaryTxBody era) = MaryTxBodyRaw era

deriving newtype instance
  (Era era, Eq (TxOut era), Eq (TxCert era), Eq (PParamsUpdate era)) =>
  Eq (MaryTxBody era)

deriving newtype instance
  (Era era, Show (TxOut era), Show (TxCert era), Show (PParamsUpdate era)) =>
  Show (MaryTxBody era)

deriving instance Generic (MaryTxBody era)

deriving newtype instance
  (Era era, NoThunks (TxOut era), NoThunks (TxCert era), NoThunks (PParamsUpdate era)) =>
  NoThunks (MaryTxBody era)

deriving newtype instance
  (Era era, NFData (TxOut era), NFData (TxCert era), NFData (PParamsUpdate era)) =>
  NFData (MaryTxBody era)

deriving newtype instance MaryEraTxBody era => DecCBOR (MaryTxBody era)

type instance MemoHashIndex (MaryTxBodyRaw era) = EraIndependentTxBody

instance Era era => HashAnnotated (MaryTxBody era) EraIndependentTxBody where
  hashAnnotated :: MaryTxBody era -> SafeHash EraIndependentTxBody
hashAnnotated = forall t. Memoized t => t -> SafeHash (MemoHashIndex (RawType t))
getMemoSafeHash

-- | A pattern to keep the newtype and the MemoBytes hidden
pattern MaryTxBody ::
  forall era.
  (EraTxOut era, EraTxCert era) =>
  Set TxIn ->
  StrictSeq (TxOut era) ->
  StrictSeq (TxCert era) ->
  Withdrawals ->
  Coin ->
  ValidityInterval ->
  StrictMaybe (Update era) ->
  StrictMaybe TxAuxDataHash ->
  MultiAsset ->
  MaryTxBody era
pattern $bMaryTxBody :: forall era.
(EraTxOut era, EraTxCert era) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> MultiAsset
-> MaryTxBody era
$mMaryTxBody :: forall {r} {era}.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era
-> (Set TxIn
    -> StrictSeq (TxOut era)
    -> StrictSeq (TxCert era)
    -> Withdrawals
    -> Coin
    -> ValidityInterval
    -> StrictMaybe (Update era)
    -> StrictMaybe TxAuxDataHash
    -> MultiAsset
    -> r)
-> ((# #) -> r)
-> r
MaryTxBody
  { forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> Set TxIn
mtbInputs
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> StrictSeq (TxOut era)
mtbOutputs
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> StrictSeq (TxCert era)
mtbCerts
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> Withdrawals
mtbWithdrawals
  , forall era. (EraTxOut era, EraTxCert era) => MaryTxBody era -> Coin
mtbTxFee
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> ValidityInterval
mtbValidityInterval
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> StrictMaybe (Update era)
mtbUpdate
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> StrictMaybe TxAuxDataHash
mtbAuxDataHash
  , forall era.
(EraTxOut era, EraTxCert era) =>
MaryTxBody era -> MultiAsset
mtbMint
  } <-
  ( getMemoRawType ->
      AllegraTxBodyRaw
        { atbrInputs = mtbInputs
        , atbrOutputs = mtbOutputs
        , atbrCerts = mtbCerts
        , atbrWithdrawals = mtbWithdrawals
        , atbrFee = mtbTxFee
        , atbrValidityInterval = mtbValidityInterval
        , atbrUpdate = mtbUpdate
        , atbrAuxDataHash = mtbAuxDataHash
        , atbrMint = mtbMint
        }
    )
  where
    MaryTxBody
      Set TxIn
inputs
      StrictSeq (TxOut era)
outputs
      StrictSeq (TxCert era)
certs
      Withdrawals
withdrawals
      Coin
txFee
      ValidityInterval
validityInterval
      StrictMaybe (Update era)
update
      StrictMaybe TxAuxDataHash
auxDataHash
      MultiAsset
mint =
        forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era forall a b. (a -> b) -> a -> b
$
          AllegraTxBodyRaw
            { atbrInputs :: Set TxIn
atbrInputs = Set TxIn
inputs
            , atbrOutputs :: StrictSeq (TxOut era)
atbrOutputs = StrictSeq (TxOut era)
outputs
            , atbrCerts :: StrictSeq (TxCert era)
atbrCerts = StrictSeq (TxCert era)
certs
            , atbrWithdrawals :: Withdrawals
atbrWithdrawals = Withdrawals
withdrawals
            , atbrFee :: Coin
atbrFee = Coin
txFee
            , atbrValidityInterval :: ValidityInterval
atbrValidityInterval = ValidityInterval
validityInterval
            , atbrUpdate :: StrictMaybe (Update era)
atbrUpdate = StrictMaybe (Update era)
update
            , atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrAuxDataHash = StrictMaybe TxAuxDataHash
auxDataHash
            , atbrMint :: MultiAsset
atbrMint = MultiAsset
mint
            }

{-# COMPLETE MaryTxBody #-}

instance EraTxBody MaryEra where
  type TxBody MaryEra = MaryTxBody MaryEra

  mkBasicTxBody :: TxBody MaryEra
mkBasicTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @MaryEra forall ma era. Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw

  inputsTxBodyL :: Lens' (TxBody MaryEra) (Set TxIn)
inputsTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> Set TxIn
atbrInputs forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Set TxIn
inputs -> RawType (TxBody MaryEra)
txBodyRaw {atbrInputs :: Set TxIn
atbrInputs = Set TxIn
inputs}
  {-# INLINEABLE inputsTxBodyL #-}

  outputsTxBodyL :: Lens' (TxBody MaryEra) (StrictSeq (TxOut MaryEra))
outputsTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxOut era)
atbrOutputs forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictSeq (TxOut MaryEra)
outputs -> RawType (TxBody MaryEra)
txBodyRaw {atbrOutputs :: StrictSeq (TxOut MaryEra)
atbrOutputs = StrictSeq (TxOut MaryEra)
outputs}
  {-# INLINEABLE outputsTxBodyL #-}

  feeTxBodyL :: Lens' (TxBody MaryEra) Coin
feeTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> Coin
atbrFee forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Coin
fee -> RawType (TxBody MaryEra)
txBodyRaw {atbrFee :: Coin
atbrFee = Coin
fee}
  {-# INLINEABLE feeTxBodyL #-}

  auxDataHashTxBodyL :: Lens' (TxBody MaryEra) (StrictMaybe TxAuxDataHash)
auxDataHashTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> StrictMaybe TxAuxDataHash
atbrAuxDataHash forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody MaryEra)
txBodyRaw StrictMaybe TxAuxDataHash
auxDataHash -> RawType (TxBody MaryEra)
txBodyRaw {atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrAuxDataHash = StrictMaybe TxAuxDataHash
auxDataHash}
  {-# INLINEABLE auxDataHashTxBodyL #-}

  spendableInputsTxBodyF :: SimpleGetter (TxBody MaryEra) (Set TxIn)
spendableInputsTxBodyF = forall era. EraTxBody era => Lens' (TxBody era) (Set TxIn)
inputsTxBodyL
  {-# INLINE spendableInputsTxBodyF #-}

  allInputsTxBodyF :: SimpleGetter (TxBody MaryEra) (Set TxIn)
allInputsTxBodyF = forall era. EraTxBody era => Lens' (TxBody era) (Set TxIn)
inputsTxBodyL
  {-# INLINEABLE allInputsTxBodyF #-}

  withdrawalsTxBodyL :: Lens' (TxBody MaryEra) Withdrawals
withdrawalsTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> Withdrawals
atbrWithdrawals forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Withdrawals
withdrawals -> RawType (TxBody MaryEra)
txBodyRaw {atbrWithdrawals :: Withdrawals
atbrWithdrawals = Withdrawals
withdrawals}
  {-# INLINEABLE withdrawalsTxBodyL #-}

  certsTxBodyL :: Lens' (TxBody MaryEra) (StrictSeq (TxCert MaryEra))
certsTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxCert era)
atbrCerts forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictSeq (TxCert MaryEra)
certs -> RawType (TxBody MaryEra)
txBodyRaw {atbrCerts :: StrictSeq (TxCert MaryEra)
atbrCerts = StrictSeq (TxCert MaryEra)
certs}
  {-# INLINEABLE certsTxBodyL #-}

  getGenesisKeyHashCountTxBody :: TxBody MaryEra -> Int
getGenesisKeyHashCountTxBody = forall era. ShelleyEraTxBody era => TxBody era -> Int
getShelleyGenesisKeyHashCountTxBody

  upgradeTxBody :: EraTxBody (PreviousEra MaryEra) =>
TxBody (PreviousEra MaryEra)
-> Either (TxBodyUpgradeError MaryEra) (TxBody MaryEra)
upgradeTxBody TxBody (PreviousEra MaryEra)
atb = do
    StrictSeq (TxCert MaryEra)
certs <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse forall era.
(EraTxCert era, EraTxCert (PreviousEra era)) =>
TxCert (PreviousEra era)
-> Either (TxCertUpgradeError era) (TxCert era)
upgradeTxCert (forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> StrictSeq (TxCert era)
atbCerts TxBody (PreviousEra MaryEra)
atb)
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
      MaryTxBody
        { mtbInputs :: Set TxIn
mtbInputs = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Set TxIn
atbInputs TxBody (PreviousEra MaryEra)
atb
        , mtbOutputs :: StrictSeq (TxOut MaryEra)
mtbOutputs = forall era.
(EraTxOut era, EraTxOut (PreviousEra era)) =>
TxOut (PreviousEra era) -> TxOut era
upgradeTxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> StrictSeq (TxOut era)
atbOutputs TxBody (PreviousEra MaryEra)
atb
        , mtbCerts :: StrictSeq (TxCert MaryEra)
mtbCerts = StrictSeq (TxCert MaryEra)
certs
        , mtbWithdrawals :: Withdrawals
mtbWithdrawals = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Withdrawals
atbWithdrawals TxBody (PreviousEra MaryEra)
atb
        , mtbTxFee :: Coin
mtbTxFee = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Coin
atbTxFee TxBody (PreviousEra MaryEra)
atb
        , mtbValidityInterval :: ValidityInterval
mtbValidityInterval = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> ValidityInterval
atbValidityInterval TxBody (PreviousEra MaryEra)
atb
        , mtbUpdate :: StrictMaybe (Update MaryEra)
mtbUpdate = forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
UpgradePParams StrictMaybe era
-> Update (PreviousEra era) -> Update era
upgradeUpdate () forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> StrictMaybe (Update era)
atbUpdate TxBody (PreviousEra MaryEra)
atb
        , mtbAuxDataHash :: StrictMaybe TxAuxDataHash
mtbAuxDataHash = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> StrictMaybe TxAuxDataHash
atbAuxDataHash TxBody (PreviousEra MaryEra)
atb
        , mtbMint :: MultiAsset
mtbMint = forall a. Monoid a => a
mempty
        }

instance ShelleyEraTxBody MaryEra where
  ttlTxBodyL :: ExactEra ShelleyEra MaryEra => Lens' (TxBody MaryEra) SlotNo
ttlTxBodyL = forall a b. HasCallStack => Lens' a b
notSupportedInThisEraL
  {-# INLINEABLE ttlTxBodyL #-}

  updateTxBodyL :: Lens' (TxBody MaryEra) (StrictMaybe (Update MaryEra))
updateTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> StrictMaybe (Update era)
atbrUpdate forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictMaybe (Update MaryEra)
update -> RawType (TxBody MaryEra)
txBodyRaw {atbrUpdate :: StrictMaybe (Update MaryEra)
atbrUpdate = StrictMaybe (Update MaryEra)
update}
  {-# INLINEABLE updateTxBodyL #-}

instance AllegraEraTxBody MaryEra where
  vldtTxBodyL :: Lens' (TxBody MaryEra) ValidityInterval
vldtTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> ValidityInterval
atbrValidityInterval forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody MaryEra)
txBodyRaw ValidityInterval
vldt -> RawType (TxBody MaryEra)
txBodyRaw {atbrValidityInterval :: ValidityInterval
atbrValidityInterval = ValidityInterval
vldt}
  {-# INLINEABLE vldtTxBodyL #-}

instance MaryEraTxBody MaryEra where
  mintTxBodyL :: Lens' (TxBody MaryEra) MultiAsset
mintTxBodyL =
    forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @MaryEra forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint (\RawType (MaryTxBody MaryEra)
txBodyRaw MultiAsset
mint -> RawType (MaryTxBody MaryEra)
txBodyRaw {atbrMint :: MultiAsset
atbrMint = MultiAsset
mint})
  {-# INLINEABLE mintTxBodyL #-}

  mintedTxBodyF :: SimpleGetter (TxBody MaryEra) (Set PolicyID)
mintedTxBodyF = forall s a. (s -> a) -> SimpleGetter s a
to forall a b. (a -> b) -> a -> b
$ \TxBody MaryEra
txBody -> MultiAsset -> Set PolicyID
policies (forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint (forall t. Memoized t => t -> RawType t
getMemoRawType TxBody MaryEra
txBody))
  {-# INLINEABLE mintedTxBodyF #-}