{-# 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 #-}
{-# OPTIONS_GHC -Wno-redundant-constraints #-}

module Cardano.Ledger.Mary.TxBody (
  MaryEraTxBody (..),
  TxBody (
    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 = (MultiAsset -> Const r MultiAsset)
-> TxBody era -> Const r (TxBody era)
forall era. MaryEraTxBody era => Lens' (TxBody era) MultiAsset
Lens' (TxBody era) MultiAsset
mintTxBodyL ((MultiAsset -> Const r MultiAsset)
 -> TxBody era -> Const r (TxBody era))
-> ((MaryValue -> Const r MaryValue)
    -> MultiAsset -> Const r MultiAsset)
-> (MaryValue -> Const r MaryValue)
-> TxBody era
-> Const r (TxBody era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MultiAsset -> MaryValue) -> SimpleGetter MultiAsset MaryValue
forall s a. (s -> a) -> SimpleGetter s a
to (Coin -> MultiAsset -> MaryValue
MaryValue Coin
forall a. Monoid a => a
mempty)
  {-# INLINE mintValueTxBodyF #-}

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

type MaryTxBodyRaw = AllegraTxBodyRaw MultiAsset MaryEra

-- | Encodes memoized bytes created upon construction.
instance EncCBOR (TxBody MaryEra)

instance EqRaw (TxBody MaryEra)

instance Memoized (TxBody MaryEra) where
  type RawType (TxBody MaryEra) = MaryTxBodyRaw

deriving newtype instance Eq (TxBody MaryEra)

deriving newtype instance Show (TxBody MaryEra)

deriving instance Generic (TxBody MaryEra)

deriving newtype instance NoThunks (TxBody MaryEra)

deriving newtype instance NFData (TxBody MaryEra)

deriving newtype instance DecCBOR (TxBody MaryEra)

type instance MemoHashIndex MaryTxBodyRaw = EraIndependentTxBody

instance HashAnnotated (TxBody MaryEra) EraIndependentTxBody where
  hashAnnotated :: TxBody MaryEra -> SafeHash EraIndependentTxBody
hashAnnotated = TxBody MaryEra -> SafeHash EraIndependentTxBody
TxBody MaryEra
-> SafeHash (MemoHashIndex (RawType (TxBody MaryEra)))
forall t. Memoized t => t -> SafeHash (MemoHashIndex (RawType t))
getMemoSafeHash

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

{-# COMPLETE MaryTxBody #-}

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

  mkBasicTxBody :: TxBody MaryEra
mkBasicTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @MaryEra MaryTxBodyRaw
RawType (TxBody 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 MaryTxBodyRaw -> Set TxIn
RawType (TxBody MaryEra) -> Set TxIn
forall ma era. AllegraTxBodyRaw ma era -> Set TxIn
atbrInputs ((RawType (TxBody MaryEra) -> Set TxIn -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) (Set TxIn))
-> (RawType (TxBody MaryEra)
    -> Set TxIn -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Set TxIn
inputs -> RawType (TxBody MaryEra)
txBodyRaw {atbrInputs = 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 MaryTxBodyRaw -> StrictSeq (TxOut MaryEra)
RawType (TxBody MaryEra) -> StrictSeq (TxOut MaryEra)
forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxOut era)
atbrOutputs ((RawType (TxBody MaryEra)
  -> StrictSeq (TxOut MaryEra) -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) (StrictSeq (TxOut MaryEra)))
-> (RawType (TxBody MaryEra)
    -> StrictSeq (TxOut MaryEra) -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) (StrictSeq (TxOut MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictSeq (TxOut MaryEra)
outputs -> RawType (TxBody MaryEra)
txBodyRaw {atbrOutputs = 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 MaryTxBodyRaw -> Coin
RawType (TxBody MaryEra) -> Coin
forall ma era. AllegraTxBodyRaw ma era -> Coin
atbrFee ((RawType (TxBody MaryEra) -> Coin -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) Coin)
-> (RawType (TxBody MaryEra) -> Coin -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) Coin
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Coin
fee -> RawType (TxBody MaryEra)
txBodyRaw {atbrFee = 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 MaryTxBodyRaw -> StrictMaybe TxAuxDataHash
RawType (TxBody MaryEra) -> StrictMaybe TxAuxDataHash
forall ma era. AllegraTxBodyRaw ma era -> StrictMaybe TxAuxDataHash
atbrAuxDataHash ((RawType (TxBody MaryEra)
  -> StrictMaybe TxAuxDataHash -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) (StrictMaybe TxAuxDataHash))
-> (RawType (TxBody MaryEra)
    -> StrictMaybe TxAuxDataHash -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) (StrictMaybe TxAuxDataHash)
forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody MaryEra)
txBodyRaw StrictMaybe TxAuxDataHash
auxDataHash -> RawType (TxBody MaryEra)
txBodyRaw {atbrAuxDataHash = auxDataHash}
  {-# INLINEABLE auxDataHashTxBodyL #-}

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

  allInputsTxBodyF :: SimpleGetter (TxBody MaryEra) (Set TxIn)
allInputsTxBodyF = (Set TxIn -> Const r (Set TxIn))
-> TxBody MaryEra -> Const r (TxBody MaryEra)
forall era. EraTxBody era => Lens' (TxBody era) (Set TxIn)
Lens' (TxBody MaryEra) (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 MaryTxBodyRaw -> Withdrawals
RawType (TxBody MaryEra) -> Withdrawals
forall ma era. AllegraTxBodyRaw ma era -> Withdrawals
atbrWithdrawals ((RawType (TxBody MaryEra)
  -> Withdrawals -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) Withdrawals)
-> (RawType (TxBody MaryEra)
    -> Withdrawals -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) Withdrawals
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw Withdrawals
withdrawals -> RawType (TxBody MaryEra)
txBodyRaw {atbrWithdrawals = 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 MaryTxBodyRaw -> StrictSeq (TxCert MaryEra)
RawType (TxBody MaryEra) -> StrictSeq (TxCert MaryEra)
forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxCert era)
atbrCerts ((RawType (TxBody MaryEra)
  -> StrictSeq (TxCert MaryEra) -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) (StrictSeq (TxCert MaryEra)))
-> (RawType (TxBody MaryEra)
    -> StrictSeq (TxCert MaryEra) -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) (StrictSeq (TxCert MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictSeq (TxCert MaryEra)
certs -> RawType (TxBody MaryEra)
txBodyRaw {atbrCerts = certs}
  {-# INLINEABLE certsTxBodyL #-}

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

instance ShelleyEraTxBody MaryEra where
  ttlTxBodyL :: ExactEra ShelleyEra MaryEra => Lens' (TxBody MaryEra) SlotNo
ttlTxBodyL = (SlotNo -> f SlotNo) -> TxBody MaryEra -> f (TxBody MaryEra)
forall a b. HasCallStack => Lens' a b
Lens' (TxBody MaryEra) SlotNo
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 MaryTxBodyRaw -> StrictMaybe (Update MaryEra)
RawType (TxBody MaryEra) -> StrictMaybe (Update MaryEra)
forall ma era. AllegraTxBodyRaw ma era -> StrictMaybe (Update era)
atbrUpdate ((RawType (TxBody MaryEra)
  -> StrictMaybe (Update MaryEra) -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) (StrictMaybe (Update MaryEra)))
-> (RawType (TxBody MaryEra)
    -> StrictMaybe (Update MaryEra) -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) (StrictMaybe (Update MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody MaryEra)
txBodyRaw StrictMaybe (Update MaryEra)
update -> RawType (TxBody MaryEra)
txBodyRaw {atbrUpdate = 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 MaryTxBodyRaw -> ValidityInterval
RawType (TxBody MaryEra) -> ValidityInterval
forall ma era. AllegraTxBodyRaw ma era -> ValidityInterval
atbrValidityInterval ((RawType (TxBody MaryEra)
  -> ValidityInterval -> RawType (TxBody MaryEra))
 -> Lens' (TxBody MaryEra) ValidityInterval)
-> (RawType (TxBody MaryEra)
    -> ValidityInterval -> RawType (TxBody MaryEra))
-> Lens' (TxBody MaryEra) ValidityInterval
forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody MaryEra)
txBodyRaw ValidityInterval
vldt -> RawType (TxBody MaryEra)
txBodyRaw {atbrValidityInterval = 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 MaryTxBodyRaw -> MultiAsset
RawType (TxBody MaryEra) -> MultiAsset
forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint (\RawType (TxBody MaryEra)
txBodyRaw MultiAsset
mint -> RawType (TxBody MaryEra)
txBodyRaw {atbrMint = mint})
  {-# INLINEABLE mintTxBodyL #-}

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