{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# 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 (..),
  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 (Annotator, 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,
  Mem,
  MemoBytes,
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.PParams (Update)
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 Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks (..))

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

  -- TODO: extract away from this type class into a standalone getter
  mintedTxBodyF :: SimpleGetter (TxBody l era) (Set PolicyID)
  mintedTxBodyF = (MultiAsset -> Const r MultiAsset)
-> TxBody l era -> Const r (TxBody l era)
forall era (l :: TxLevel).
MaryEraTxBody era =>
Lens' (TxBody l era) MultiAsset
forall (l :: TxLevel). Lens' (TxBody l era) MultiAsset
mintTxBodyL ((MultiAsset -> Const r MultiAsset)
 -> TxBody l era -> Const r (TxBody l era))
-> ((Set PolicyID -> Const r (Set PolicyID))
    -> MultiAsset -> Const r MultiAsset)
-> (Set PolicyID -> Const r (Set PolicyID))
-> TxBody l era
-> Const r (TxBody l era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MultiAsset -> Set PolicyID)
-> SimpleGetter MultiAsset (Set PolicyID)
forall s a. (s -> a) -> SimpleGetter s a
to MultiAsset -> Set PolicyID
policies
  {-# INLINE mintedTxBodyF #-}

  mintValueTxBodyF :: SimpleGetter (TxBody l era) (Value era)
  default mintValueTxBodyF :: Value era ~ MaryValue => SimpleGetter (TxBody l era) (Value era)
  mintValueTxBodyF = (MultiAsset -> Const r MultiAsset)
-> TxBody l era -> Const r (TxBody l era)
forall era (l :: TxLevel).
MaryEraTxBody era =>
Lens' (TxBody l era) MultiAsset
forall (l :: TxLevel). Lens' (TxBody l era) MultiAsset
mintTxBodyL ((MultiAsset -> Const r MultiAsset)
 -> TxBody l era -> Const r (TxBody l era))
-> ((MaryValue -> Const r MaryValue)
    -> MultiAsset -> Const r MultiAsset)
-> (MaryValue -> Const r MaryValue)
-> TxBody l era
-> Const r (TxBody l 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 l = AllegraTxBodyRaw MultiAsset l MaryEra

instance EqRaw (TxBody l MaryEra)

deriving instance Generic (TxBody l MaryEra)

deriving via
  Mem (MaryTxBodyRaw l)
  instance
    Typeable l => DecCBOR (Annotator (TxBody l MaryEra))

type instance MemoHashIndex (MaryTxBodyRaw l) = EraIndependentTxBody

instance HashAnnotated (TxBody l MaryEra) EraIndependentTxBody where
  hashAnnotated :: TxBody l MaryEra -> SafeHash EraIndependentTxBody
hashAnnotated = TxBody l MaryEra -> SafeHash EraIndependentTxBody
TxBody l MaryEra
-> SafeHash (MemoHashIndex (RawType (TxBody l 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 TopTx MaryEra
pattern $mMaryTxBody :: forall {r}.
(EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx 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 TopTx MaryEra
MaryTxBody
  { (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> Set TxIn
mtbInputs
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> StrictSeq (TxOut MaryEra)
mtbOutputs
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> StrictSeq (TxCert MaryEra)
mtbCerts
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> Withdrawals
mtbWithdrawals
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> Coin
mtbTxFee
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> ValidityInterval
mtbValidityInterval
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> StrictMaybe (Update MaryEra)
mtbUpdate
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx MaryEra -> StrictMaybe TxAuxDataHash
mtbAuxDataHash
  , (EraTxOut MaryEra, EraTxCert MaryEra) =>
TxBody TopTx 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 TopTx MaryEra) -> TxBody TopTx MaryEra)
-> RawType (TxBody TopTx MaryEra) -> TxBody TopTx 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 EraTxLevel MaryEra where type STxLevel l MaryEra = STxTopLevel l MaryEra

instance HasEraTxLevel (AllegraTxBodyRaw ma) MaryEra where
  toSTxLevel :: forall (l :: TxLevel).
AllegraTxBodyRaw ma l MaryEra -> STxLevel l MaryEra
toSTxLevel AllegraTxBodyRaw {} = STxLevel l MaryEra
STxTopLevel TopTx MaryEra
forall era. STxTopLevel TopTx era
STopTxOnly

instance HasEraTxLevel TxBody MaryEra where
  toSTxLevel :: forall (l :: TxLevel). TxBody l MaryEra -> STxLevel l MaryEra
toSTxLevel = AllegraTxBodyRaw MultiAsset l MaryEra -> STxLevel l MaryEra
AllegraTxBodyRaw MultiAsset l MaryEra -> STxTopLevel l MaryEra
forall (l :: TxLevel).
AllegraTxBodyRaw MultiAsset l MaryEra -> STxLevel l MaryEra
forall (t :: TxLevel -> * -> *) era (l :: TxLevel).
HasEraTxLevel t era =>
t l era -> STxLevel l era
toSTxLevel (AllegraTxBodyRaw MultiAsset l MaryEra -> STxTopLevel l MaryEra)
-> (TxBody l MaryEra -> AllegraTxBodyRaw MultiAsset l MaryEra)
-> TxBody l MaryEra
-> STxTopLevel l MaryEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody l MaryEra -> AllegraTxBodyRaw MultiAsset l MaryEra
TxBody l MaryEra -> RawType (TxBody l MaryEra)
forall t. Memoized t => t -> RawType t
getMemoRawType

instance Memoized (TxBody l MaryEra) where
  type RawType (TxBody l MaryEra) = AllegraTxBodyRaw MultiAsset l MaryEra

emptyMaryTxBodyRaw :: MaryTxBodyRaw TopTx
emptyMaryTxBodyRaw :: AllegraTxBodyRaw MultiAsset TopTx MaryEra
emptyMaryTxBodyRaw = AllegraTxBodyRaw MultiAsset TopTx MaryEra
forall ma era. Monoid ma => AllegraTxBodyRaw ma TopTx era
emptyAllegraTxBodyRaw

basicMaryTxBody :: Typeable l => TxBody l MaryEra
basicMaryTxBody :: forall (l :: TxLevel). Typeable l => TxBody l MaryEra
basicMaryTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @MaryEra (RawType (TxBody l MaryEra) -> TxBody l MaryEra)
-> RawType (TxBody l MaryEra) -> TxBody l MaryEra
forall a b. (a -> b) -> a -> b
$ AllegraTxBodyRaw MultiAsset TopTx MaryEra
-> AllegraTxBodyRaw MultiAsset l MaryEra
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel AllegraTxBodyRaw MultiAsset TopTx MaryEra
emptyMaryTxBodyRaw

instance EraTxBody MaryEra where
  newtype TxBody l MaryEra = MkMaryTxBody (MemoBytes (MaryTxBodyRaw l))
    deriving newtype (TxBody l MaryEra -> Int
TxBody l MaryEra -> ByteString
(TxBody l MaryEra -> ByteString)
-> (TxBody l MaryEra -> Int)
-> (forall i. Proxy i -> TxBody l MaryEra -> SafeHash i)
-> SafeToHash (TxBody l MaryEra)
forall i. Proxy i -> TxBody l MaryEra -> SafeHash i
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall (l :: TxLevel). TxBody l MaryEra -> Int
forall (l :: TxLevel). TxBody l MaryEra -> ByteString
forall (l :: TxLevel) i. Proxy i -> TxBody l MaryEra -> SafeHash i
$coriginalBytes :: forall (l :: TxLevel). TxBody l MaryEra -> ByteString
originalBytes :: TxBody l MaryEra -> ByteString
$coriginalBytesSize :: forall (l :: TxLevel). TxBody l MaryEra -> Int
originalBytesSize :: TxBody l MaryEra -> Int
$cmakeHashWithExplicitProxys :: forall (l :: TxLevel) i. Proxy i -> TxBody l MaryEra -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxBody l MaryEra -> SafeHash i
SafeToHash, Typeable (TxBody l MaryEra)
Typeable (TxBody l MaryEra) =>
(TxBody l MaryEra -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxBody l MaryEra) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxBody l MaryEra] -> Size)
-> ToCBOR (TxBody l MaryEra)
TxBody l MaryEra -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l MaryEra] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l 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
forall (l :: TxLevel). Typeable l => Typeable (TxBody l MaryEra)
forall (l :: TxLevel). Typeable l => TxBody l MaryEra -> Encoding
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l MaryEra] -> Size
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l MaryEra) -> Size
$ctoCBOR :: forall (l :: TxLevel). Typeable l => TxBody l MaryEra -> Encoding
toCBOR :: TxBody l MaryEra -> Encoding
$cencodedSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l MaryEra) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l MaryEra) -> Size
$cencodedListSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l MaryEra] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l MaryEra] -> Size
ToCBOR, TxBody l MaryEra -> Encoding
(TxBody l MaryEra -> Encoding) -> EncCBOR (TxBody l MaryEra)
forall a. (a -> Encoding) -> EncCBOR a
forall (l :: TxLevel). TxBody l MaryEra -> Encoding
$cencCBOR :: forall (l :: TxLevel). TxBody l MaryEra -> Encoding
encCBOR :: TxBody l MaryEra -> Encoding
EncCBOR, TxBody l MaryEra -> TxBody l MaryEra -> Bool
(TxBody l MaryEra -> TxBody l MaryEra -> Bool)
-> (TxBody l MaryEra -> TxBody l MaryEra -> Bool)
-> Eq (TxBody l MaryEra)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (l :: TxLevel). TxBody l MaryEra -> TxBody l MaryEra -> Bool
$c== :: forall (l :: TxLevel). TxBody l MaryEra -> TxBody l MaryEra -> Bool
== :: TxBody l MaryEra -> TxBody l MaryEra -> Bool
$c/= :: forall (l :: TxLevel). TxBody l MaryEra -> TxBody l MaryEra -> Bool
/= :: TxBody l MaryEra -> TxBody l MaryEra -> Bool
Eq, Int -> TxBody l MaryEra -> ShowS
[TxBody l MaryEra] -> ShowS
TxBody l MaryEra -> String
(Int -> TxBody l MaryEra -> ShowS)
-> (TxBody l MaryEra -> String)
-> ([TxBody l MaryEra] -> ShowS)
-> Show (TxBody l MaryEra)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (l :: TxLevel). Int -> TxBody l MaryEra -> ShowS
forall (l :: TxLevel). [TxBody l MaryEra] -> ShowS
forall (l :: TxLevel). TxBody l MaryEra -> String
$cshowsPrec :: forall (l :: TxLevel). Int -> TxBody l MaryEra -> ShowS
showsPrec :: Int -> TxBody l MaryEra -> ShowS
$cshow :: forall (l :: TxLevel). TxBody l MaryEra -> String
show :: TxBody l MaryEra -> String
$cshowList :: forall (l :: TxLevel). [TxBody l MaryEra] -> ShowS
showList :: [TxBody l MaryEra] -> ShowS
Show, Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
Proxy (TxBody l MaryEra) -> String
(Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo))
-> (Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo))
-> (Proxy (TxBody l MaryEra) -> String)
-> NoThunks (TxBody l MaryEra)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
forall (l :: TxLevel).
Typeable l =>
Proxy (TxBody l MaryEra) -> String
$cnoThunks :: forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxBody l MaryEra -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall (l :: TxLevel).
Typeable l =>
Proxy (TxBody l MaryEra) -> String
showTypeOf :: Proxy (TxBody l MaryEra) -> String
NoThunks, TxBody l MaryEra -> ()
(TxBody l MaryEra -> ()) -> NFData (TxBody l MaryEra)
forall a. (a -> ()) -> NFData a
forall (l :: TxLevel). TxBody l MaryEra -> ()
$crnf :: forall (l :: TxLevel). TxBody l MaryEra -> ()
rnf :: TxBody l MaryEra -> ()
NFData)

  mkBasicTxBody :: forall (l :: TxLevel). Typeable l => TxBody l MaryEra
mkBasicTxBody = TxBody l MaryEra
forall (l :: TxLevel). Typeable l => TxBody l MaryEra
basicMaryTxBody

  inputsTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l 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 (\AllegraTxBodyRaw {Set TxIn
atbrInputs :: forall era ma. AllegraTxBodyRaw ma TopTx era -> Set TxIn
atbrInputs :: Set TxIn
atbrInputs} -> Set TxIn
atbrInputs) ((RawType (TxBody l MaryEra)
  -> Set TxIn -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra) (TxBody l MaryEra) (Set TxIn) (Set TxIn))
-> (RawType (TxBody l MaryEra)
    -> Set TxIn -> RawType (TxBody l MaryEra))
-> Lens (TxBody l MaryEra) (TxBody l MaryEra) (Set TxIn) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l MaryEra)
txBodyRaw Set TxIn
inputs -> RawType (TxBody l MaryEra)
txBodyRaw {atbrInputs = inputs}
  {-# INLINEABLE inputsTxBodyL #-}

  outputsTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l 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 (\AllegraTxBodyRaw {StrictSeq (TxOut MaryEra)
atbrOutputs :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxOut era)
atbrOutputs :: StrictSeq (TxOut MaryEra)
atbrOutputs} -> StrictSeq (TxOut MaryEra)
atbrOutputs) ((RawType (TxBody l MaryEra)
  -> StrictSeq (TxOut MaryEra) -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra)
      (TxBody l MaryEra)
      (StrictSeq (TxOut MaryEra))
      (StrictSeq (TxOut MaryEra)))
-> (RawType (TxBody l MaryEra)
    -> StrictSeq (TxOut MaryEra) -> RawType (TxBody l MaryEra))
-> Lens
     (TxBody l MaryEra)
     (TxBody l MaryEra)
     (StrictSeq (TxOut MaryEra))
     (StrictSeq (TxOut MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l MaryEra)
txBodyRaw StrictSeq (TxOut MaryEra)
outputs -> RawType (TxBody l MaryEra)
txBodyRaw {atbrOutputs = outputs}
  {-# INLINEABLE outputsTxBodyL #-}

  feeTxBodyL :: Lens' (TxBody TopTx 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 AllegraTxBodyRaw MultiAsset TopTx MaryEra -> Coin
RawType (TxBody TopTx MaryEra) -> Coin
forall era ma. AllegraTxBodyRaw ma TopTx era -> Coin
atbrFee ((RawType (TxBody TopTx MaryEra)
  -> Coin -> RawType (TxBody TopTx MaryEra))
 -> Lens' (TxBody TopTx MaryEra) Coin)
-> (RawType (TxBody TopTx MaryEra)
    -> Coin -> RawType (TxBody TopTx MaryEra))
-> Lens' (TxBody TopTx MaryEra) Coin
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx MaryEra)
txBodyRaw Coin
fee -> RawType (TxBody TopTx MaryEra)
txBodyRaw {atbrFee = fee}
  {-# INLINEABLE feeTxBodyL #-}

  auxDataHashTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l 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 (\AllegraTxBodyRaw {StrictMaybe TxAuxDataHash
atbrAuxDataHash :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe TxAuxDataHash
atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrAuxDataHash} -> StrictMaybe TxAuxDataHash
atbrAuxDataHash) ((RawType (TxBody l MaryEra)
  -> StrictMaybe TxAuxDataHash -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra)
      (TxBody l MaryEra)
      (StrictMaybe TxAuxDataHash)
      (StrictMaybe TxAuxDataHash))
-> (RawType (TxBody l MaryEra)
    -> StrictMaybe TxAuxDataHash -> RawType (TxBody l MaryEra))
-> Lens
     (TxBody l MaryEra)
     (TxBody l MaryEra)
     (StrictMaybe TxAuxDataHash)
     (StrictMaybe TxAuxDataHash)
forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody l MaryEra)
txBodyRaw StrictMaybe TxAuxDataHash
auxDataHash -> RawType (TxBody l MaryEra)
txBodyRaw {atbrAuxDataHash = auxDataHash}
  {-# INLINEABLE auxDataHashTxBodyL #-}

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

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

  withdrawalsTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l 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 (\AllegraTxBodyRaw {Withdrawals
atbrWithdrawals :: forall era ma. AllegraTxBodyRaw ma TopTx era -> Withdrawals
atbrWithdrawals :: Withdrawals
atbrWithdrawals} -> Withdrawals
atbrWithdrawals) ((RawType (TxBody l MaryEra)
  -> Withdrawals -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra) (TxBody l MaryEra) Withdrawals Withdrawals)
-> (RawType (TxBody l MaryEra)
    -> Withdrawals -> RawType (TxBody l MaryEra))
-> Lens
     (TxBody l MaryEra) (TxBody l MaryEra) Withdrawals Withdrawals
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l MaryEra)
txBodyRaw Withdrawals
withdrawals -> RawType (TxBody l MaryEra)
txBodyRaw {atbrWithdrawals = withdrawals}
  {-# INLINEABLE withdrawalsTxBodyL #-}

  certsTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l 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 (\AllegraTxBodyRaw {StrictSeq (TxCert MaryEra)
atbrCerts :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxCert era)
atbrCerts :: StrictSeq (TxCert MaryEra)
atbrCerts} -> StrictSeq (TxCert MaryEra)
atbrCerts) ((RawType (TxBody l MaryEra)
  -> StrictSeq (TxCert MaryEra) -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra)
      (TxBody l MaryEra)
      (StrictSeq (TxCert MaryEra))
      (StrictSeq (TxCert MaryEra)))
-> (RawType (TxBody l MaryEra)
    -> StrictSeq (TxCert MaryEra) -> RawType (TxBody l MaryEra))
-> Lens
     (TxBody l MaryEra)
     (TxBody l MaryEra)
     (StrictSeq (TxCert MaryEra))
     (StrictSeq (TxCert MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l MaryEra)
txBodyRaw StrictSeq (TxCert MaryEra)
certs -> RawType (TxBody l MaryEra)
txBodyRaw {atbrCerts = certs}
  {-# INLINEABLE certsTxBodyL #-}

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

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

  updateTxBodyL :: Lens' (TxBody TopTx 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 AllegraTxBodyRaw MultiAsset TopTx MaryEra
-> StrictMaybe (Update MaryEra)
RawType (TxBody TopTx MaryEra) -> StrictMaybe (Update MaryEra)
forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe (Update era)
atbrUpdate ((RawType (TxBody TopTx MaryEra)
  -> StrictMaybe (Update MaryEra) -> RawType (TxBody TopTx MaryEra))
 -> Lens' (TxBody TopTx MaryEra) (StrictMaybe (Update MaryEra)))
-> (RawType (TxBody TopTx MaryEra)
    -> StrictMaybe (Update MaryEra) -> RawType (TxBody TopTx MaryEra))
-> Lens' (TxBody TopTx MaryEra) (StrictMaybe (Update MaryEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx MaryEra)
txBodyRaw StrictMaybe (Update MaryEra)
update -> RawType (TxBody TopTx MaryEra)
txBodyRaw {atbrUpdate = update}
  {-# INLINEABLE updateTxBodyL #-}

instance AllegraEraTxBody MaryEra where
  vldtTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l 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 (\AllegraTxBodyRaw {ValidityInterval
atbrValidityInterval :: forall era ma. AllegraTxBodyRaw ma TopTx era -> ValidityInterval
atbrValidityInterval :: ValidityInterval
atbrValidityInterval} -> ValidityInterval
atbrValidityInterval) ((RawType (TxBody l MaryEra)
  -> ValidityInterval -> RawType (TxBody l MaryEra))
 -> Lens
      (TxBody l MaryEra)
      (TxBody l MaryEra)
      ValidityInterval
      ValidityInterval)
-> (RawType (TxBody l MaryEra)
    -> ValidityInterval -> RawType (TxBody l MaryEra))
-> Lens
     (TxBody l MaryEra)
     (TxBody l MaryEra)
     ValidityInterval
     ValidityInterval
forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody l MaryEra)
txBodyRaw ValidityInterval
vldt -> RawType (TxBody l MaryEra)
txBodyRaw {atbrValidityInterval = vldt}
  {-# INLINEABLE vldtTxBodyL #-}

instance MaryEraTxBody MaryEra where
  mintTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l 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
      (\AllegraTxBodyRaw {MultiAsset
atbrMint :: forall era ma. AllegraTxBodyRaw ma TopTx era -> ma
atbrMint :: MultiAsset
atbrMint} -> MultiAsset
atbrMint)
      (\RawType (TxBody l MaryEra)
txBodyRaw MultiAsset
mint -> RawType (TxBody l MaryEra)
txBodyRaw {atbrMint = mint})
  {-# INLINEABLE mintTxBodyL #-}