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

-- | Provides Mary TxBody internals
--
-- = Warning
--
-- This module is considered __internal__.
--
-- The contents of this module may change __in any way whatsoever__
-- and __without any warning__ between minor versions of this package.
module Cardano.Ledger.Mary.TxBody.Internal (
  MaryEraTxBody (..),
  MaryTxBody (
    ..,
    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.AuxiliaryData (AuxiliaryDataHash)
import Cardano.Ledger.Binary (Annotator, DecCBOR (..), EncCBOR (..), ToCBOR (..))
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Crypto (Crypto, StandardCrypto)
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,
  Mem,
  MemoBytes (Memo),
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoized,
 )
import Cardano.Ledger.SafeHash (HashAnnotated (..), SafeToHash)
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 (EraCrypto era))

  mintValueTxBodyF :: SimpleGetter (TxBody era) (Value era)

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

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

newtype MaryTxBodyRaw era = MaryTxBodyRaw (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)

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

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

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

deriving instance Generic (MaryTxBodyRaw era)

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

deriving newtype instance AllegraEraTxBody era => DecCBOR (MaryTxBodyRaw era)

newtype MaryTxBody era = TxBodyConstr (MemoBytes MaryTxBodyRaw era)
  deriving newtype (MaryTxBody era -> Int
MaryTxBody era -> ByteString
forall era. MaryTxBody era -> Int
forall era. MaryTxBody era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall c index.
    HashAlgorithm (HASH c) =>
    Proxy c -> Proxy index -> t -> SafeHash c index)
-> SafeToHash t
forall c index.
HashAlgorithm (HASH c) =>
Proxy c -> Proxy index -> MaryTxBody era -> SafeHash c index
forall era c index.
HashAlgorithm (HASH c) =>
Proxy c -> Proxy index -> MaryTxBody era -> SafeHash c index
makeHashWithExplicitProxys :: forall c index.
HashAlgorithm (HASH c) =>
Proxy c -> Proxy index -> MaryTxBody era -> SafeHash c index
$cmakeHashWithExplicitProxys :: forall era c index.
HashAlgorithm (HASH c) =>
Proxy c -> Proxy index -> MaryTxBody era -> SafeHash c index
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 AllegraEraTxBody era => DecCBOR (Annotator (MaryTxBodyRaw era)) where
  decCBOR :: forall s. Decoder s (Annotator (MaryTxBodyRaw era))
decCBOR = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. DecCBOR a => Decoder s a
decCBOR

deriving newtype instance (EraTxOut era, EraTxCert era) => EncCBOR (MaryTxBodyRaw era)

instance Memoized MaryTxBody where
  type RawType MaryTxBody = MaryTxBodyRaw

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 via
  Mem MaryTxBodyRaw era
  instance
    MaryEraTxBody era => DecCBOR (Annotator (MaryTxBody era))

type instance MemoHashIndex MaryTxBodyRaw = EraIndependentTxBody

instance (c ~ EraCrypto era, Era era) => HashAnnotated (MaryTxBody era) EraIndependentTxBody c where
  hashAnnotated :: HashAlgorithm (HASH c) =>
MaryTxBody era -> SafeHash c EraIndependentTxBody
hashAnnotated = forall (t :: * -> *) era.
Memoized t =>
t era -> SafeHash (EraCrypto era) (MemoHashIndex (RawType t))
getMemoSafeHash

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

{-# COMPLETE MaryTxBody #-}

-- | This is a helper Lens creator for any Memoized type.
lensMaryTxBodyRaw ::
  (EraTxOut era, EraTxCert era) =>
  (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a) ->
  ( AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era ->
    b ->
    AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
  ) ->
  Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw :: forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a
getter AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
-> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
setter =
  forall era (t :: * -> *) a b.
(Era era, EncCBOR (RawType t era), Memoized t) =>
(RawType t era -> a)
-> (RawType t era -> b -> RawType t era)
-> Lens (t era) (t era) a b
lensMemoRawType
    (\(MaryTxBodyRaw AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
atbr) -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a
getter AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
atbr)
    (\(MaryTxBodyRaw AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
atbr) b
a -> forall era.
AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
-> MaryTxBodyRaw era
MaryTxBodyRaw (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
-> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
setter AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
atbr b
a))
{-# INLINEABLE lensMaryTxBodyRaw #-}

instance Crypto c => EraTxBody (MaryEra c) where
  {-# SPECIALIZE instance EraTxBody (MaryEra StandardCrypto) #-}

  type TxBody (MaryEra c) = MaryTxBody (MaryEra c)

  mkBasicTxBody :: TxBody (MaryEra c)
mkBasicTxBody = forall era (t :: * -> *).
(Era era, EncCBOR (RawType t era), Memoized t) =>
RawType t era -> t era
mkMemoized forall a b. (a -> b) -> a -> b
$ forall era.
AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
-> MaryTxBodyRaw era
MaryTxBodyRaw forall ma era. Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw

  inputsTxBodyL :: Lens' (TxBody (MaryEra c)) (Set (TxIn (EraCrypto (MaryEra c))))
inputsTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era.
AllegraTxBodyRaw ma era -> Set (TxIn (EraCrypto era))
atbrInputs forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw Set (TxIn (EraCrypto (MaryEra c)))
inputs -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrInputs :: Set (TxIn (EraCrypto (MaryEra c)))
atbrInputs = Set (TxIn (EraCrypto (MaryEra c)))
inputs}
  {-# INLINEABLE inputsTxBodyL #-}

  outputsTxBodyL :: Lens' (TxBody (MaryEra c)) (StrictSeq (TxOut (MaryEra c)))
outputsTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxOut era)
atbrOutputs forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw StrictSeq (TxOut (MaryEra c))
outputs -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrOutputs :: StrictSeq (TxOut (MaryEra c))
atbrOutputs = StrictSeq (TxOut (MaryEra c))
outputs}
  {-# INLINEABLE outputsTxBodyL #-}

  feeTxBodyL :: Lens' (TxBody (MaryEra c)) Coin
feeTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> Coin
atbrTxFee forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw Coin
fee -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrTxFee :: Coin
atbrTxFee = Coin
fee}
  {-# INLINEABLE feeTxBodyL #-}

  auxDataHashTxBodyL :: Lens'
  (TxBody (MaryEra c))
  (StrictMaybe (AuxiliaryDataHash (EraCrypto (MaryEra c))))
auxDataHashTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era.
AllegraTxBodyRaw ma era
-> StrictMaybe (AuxiliaryDataHash (EraCrypto era))
atbrAuxDataHash forall a b. (a -> b) -> a -> b
$
      \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw StrictMaybe (AuxiliaryDataHash (EraCrypto (MaryEra c)))
auxDataHash -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrAuxDataHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto (MaryEra c)))
atbrAuxDataHash = StrictMaybe (AuxiliaryDataHash (EraCrypto (MaryEra c)))
auxDataHash}
  {-# INLINEABLE auxDataHashTxBodyL #-}

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

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

  withdrawalsTxBodyL :: Lens' (TxBody (MaryEra c)) (Withdrawals (EraCrypto (MaryEra c)))
withdrawalsTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era.
AllegraTxBodyRaw ma era -> Withdrawals (EraCrypto era)
atbrWithdrawals forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw Withdrawals (EraCrypto (MaryEra c))
withdrawals -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrWithdrawals :: Withdrawals (EraCrypto (MaryEra c))
atbrWithdrawals = Withdrawals (EraCrypto (MaryEra c))
withdrawals}
  {-# INLINEABLE withdrawalsTxBodyL #-}

  certsTxBodyL :: Lens' (TxBody (MaryEra c)) (StrictSeq (TxCert (MaryEra c)))
certsTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> StrictSeq (TxCert era)
atbrCerts forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw StrictSeq (TxCert (MaryEra c))
certs -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrCerts :: StrictSeq (TxCert (MaryEra c))
atbrCerts = StrictSeq (TxCert (MaryEra c))
certs}
  {-# INLINEABLE certsTxBodyL #-}

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

  upgradeTxBody :: EraTxBody (PreviousEra (MaryEra c)) =>
TxBody (PreviousEra (MaryEra c))
-> Either (TxBodyUpgradeError (MaryEra c)) (TxBody (MaryEra c))
upgradeTxBody TxBody (PreviousEra (MaryEra c))
atb = do
    StrictSeq (TxCert (MaryEra c))
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 c))
atb)
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
      MaryTxBody
        { mtbInputs :: Set (TxIn (EraCrypto (MaryEra c)))
mtbInputs = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Set (TxIn (EraCrypto era))
atbInputs TxBody (PreviousEra (MaryEra c))
atb
        , mtbOutputs :: StrictSeq (TxOut (MaryEra c))
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 c))
atb
        , mtbCerts :: StrictSeq (TxCert (MaryEra c))
mtbCerts = StrictSeq (TxCert (MaryEra c))
certs
        , mtbWithdrawals :: Withdrawals (EraCrypto (MaryEra c))
mtbWithdrawals = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Withdrawals (EraCrypto era)
atbWithdrawals TxBody (PreviousEra (MaryEra c))
atb
        , mtbTxFee :: Coin
mtbTxFee = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> Coin
atbTxFee TxBody (PreviousEra (MaryEra c))
atb
        , mtbValidityInterval :: ValidityInterval
mtbValidityInterval = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era -> ValidityInterval
atbValidityInterval TxBody (PreviousEra (MaryEra c))
atb
        , mtbUpdate :: StrictMaybe (Update (MaryEra c))
mtbUpdate = forall era.
(EraPParams era, EraPParams (PreviousEra era),
 EraCrypto (PreviousEra era) ~ EraCrypto 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 c))
atb
        , mtbAuxDataHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto (MaryEra c)))
mtbAuxDataHash = forall era.
(EraTxOut era, EraTxCert era) =>
AllegraTxBody era
-> StrictMaybe (AuxiliaryDataHash (EraCrypto era))
atbAuxDataHash TxBody (PreviousEra (MaryEra c))
atb
        , mtbMint :: MultiAsset (EraCrypto (MaryEra c))
mtbMint = forall a. Monoid a => a
mempty
        }

instance Crypto c => ShelleyEraTxBody (MaryEra c) where
  {-# SPECIALIZE instance ShelleyEraTxBody (MaryEra StandardCrypto) #-}

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

  updateTxBodyL :: Lens' (TxBody (MaryEra c)) (StrictMaybe (Update (MaryEra c)))
updateTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> StrictMaybe (Update era)
atbrUpdate forall a b. (a -> b) -> a -> b
$ \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw StrictMaybe (Update (MaryEra c))
update -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrUpdate :: StrictMaybe (Update (MaryEra c))
atbrUpdate = StrictMaybe (Update (MaryEra c))
update}
  {-# INLINEABLE updateTxBodyL #-}

instance Crypto c => AllegraEraTxBody (MaryEra c) where
  {-# SPECIALIZE instance AllegraEraTxBody (MaryEra StandardCrypto) #-}

  vldtTxBodyL :: Lens' (TxBody (MaryEra c)) ValidityInterval
vldtTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> ValidityInterval
atbrValidityInterval forall a b. (a -> b) -> a -> b
$
      \AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw ValidityInterval
vldt -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrValidityInterval :: ValidityInterval
atbrValidityInterval = ValidityInterval
vldt}
  {-# INLINEABLE vldtTxBodyL #-}

instance Crypto c => MaryEraTxBody (MaryEra c) where
  {-# SPECIALIZE instance MaryEraTxBody (MaryEra StandardCrypto) #-}

  mintTxBodyL :: Lens' (TxBody (MaryEra c)) (MultiAsset (EraCrypto (MaryEra c)))
mintTxBodyL =
    forall era a b.
(EraTxOut era, EraTxCert era) =>
(AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era -> a)
-> (AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era
    -> b -> AllegraTxBodyRaw (MultiAsset (EraCrypto era)) era)
-> Lens (MaryTxBody era) (MaryTxBody era) a b
lensMaryTxBodyRaw forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint (\AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw MultiAsset c
mint -> AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw {atbrMint :: MultiAsset c
atbrMint = MultiAsset c
mint})
  {-# INLINEABLE mintTxBodyL #-}

  mintValueTxBodyF :: SimpleGetter (TxBody (MaryEra c)) (Value (MaryEra c))
mintValueTxBodyF =
    forall s a. (s -> a) -> SimpleGetter s a
to forall a b. (a -> b) -> a -> b
$ \(TxBodyConstr (Memo (MaryTxBodyRaw AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw) ShortByteString
_)) ->
      forall c. Coin -> MultiAsset c -> MaryValue c
MaryValue forall a. Monoid a => a
mempty (forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw)
  {-# INLINEABLE mintValueTxBodyF #-}

  mintedTxBodyF :: SimpleGetter
  (TxBody (MaryEra c)) (Set (PolicyID (EraCrypto (MaryEra c))))
mintedTxBodyF =
    forall s a. (s -> a) -> SimpleGetter s a
to forall a b. (a -> b) -> a -> b
$ \(TxBodyConstr (Memo (MaryTxBodyRaw AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw) ShortByteString
_)) -> forall c. MultiAsset c -> Set (PolicyID c)
policies (forall ma era. AllegraTxBodyRaw ma era -> ma
atbrMint AllegraTxBodyRaw (MultiAsset (EraCrypto (MaryEra c))) (MaryEra c)
txBodyRaw)
  {-# INLINEABLE mintedTxBodyF #-}