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

module Cardano.Ledger.Babbage.TxBody (
  BabbageTxOut (
    BabbageTxOut,
    TxOutCompact,
    TxOutCompactDH,
    TxOutCompactDatum,
    TxOutCompactRefScript
  ),
  TxBody (
    MkBabbageTxBody,
    BabbageTxBody,
    btbInputs,
    btbCollateral,
    btbReferenceInputs,
    btbOutputs,
    btbCollateralReturn,
    btbTotalCollateral,
    btbCerts,
    btbWithdrawals,
    btbTxFee,
    btbValidityInterval,
    btbUpdate,
    btbReqSignerHashes,
    btbMint,
    btbScriptIntegrityHash,
    btbAuxDataHash,
    btbTxNetworkId
  ),
  allSizedOutputsBabbageTxBodyF,
  babbageMinUTxOValue,
  BabbageTxBodyRaw (..),
  babbageAllInputsTxBodyF,
  babbageSpendableInputsTxBodyF,
  BabbageEraTxBody (..),
  getEitherAddrBabbageTxOut,
  EraIndependentScriptIntegrity,
  ScriptIntegrityHash,
) where

import Cardano.Ledger.Alonzo.Core
import Cardano.Ledger.Alonzo.TxBody (alonzoRedeemerPointer, alonzoRedeemerPointerInverse)
import Cardano.Ledger.Babbage.Era (BabbageEra)
import Cardano.Ledger.Babbage.Scripts ()
import Cardano.Ledger.Babbage.TxCert ()
import Cardano.Ledger.Babbage.TxOut
import Cardano.Ledger.BaseTypes (
  Network (..),
  StrictMaybe (..),
 )
import Cardano.Ledger.Binary (
  Annotator (..),
  DecCBOR (..),
  EncCBOR (..),
  Sized (..),
  ToCBOR (..),
  mkSized,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Mary.Value (MultiAsset)
import Cardano.Ledger.MemoBytes (
  EqRaw,
  Mem,
  MemoBytes,
  MemoHashIndex,
  Memoized (..),
  eqRaw,
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
  zipMemoRawType,
 )
import Cardano.Ledger.Shelley.PParams (Update (..))
import Cardano.Ledger.Shelley.TxBody (getShelleyGenesisKeyHashCountTxBody)
import Cardano.Ledger.TxIn (TxIn (..))
import Control.DeepSeq (NFData (..), deepseq)
import Data.Foldable as F (foldl')
import Data.Sequence.Strict (StrictSeq, (|>))
import qualified Data.Sequence.Strict as StrictSeq
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (InspectHeap (..), NoThunks)

class (AlonzoEraTxBody era, BabbageEraTxOut era) => BabbageEraTxBody era where
  sizedOutputsTxBodyL :: Lens' (TxBody l era) (StrictSeq (Sized (TxOut era)))

  referenceInputsTxBodyL :: Lens' (TxBody l era) (Set TxIn)

  totalCollateralTxBodyL :: Lens' (TxBody TopTx era) (StrictMaybe Coin)

  collateralReturnTxBodyL :: Lens' (TxBody TopTx era) (StrictMaybe (TxOut era))

  sizedCollateralReturnTxBodyL :: Lens' (TxBody TopTx era) (StrictMaybe (Sized (TxOut era)))

  allSizedOutputsTxBodyF :: SimpleGetter (TxBody l era) (StrictSeq (Sized (TxOut era)))

-- ======================================

data BabbageTxBodyRaw l era where
  BabbageTxBodyRaw ::
    { forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrInputs :: !(Set TxIn)
    , forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs :: !(Set TxIn)
    , forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs :: !(Set TxIn)
    , forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs :: !(StrictSeq (Sized (TxOut era)))
    , forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn :: !(StrictMaybe (Sized (TxOut era)))
    , forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrTotalCollateral :: !(StrictMaybe Coin)
    , forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrCerts :: !(StrictSeq (TxCert era))
    , forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrWithdrawals :: !Withdrawals
    , forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrFee :: !Coin
    , forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrValidityInterval :: !ValidityInterval
    , forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrUpdate :: !(StrictMaybe (Update era))
    , forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrReqSignerHashes :: !(Set (KeyHash Guard))
    , forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrMint :: !MultiAsset
    , -- The spec makes it clear that the mint field is a
      -- Cardano.Ledger.Mary.Value.MaryValue, not a Value.
      -- Operations on the TxBody in the BabbageEra depend upon this.
      -- We now store only the MultiAsset part of a Mary.Value.
      forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: !(StrictMaybe ScriptIntegrityHash)
    , forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrAuxDataHash :: !(StrictMaybe TxAuxDataHash)
    , forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrNetworkId :: !(StrictMaybe Network)
    } ->
    BabbageTxBodyRaw TopTx era

deriving instance Eq (BabbageTxBodyRaw l BabbageEra)

deriving instance Show (BabbageTxBodyRaw l BabbageEra)

instance NFData (BabbageTxBodyRaw l BabbageEra) where
  rnf :: BabbageTxBodyRaw l BabbageEra -> ()
rnf BabbageTxBodyRaw {Set (KeyHash Guard)
Set TxIn
StrictMaybe ScriptIntegrityHash
StrictMaybe TxAuxDataHash
StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe Network
StrictMaybe Coin
StrictMaybe (Update BabbageEra)
ValidityInterval
Withdrawals
Coin
MultiAsset
StrictSeq (TxCert BabbageEra)
StrictSeq (Sized (TxOut BabbageEra))
btbrInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrOutputs :: forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrCollateralReturn :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrTotalCollateral :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrCerts :: forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrWithdrawals :: forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrFee :: forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrValidityInterval :: forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrUpdate :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrReqSignerHashes :: forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrMint :: forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrScriptIntegrityHash :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrAuxDataHash :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrNetworkId :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrInputs :: Set TxIn
btbrCollateralInputs :: Set TxIn
btbrReferenceInputs :: Set TxIn
btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrTotalCollateral :: StrictMaybe Coin
btbrCerts :: StrictSeq (TxCert BabbageEra)
btbrWithdrawals :: Withdrawals
btbrFee :: Coin
btbrValidityInterval :: ValidityInterval
btbrUpdate :: StrictMaybe (Update BabbageEra)
btbrReqSignerHashes :: Set (KeyHash Guard)
btbrMint :: MultiAsset
btbrScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbrAuxDataHash :: StrictMaybe TxAuxDataHash
btbrNetworkId :: StrictMaybe Network
..} =
    Set TxIn
btbrInputs Set TxIn -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
      Set TxIn
btbrCollateralInputs Set TxIn -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
        Set TxIn
btbrReferenceInputs Set TxIn -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
          StrictSeq (Sized (TxOut BabbageEra))
StrictSeq (Sized (BabbageTxOut BabbageEra))
btbrOutputs StrictSeq (Sized (BabbageTxOut BabbageEra)) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
            StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
btbrCollateralReturn StrictMaybe (Sized (BabbageTxOut BabbageEra)) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
              StrictMaybe Coin
btbrTotalCollateral StrictMaybe Coin -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                StrictSeq (TxCert BabbageEra)
StrictSeq (ShelleyTxCert BabbageEra)
btbrCerts StrictSeq (ShelleyTxCert BabbageEra) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                  Withdrawals
btbrWithdrawals Withdrawals -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                    Coin
btbrFee Coin -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                      ValidityInterval
btbrValidityInterval ValidityInterval -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                        StrictMaybe (Update BabbageEra)
btbrUpdate StrictMaybe (Update BabbageEra) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                          Set (KeyHash Guard)
btbrReqSignerHashes Set (KeyHash Guard) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                            MultiAsset
btbrMint MultiAsset -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                              StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash StrictMaybe ScriptIntegrityHash -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                                StrictMaybe TxAuxDataHash
btbrAuxDataHash StrictMaybe TxAuxDataHash -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                                  StrictMaybe Network -> ()
forall a. NFData a => a -> ()
rnf StrictMaybe Network
btbrNetworkId

-- We override this instance because the 'Sized' types also reference their
-- serialisation and as such cannot be compared directly. An alternative would
-- be to derive `EqRaw` for `Sized`.
instance EqRaw (BabbageTxBodyRaw l BabbageEra) where
  eqRaw :: BabbageTxBodyRaw l BabbageEra
-> BabbageTxBodyRaw l BabbageEra -> Bool
eqRaw BabbageTxBodyRaw l BabbageEra
a BabbageTxBodyRaw l BabbageEra
b =
    case BabbageTxBodyRaw l BabbageEra -> STxLevel l BabbageEra
forall (l :: TxLevel).
BabbageTxBodyRaw l BabbageEra -> STxLevel l BabbageEra
forall (t :: TxLevel -> * -> *) era (l :: TxLevel).
HasEraTxLevel t era =>
t l era -> STxLevel l era
toSTxLevel BabbageTxBodyRaw l BabbageEra
a of
      STxLevel l BabbageEra
STxTopLevel l BabbageEra
STopTxOnly ->
        BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Set TxIn
forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra
-> StrictSeq (Sized (TxOut BabbageEra))
forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictSeq (Sized (BabbageTxOut BabbageEra))
-> StrictSeq (Sized (BabbageTxOut BabbageEra)) -> Bool
forall {a}.
Eq a =>
StrictSeq (Sized a) -> StrictSeq (Sized a) -> Bool
`eqSeqUnsized` BabbageTxBodyRaw TopTx BabbageEra
-> StrictSeq (Sized (TxOut BabbageEra))
forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (Sized (TxOut BabbageEra))
forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe (Sized (BabbageTxOut BabbageEra))
-> StrictMaybe (Sized (BabbageTxOut BabbageEra)) -> Bool
forall {a}.
Eq a =>
StrictMaybe (Sized a) -> StrictMaybe (Sized a) -> Bool
`eqMbUnsized` BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (Sized (TxOut BabbageEra))
forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe Coin
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrTotalCollateral BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe Coin -> StrictMaybe Coin -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe Coin
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrTotalCollateral BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> StrictSeq (TxCert BabbageEra)
forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrCerts BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictSeq (ShelleyTxCert BabbageEra)
-> StrictSeq (ShelleyTxCert BabbageEra) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> StrictSeq (TxCert BabbageEra)
forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrCerts BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> Withdrawals
forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrWithdrawals BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Withdrawals -> Withdrawals -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Withdrawals
forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrWithdrawals BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> Coin
forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrFee BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Coin -> Coin -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Coin
forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrFee BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> ValidityInterval
forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrValidityInterval BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a ValidityInterval -> ValidityInterval -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> ValidityInterval
forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrValidityInterval BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (Update BabbageEra)
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrUpdate BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe (Update BabbageEra)
-> StrictMaybe (Update BabbageEra) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (Update BabbageEra)
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrUpdate BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> Set (KeyHash Guard)
forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrReqSignerHashes BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a Set (KeyHash Guard) -> Set (KeyHash Guard) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> Set (KeyHash Guard)
forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrReqSignerHashes BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> MultiAsset
forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrMint BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a MultiAsset -> MultiAsset -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> MultiAsset
forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrMint BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe ScriptIntegrityHash
forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe ScriptIntegrityHash
-> StrictMaybe ScriptIntegrityHash -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe ScriptIntegrityHash
forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe TxAuxDataHash
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrAuxDataHash BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe TxAuxDataHash -> StrictMaybe TxAuxDataHash -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe TxAuxDataHash
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrAuxDataHash BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
          Bool -> Bool -> Bool
&& BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe Network
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrNetworkId BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
a StrictMaybe Network -> StrictMaybe Network -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw TopTx BabbageEra -> StrictMaybe Network
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrNetworkId BabbageTxBodyRaw l BabbageEra
BabbageTxBodyRaw TopTx BabbageEra
b
        where
          eqMbUnsized :: StrictMaybe (Sized a) -> StrictMaybe (Sized a) -> Bool
eqMbUnsized StrictMaybe (Sized a)
x StrictMaybe (Sized a)
y = case (StrictMaybe (Sized a)
x, StrictMaybe (Sized a)
y) of
            (SJust Sized a
a', SJust Sized a
b') -> Sized a
a' Sized a -> Sized a -> Bool
forall {a}. Eq a => Sized a -> Sized a -> Bool
`eqUnsized` Sized a
b'
            (StrictMaybe (Sized a)
SNothing, StrictMaybe (Sized a)
SNothing) -> Bool
True
            (StrictMaybe (Sized a), StrictMaybe (Sized a))
_ -> Bool
False
          eqSeqUnsized :: StrictSeq (Sized a) -> StrictSeq (Sized a) -> Bool
eqSeqUnsized StrictSeq (Sized a)
x StrictSeq (Sized a)
y =
            StrictSeq (Sized a) -> Int
forall a. StrictSeq a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length StrictSeq (Sized a)
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== StrictSeq (Sized a) -> Int
forall a. StrictSeq a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length StrictSeq (Sized a)
y
              Bool -> Bool -> Bool
&& (Bool -> (Sized a, Sized a) -> Bool)
-> Bool -> StrictSeq (Sized a, Sized a) -> Bool
forall b a. (b -> a -> b) -> b -> StrictSeq a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' (\Bool
acc (Sized a
x', Sized a
y') -> Bool
acc Bool -> Bool -> Bool
&& Sized a
x' Sized a -> Sized a -> Bool
forall {a}. Eq a => Sized a -> Sized a -> Bool
`eqUnsized` Sized a
y') Bool
True (StrictSeq (Sized a)
-> StrictSeq (Sized a) -> StrictSeq (Sized a, Sized a)
forall a b. StrictSeq a -> StrictSeq b -> StrictSeq (a, b)
StrictSeq.zip StrictSeq (Sized a)
x StrictSeq (Sized a)
y)
          eqUnsized :: Sized a -> Sized a -> Bool
eqUnsized Sized a
x Sized a
y = Sized a -> a
forall a. Sized a -> a
sizedValue Sized a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Sized a -> a
forall a. Sized a -> a
sizedValue Sized a
y

type instance MemoHashIndex (BabbageTxBodyRaw l era) = EraIndependentTxBody

deriving via
  InspectHeap (BabbageTxBodyRaw l BabbageEra)
  instance
    Typeable l => NoThunks (BabbageTxBodyRaw l BabbageEra)

deriving via
  Mem (BabbageTxBodyRaw l BabbageEra)
  instance
    Typeable l => DecCBOR (Annotator (TxBody l BabbageEra))

instance Memoized (TxBody l BabbageEra) where
  type RawType (TxBody l BabbageEra) = BabbageTxBodyRaw l BabbageEra

deriving newtype instance NFData (TxBody l BabbageEra)

babbageSpendableInputsTxBodyF ::
  BabbageEraTxBody era => SimpleGetter (TxBody TopTx era) (Set TxIn)
babbageSpendableInputsTxBodyF :: forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (Set TxIn)
babbageSpendableInputsTxBodyF =
  (TxBody TopTx era -> Set TxIn)
-> SimpleGetter (TxBody TopTx era) (Set TxIn)
forall s a. (s -> a) -> SimpleGetter s a
to ((TxBody TopTx era -> Set TxIn)
 -> SimpleGetter (TxBody TopTx era) (Set TxIn))
-> (TxBody TopTx era -> Set TxIn)
-> SimpleGetter (TxBody TopTx era) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \TxBody TopTx era
txBody ->
    (TxBody TopTx era
txBody TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l era) (Set TxIn)
inputsTxBodyL)
      Set TxIn -> Set TxIn -> Set TxIn
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` (TxBody TopTx era
txBody TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody TopTx era) (Set TxIn)
Lens' (TxBody TopTx era) (Set TxIn)
collateralInputsTxBodyL)
{-# INLINEABLE babbageSpendableInputsTxBodyF #-}

babbageAllInputsTxBodyF ::
  BabbageEraTxBody era => SimpleGetter (TxBody TopTx era) (Set TxIn)
babbageAllInputsTxBodyF :: forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (Set TxIn)
babbageAllInputsTxBodyF =
  (TxBody TopTx era -> Set TxIn)
-> SimpleGetter (TxBody TopTx era) (Set TxIn)
forall s a. (s -> a) -> SimpleGetter s a
to ((TxBody TopTx era -> Set TxIn)
 -> SimpleGetter (TxBody TopTx era) (Set TxIn))
-> (TxBody TopTx era -> Set TxIn)
-> SimpleGetter (TxBody TopTx era) (Set TxIn)
forall a b. (a -> b) -> a -> b
$
    \TxBody TopTx era
txBody ->
      (TxBody TopTx era
txBody TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l era) (Set TxIn)
inputsTxBodyL)
        Set TxIn -> Set TxIn -> Set TxIn
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` (TxBody TopTx era
txBody TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody TopTx era) (Set TxIn)
Lens' (TxBody TopTx era) (Set TxIn)
collateralInputsTxBodyL)
        Set TxIn -> Set TxIn -> Set TxIn
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` (TxBody TopTx era
txBody TxBody TopTx era
-> Getting (Set TxIn) (TxBody TopTx era) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx era) (Set TxIn)
forall era (l :: TxLevel).
BabbageEraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l era) (Set TxIn)
referenceInputsTxBodyL)
{-# INLINEABLE babbageAllInputsTxBodyF #-}

allSizedOutputsBabbageTxBodyF ::
  BabbageEraTxBody era =>
  SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era)))
allSizedOutputsBabbageTxBodyF :: forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era)))
allSizedOutputsBabbageTxBodyF =
  (TxBody TopTx era -> StrictSeq (Sized (TxOut era)))
-> SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era)))
forall s a. (s -> a) -> SimpleGetter s a
to ((TxBody TopTx era -> StrictSeq (Sized (TxOut era)))
 -> SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era))))
-> (TxBody TopTx era -> StrictSeq (Sized (TxOut era)))
-> SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era)))
forall a b. (a -> b) -> a -> b
$ \TxBody TopTx era
txBody ->
    let txOuts :: StrictSeq (Sized (TxOut era))
txOuts = TxBody TopTx era
txBody TxBody TopTx era
-> Getting
     (StrictSeq (Sized (TxOut era)))
     (TxBody TopTx era)
     (StrictSeq (Sized (TxOut era)))
-> StrictSeq (Sized (TxOut era))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (Sized (TxOut era)))
  (TxBody TopTx era)
  (StrictSeq (Sized (TxOut era)))
forall era (l :: TxLevel).
BabbageEraTxBody era =>
Lens' (TxBody l era) (StrictSeq (Sized (TxOut era)))
forall (l :: TxLevel).
Lens' (TxBody l era) (StrictSeq (Sized (TxOut era)))
sizedOutputsTxBodyL
     in case TxBody TopTx era
txBody TxBody TopTx era
-> Getting
     (StrictMaybe (Sized (TxOut era)))
     (TxBody TopTx era)
     (StrictMaybe (Sized (TxOut era)))
-> StrictMaybe (Sized (TxOut era))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (Sized (TxOut era)))
  (TxBody TopTx era)
  (StrictMaybe (Sized (TxOut era)))
forall era.
BabbageEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe (Sized (TxOut era)))
Lens' (TxBody TopTx era) (StrictMaybe (Sized (TxOut era)))
sizedCollateralReturnTxBodyL of
          StrictMaybe (Sized (TxOut era))
SNothing -> StrictSeq (Sized (TxOut era))
txOuts
          SJust Sized (TxOut era)
collTxOut -> StrictSeq (Sized (TxOut era))
txOuts StrictSeq (Sized (TxOut era))
-> Sized (TxOut era) -> StrictSeq (Sized (TxOut era))
forall a. StrictSeq a -> a -> StrictSeq a
|> Sized (TxOut era)
collTxOut
{-# INLINEABLE allSizedOutputsBabbageTxBodyF #-}

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

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

basicBabbageTxBody :: Typeable l => TxBody l BabbageEra
basicBabbageTxBody :: forall (l :: TxLevel). Typeable l => TxBody l BabbageEra
basicBabbageTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @BabbageEra (RawType (TxBody l BabbageEra) -> TxBody l BabbageEra)
-> RawType (TxBody l BabbageEra) -> TxBody l BabbageEra
forall a b. (a -> b) -> a -> b
$ BabbageTxBodyRaw TopTx BabbageEra -> BabbageTxBodyRaw l BabbageEra
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel BabbageTxBodyRaw TopTx BabbageEra
forall era. BabbageTxBodyRaw TopTx era
basicBabbageTxBodyRaw

instance EraTxBody BabbageEra where
  newtype TxBody l BabbageEra = MkBabbageTxBody (MemoBytes (BabbageTxBodyRaw l BabbageEra))
    deriving newtype ((forall x. TxBody l BabbageEra -> Rep (TxBody l BabbageEra) x)
-> (forall x. Rep (TxBody l BabbageEra) x -> TxBody l BabbageEra)
-> Generic (TxBody l BabbageEra)
forall x. Rep (TxBody l BabbageEra) x -> TxBody l BabbageEra
forall x. TxBody l BabbageEra -> Rep (TxBody l BabbageEra) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (l :: TxLevel) x.
Rep (TxBody l BabbageEra) x -> TxBody l BabbageEra
forall (l :: TxLevel) x.
TxBody l BabbageEra -> Rep (TxBody l BabbageEra) x
$cfrom :: forall (l :: TxLevel) x.
TxBody l BabbageEra -> Rep (TxBody l BabbageEra) x
from :: forall x. TxBody l BabbageEra -> Rep (TxBody l BabbageEra) x
$cto :: forall (l :: TxLevel) x.
Rep (TxBody l BabbageEra) x -> TxBody l BabbageEra
to :: forall x. Rep (TxBody l BabbageEra) x -> TxBody l BabbageEra
Generic, TxBody l BabbageEra -> Int
TxBody l BabbageEra -> ByteString
(TxBody l BabbageEra -> ByteString)
-> (TxBody l BabbageEra -> Int)
-> (forall i. Proxy i -> TxBody l BabbageEra -> SafeHash i)
-> SafeToHash (TxBody l BabbageEra)
forall i. Proxy i -> TxBody l BabbageEra -> SafeHash i
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall (l :: TxLevel). TxBody l BabbageEra -> Int
forall (l :: TxLevel). TxBody l BabbageEra -> ByteString
forall (l :: TxLevel) i.
Proxy i -> TxBody l BabbageEra -> SafeHash i
$coriginalBytes :: forall (l :: TxLevel). TxBody l BabbageEra -> ByteString
originalBytes :: TxBody l BabbageEra -> ByteString
$coriginalBytesSize :: forall (l :: TxLevel). TxBody l BabbageEra -> Int
originalBytesSize :: TxBody l BabbageEra -> Int
$cmakeHashWithExplicitProxys :: forall (l :: TxLevel) i.
Proxy i -> TxBody l BabbageEra -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxBody l BabbageEra -> SafeHash i
SafeToHash, Typeable (TxBody l BabbageEra)
Typeable (TxBody l BabbageEra) =>
(TxBody l BabbageEra -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxBody l BabbageEra) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxBody l BabbageEra] -> Size)
-> ToCBOR (TxBody l BabbageEra)
TxBody l BabbageEra -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l BabbageEra] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l BabbageEra) -> 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 BabbageEra)
forall (l :: TxLevel).
Typeable l =>
TxBody l BabbageEra -> Encoding
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l BabbageEra] -> Size
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l BabbageEra) -> Size
$ctoCBOR :: forall (l :: TxLevel).
Typeable l =>
TxBody l BabbageEra -> Encoding
toCBOR :: TxBody l BabbageEra -> Encoding
$cencodedSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l BabbageEra) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l BabbageEra) -> Size
$cencodedListSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l BabbageEra] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l BabbageEra] -> Size
ToCBOR, TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
(TxBody l BabbageEra -> TxBody l BabbageEra -> Bool)
-> (TxBody l BabbageEra -> TxBody l BabbageEra -> Bool)
-> Eq (TxBody l BabbageEra)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (l :: TxLevel).
TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
$c== :: forall (l :: TxLevel).
TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
== :: TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
$c/= :: forall (l :: TxLevel).
TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
/= :: TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
Eq)

  mkBasicTxBody :: forall (l :: TxLevel). Typeable l => TxBody l BabbageEra
mkBasicTxBody = TxBody l BabbageEra
forall (l :: TxLevel). Typeable l => TxBody l BabbageEra
basicBabbageTxBody

  inputsTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l BabbageEra) (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 @BabbageEra (\BabbageTxBodyRaw {Set TxIn
btbrInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrInputs :: Set TxIn
btbrInputs} -> Set TxIn
btbrInputs) ((RawType (TxBody l BabbageEra)
  -> Set TxIn -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra) (TxBody l BabbageEra) (Set TxIn) (Set TxIn))
-> (RawType (TxBody l BabbageEra)
    -> Set TxIn -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra) (TxBody l BabbageEra) (Set TxIn) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw Set TxIn
inputs -> RawType (TxBody l BabbageEra)
txBodyRaw {btbrInputs = inputs}
  {-# INLINE inputsTxBodyL #-}

  outputsTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (StrictSeq (TxOut BabbageEra))
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 @BabbageEra ((Sized (BabbageTxOut BabbageEra) -> BabbageTxOut BabbageEra)
-> StrictSeq (Sized (BabbageTxOut BabbageEra))
-> StrictSeq (BabbageTxOut BabbageEra)
forall a b. (a -> b) -> StrictSeq a -> StrictSeq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Sized (BabbageTxOut BabbageEra) -> BabbageTxOut BabbageEra
forall a. Sized a -> a
sizedValue (StrictSeq (Sized (BabbageTxOut BabbageEra))
 -> StrictSeq (BabbageTxOut BabbageEra))
-> (BabbageTxBodyRaw l BabbageEra
    -> StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> BabbageTxBodyRaw l BabbageEra
-> StrictSeq (BabbageTxOut BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\BabbageTxBodyRaw {StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs} -> StrictSeq (Sized (TxOut BabbageEra))
StrictSeq (Sized (BabbageTxOut BabbageEra))
btbrOutputs)) ((RawType (TxBody l BabbageEra)
  -> StrictSeq (TxOut BabbageEra) -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictSeq (TxOut BabbageEra))
      (StrictSeq (TxOut BabbageEra)))
-> (RawType (TxBody l BabbageEra)
    -> StrictSeq (TxOut BabbageEra) -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictSeq (TxOut BabbageEra))
     (StrictSeq (TxOut BabbageEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictSeq (TxOut BabbageEra)
outputs ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrOutputs = mkSized (eraProtVerLow @BabbageEra) <$> outputs}
  {-# INLINE outputsTxBodyL #-}

  feeTxBodyL :: Lens' (TxBody TopTx BabbageEra) 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 @BabbageEra (\BabbageTxBodyRaw {Coin
btbrFee :: forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrFee :: Coin
btbrFee} -> Coin
btbrFee) ((RawType (TxBody TopTx BabbageEra)
  -> Coin -> RawType (TxBody TopTx BabbageEra))
 -> Lens' (TxBody TopTx BabbageEra) Coin)
-> (RawType (TxBody TopTx BabbageEra)
    -> Coin -> RawType (TxBody TopTx BabbageEra))
-> Lens' (TxBody TopTx BabbageEra) Coin
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw Coin
fee -> RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrFee = fee}
  {-# INLINE feeTxBodyL #-}

  auxDataHashTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (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 @BabbageEra (\BabbageTxBodyRaw {StrictMaybe TxAuxDataHash
btbrAuxDataHash :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrAuxDataHash :: StrictMaybe TxAuxDataHash
btbrAuxDataHash} -> StrictMaybe TxAuxDataHash
btbrAuxDataHash) ((RawType (TxBody l BabbageEra)
  -> StrictMaybe TxAuxDataHash -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictMaybe TxAuxDataHash)
      (StrictMaybe TxAuxDataHash))
-> (RawType (TxBody l BabbageEra)
    -> StrictMaybe TxAuxDataHash -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictMaybe TxAuxDataHash)
     (StrictMaybe TxAuxDataHash)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictMaybe TxAuxDataHash
auxDataHash ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrAuxDataHash = auxDataHash}
  {-# INLINE auxDataHashTxBodyL #-}

  spendableInputsTxBodyF :: forall (l :: TxLevel).
SimpleGetter (TxBody l BabbageEra) (Set TxIn)
spendableInputsTxBodyF = (TxBody l BabbageEra -> Set TxIn)
-> SimpleGetter (TxBody l BabbageEra) (Set TxIn)
forall s a. (s -> a) -> SimpleGetter s a
to (TxBody l BabbageEra
-> (TxBody TopTx BabbageEra -> Set TxIn) -> Set TxIn
forall (t :: TxLevel -> * -> *) era (l :: TxLevel) a.
(HasEraTxLevel t era, STxLevel l era ~ STxTopLevel l era) =>
t l era -> (t TopTx era -> a) -> a
`withTopTxLevelOnly` (TxBody TopTx BabbageEra
-> Getting (Set TxIn) (TxBody TopTx BabbageEra) (Set TxIn)
-> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody TopTx BabbageEra) (Set TxIn)
forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (Set TxIn)
SimpleGetter (TxBody TopTx BabbageEra) (Set TxIn)
babbageSpendableInputsTxBodyF))
  {-# INLINE spendableInputsTxBodyF #-}

  allInputsTxBodyF :: SimpleGetter (TxBody TopTx BabbageEra) (Set TxIn)
allInputsTxBodyF = Getting r (TxBody TopTx BabbageEra) (Set TxIn)
forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (Set TxIn)
SimpleGetter (TxBody TopTx BabbageEra) (Set TxIn)
babbageAllInputsTxBodyF
  {-# INLINE allInputsTxBodyF #-}

  withdrawalsTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l BabbageEra) 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 @BabbageEra (\BabbageTxBodyRaw {Withdrawals
btbrWithdrawals :: forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrWithdrawals :: Withdrawals
btbrWithdrawals} -> Withdrawals
btbrWithdrawals) ((RawType (TxBody l BabbageEra)
  -> Withdrawals -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      Withdrawals
      Withdrawals)
-> (RawType (TxBody l BabbageEra)
    -> Withdrawals -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra) (TxBody l BabbageEra) Withdrawals Withdrawals
forall a b. (a -> b) -> a -> b
$
      \RawType (TxBody l BabbageEra)
txBodyRaw Withdrawals
withdrawals -> RawType (TxBody l BabbageEra)
txBodyRaw {btbrWithdrawals = withdrawals}
  {-# INLINE withdrawalsTxBodyL #-}

  certsTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (StrictSeq (TxCert BabbageEra))
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 @BabbageEra (\BabbageTxBodyRaw {StrictSeq (TxCert BabbageEra)
btbrCerts :: forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrCerts :: StrictSeq (TxCert BabbageEra)
btbrCerts} -> StrictSeq (TxCert BabbageEra)
btbrCerts) ((RawType (TxBody l BabbageEra)
  -> StrictSeq (TxCert BabbageEra) -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictSeq (TxCert BabbageEra))
      (StrictSeq (TxCert BabbageEra)))
-> (RawType (TxBody l BabbageEra)
    -> StrictSeq (TxCert BabbageEra) -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictSeq (TxCert BabbageEra))
     (StrictSeq (TxCert BabbageEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictSeq (TxCert BabbageEra)
certs -> RawType (TxBody l BabbageEra)
txBodyRaw {btbrCerts = certs}
  {-# INLINE certsTxBodyL #-}

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

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

  updateTxBodyL :: Lens' (TxBody TopTx BabbageEra) (StrictMaybe (Update BabbageEra))
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 @BabbageEra RawType (TxBody TopTx BabbageEra)
-> StrictMaybe (Update BabbageEra)
BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (Update BabbageEra)
forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrUpdate ((RawType (TxBody TopTx BabbageEra)
  -> StrictMaybe (Update BabbageEra)
  -> RawType (TxBody TopTx BabbageEra))
 -> Lens'
      (TxBody TopTx BabbageEra) (StrictMaybe (Update BabbageEra)))
-> (RawType (TxBody TopTx BabbageEra)
    -> StrictMaybe (Update BabbageEra)
    -> RawType (TxBody TopTx BabbageEra))
-> Lens'
     (TxBody TopTx BabbageEra) (StrictMaybe (Update BabbageEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw StrictMaybe (Update BabbageEra)
update -> RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrUpdate = update}
  {-# INLINE updateTxBodyL #-}

instance AllegraEraTxBody BabbageEra where
  vldtTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l BabbageEra) 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 @BabbageEra (\BabbageTxBodyRaw {ValidityInterval
btbrValidityInterval :: forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrValidityInterval :: ValidityInterval
btbrValidityInterval} -> ValidityInterval
btbrValidityInterval) ((RawType (TxBody l BabbageEra)
  -> ValidityInterval -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      ValidityInterval
      ValidityInterval)
-> (RawType (TxBody l BabbageEra)
    -> ValidityInterval -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     ValidityInterval
     ValidityInterval
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw ValidityInterval
vldt ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrValidityInterval = vldt}
  {-# INLINE vldtTxBodyL #-}

instance MaryEraTxBody BabbageEra where
  mintTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l BabbageEra) 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 @BabbageEra (\BabbageTxBodyRaw {MultiAsset
btbrMint :: forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrMint :: MultiAsset
btbrMint} -> MultiAsset
btbrMint) ((RawType (TxBody l BabbageEra)
  -> MultiAsset -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra) (TxBody l BabbageEra) MultiAsset MultiAsset)
-> (RawType (TxBody l BabbageEra)
    -> MultiAsset -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra) (TxBody l BabbageEra) MultiAsset MultiAsset
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw MultiAsset
mint -> RawType (TxBody l BabbageEra)
txBodyRaw {btbrMint = mint}
  {-# INLINE mintTxBodyL #-}

instance AlonzoEraTxBody BabbageEra where
  collateralInputsTxBodyL :: Lens' (TxBody TopTx BabbageEra) (Set TxIn)
collateralInputsTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {Set TxIn
btbrCollateralInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs :: Set TxIn
btbrCollateralInputs} -> Set TxIn
btbrCollateralInputs) ((RawType (TxBody TopTx BabbageEra)
  -> Set TxIn -> RawType (TxBody TopTx BabbageEra))
 -> Lens' (TxBody TopTx BabbageEra) (Set TxIn))
-> (RawType (TxBody TopTx BabbageEra)
    -> Set TxIn -> RawType (TxBody TopTx BabbageEra))
-> Lens' (TxBody TopTx BabbageEra) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw Set TxIn
collateral ->
      RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrCollateralInputs = collateral}
  {-# INLINE collateralInputsTxBodyL #-}

  reqSignerHashesTxBodyL :: forall (l :: TxLevel).
AtMostEra "Conway" BabbageEra =>
Lens' (TxBody l BabbageEra) (Set (KeyHash Guard))
reqSignerHashesTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {Set (KeyHash Guard)
btbrReqSignerHashes :: forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrReqSignerHashes :: Set (KeyHash Guard)
btbrReqSignerHashes} -> Set (KeyHash Guard)
btbrReqSignerHashes) ((RawType (TxBody l BabbageEra)
  -> Set (KeyHash Guard) -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (Set (KeyHash Guard))
      (Set (KeyHash Guard)))
-> (RawType (TxBody l BabbageEra)
    -> Set (KeyHash Guard) -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (Set (KeyHash Guard))
     (Set (KeyHash Guard))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw Set (KeyHash Guard)
reqSignerHashes ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrReqSignerHashes = reqSignerHashes}
  {-# INLINE reqSignerHashesTxBodyL #-}

  scriptIntegrityHashTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (StrictMaybe ScriptIntegrityHash)
scriptIntegrityHashTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash} -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash) ((RawType (TxBody l BabbageEra)
  -> StrictMaybe ScriptIntegrityHash
  -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictMaybe ScriptIntegrityHash)
      (StrictMaybe ScriptIntegrityHash))
-> (RawType (TxBody l BabbageEra)
    -> StrictMaybe ScriptIntegrityHash
    -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictMaybe ScriptIntegrityHash)
     (StrictMaybe ScriptIntegrityHash)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictMaybe ScriptIntegrityHash
scriptIntegrityHash ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrScriptIntegrityHash = scriptIntegrityHash}
  {-# INLINE scriptIntegrityHashTxBodyL #-}

  networkIdTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (StrictMaybe Network)
networkIdTxBodyL = 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 @BabbageEra (\BabbageTxBodyRaw {StrictMaybe Network
btbrNetworkId :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrNetworkId :: StrictMaybe Network
btbrNetworkId} -> StrictMaybe Network
btbrNetworkId) ((RawType (TxBody l BabbageEra)
  -> StrictMaybe Network -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictMaybe Network)
      (StrictMaybe Network))
-> (RawType (TxBody l BabbageEra)
    -> StrictMaybe Network -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictMaybe Network)
     (StrictMaybe Network)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictMaybe Network
networkId ->
    RawType (TxBody l BabbageEra)
txBodyRaw {btbrNetworkId = networkId}
  {-# INLINE networkIdTxBodyL #-}

  redeemerPointer :: forall (l :: TxLevel).
TxBody l BabbageEra
-> PlutusPurpose AsItem BabbageEra
-> StrictMaybe (PlutusPurpose AsIx BabbageEra)
redeemerPointer = TxBody l BabbageEra
-> AlonzoPlutusPurpose AsItem BabbageEra
-> StrictMaybe (AlonzoPlutusPurpose AsIx BabbageEra)
TxBody l BabbageEra
-> PlutusPurpose AsItem BabbageEra
-> StrictMaybe (PlutusPurpose AsIx BabbageEra)
forall era (l :: TxLevel).
MaryEraTxBody era =>
TxBody l era
-> AlonzoPlutusPurpose AsItem era
-> StrictMaybe (AlonzoPlutusPurpose AsIx era)
alonzoRedeemerPointer

  redeemerPointerInverse :: forall (l :: TxLevel).
TxBody l BabbageEra
-> PlutusPurpose AsIx BabbageEra
-> StrictMaybe (PlutusPurpose AsIxItem BabbageEra)
redeemerPointerInverse = TxBody l BabbageEra
-> AlonzoPlutusPurpose AsIx BabbageEra
-> StrictMaybe (AlonzoPlutusPurpose AsIxItem BabbageEra)
TxBody l BabbageEra
-> PlutusPurpose AsIx BabbageEra
-> StrictMaybe (PlutusPurpose AsIxItem BabbageEra)
forall era (l :: TxLevel).
MaryEraTxBody era =>
TxBody l era
-> AlonzoPlutusPurpose AsIx era
-> StrictMaybe (AlonzoPlutusPurpose AsIxItem era)
alonzoRedeemerPointerInverse

instance BabbageEraTxBody BabbageEra where
  sizedOutputsTxBodyL :: forall (l :: TxLevel).
Lens' (TxBody l BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
sizedOutputsTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs} -> StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs) ((RawType (TxBody l BabbageEra)
  -> StrictSeq (Sized (TxOut BabbageEra))
  -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra)
      (TxBody l BabbageEra)
      (StrictSeq (Sized (TxOut BabbageEra)))
      (StrictSeq (Sized (TxOut BabbageEra))))
-> (RawType (TxBody l BabbageEra)
    -> StrictSeq (Sized (TxOut BabbageEra))
    -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra)
     (TxBody l BabbageEra)
     (StrictSeq (Sized (TxOut BabbageEra)))
     (StrictSeq (Sized (TxOut BabbageEra)))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw StrictSeq (Sized (TxOut BabbageEra))
outputs -> RawType (TxBody l BabbageEra)
txBodyRaw {btbrOutputs = outputs}
  {-# INLINE sizedOutputsTxBodyL #-}

  referenceInputsTxBodyL :: forall (l :: TxLevel). Lens' (TxBody l BabbageEra) (Set TxIn)
referenceInputsTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {Set TxIn
btbrReferenceInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs :: Set TxIn
btbrReferenceInputs} -> Set TxIn
btbrReferenceInputs) ((RawType (TxBody l BabbageEra)
  -> Set TxIn -> RawType (TxBody l BabbageEra))
 -> Lens
      (TxBody l BabbageEra) (TxBody l BabbageEra) (Set TxIn) (Set TxIn))
-> (RawType (TxBody l BabbageEra)
    -> Set TxIn -> RawType (TxBody l BabbageEra))
-> Lens
     (TxBody l BabbageEra) (TxBody l BabbageEra) (Set TxIn) (Set TxIn)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody l BabbageEra)
txBodyRaw Set TxIn
reference ->
      RawType (TxBody l BabbageEra)
txBodyRaw {btbrReferenceInputs = reference}
  {-# INLINE referenceInputsTxBodyL #-}

  totalCollateralTxBodyL :: Lens' (TxBody TopTx BabbageEra) (StrictMaybe Coin)
totalCollateralTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {StrictMaybe Coin
btbrTotalCollateral :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrTotalCollateral :: StrictMaybe Coin
btbrTotalCollateral} -> StrictMaybe Coin
btbrTotalCollateral) ((RawType (TxBody TopTx BabbageEra)
  -> StrictMaybe Coin -> RawType (TxBody TopTx BabbageEra))
 -> Lens' (TxBody TopTx BabbageEra) (StrictMaybe Coin))
-> (RawType (TxBody TopTx BabbageEra)
    -> StrictMaybe Coin -> RawType (TxBody TopTx BabbageEra))
-> Lens' (TxBody TopTx BabbageEra) (StrictMaybe Coin)
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw StrictMaybe Coin
totalCollateral ->
      RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrTotalCollateral = totalCollateral}
  {-# INLINE totalCollateralTxBodyL #-}

  collateralReturnTxBodyL :: Lens' (TxBody TopTx BabbageEra) (StrictMaybe (TxOut BabbageEra))
collateralReturnTxBodyL =
    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 @BabbageEra
      ((Sized (BabbageTxOut BabbageEra) -> BabbageTxOut BabbageEra)
-> StrictMaybe (Sized (BabbageTxOut BabbageEra))
-> StrictMaybe (BabbageTxOut BabbageEra)
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Sized (BabbageTxOut BabbageEra) -> BabbageTxOut BabbageEra
forall a. Sized a -> a
sizedValue (StrictMaybe (Sized (BabbageTxOut BabbageEra))
 -> StrictMaybe (BabbageTxOut BabbageEra))
-> (BabbageTxBodyRaw TopTx BabbageEra
    -> StrictMaybe (Sized (BabbageTxOut BabbageEra)))
-> BabbageTxBodyRaw TopTx BabbageEra
-> StrictMaybe (BabbageTxOut BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\BabbageTxBodyRaw {StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn} -> StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
btbrCollateralReturn))
      ((RawType (TxBody TopTx BabbageEra)
  -> StrictMaybe (TxOut BabbageEra)
  -> RawType (TxBody TopTx BabbageEra))
 -> Lens'
      (TxBody TopTx BabbageEra) (StrictMaybe (TxOut BabbageEra)))
-> (RawType (TxBody TopTx BabbageEra)
    -> StrictMaybe (TxOut BabbageEra)
    -> RawType (TxBody TopTx BabbageEra))
-> Lens' (TxBody TopTx BabbageEra) (StrictMaybe (TxOut BabbageEra))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw StrictMaybe (TxOut BabbageEra)
collateralReturn ->
        RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrCollateralReturn = mkSized (eraProtVerLow @BabbageEra) <$> collateralReturn}
  {-# INLINE collateralReturnTxBodyL #-}

  sizedCollateralReturnTxBodyL :: Lens'
  (TxBody TopTx BabbageEra) (StrictMaybe (Sized (TxOut BabbageEra)))
sizedCollateralReturnTxBodyL =
    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 @BabbageEra (\BabbageTxBodyRaw {StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn} -> StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn) ((RawType (TxBody TopTx BabbageEra)
  -> StrictMaybe (Sized (TxOut BabbageEra))
  -> RawType (TxBody TopTx BabbageEra))
 -> Lens'
      (TxBody TopTx BabbageEra) (StrictMaybe (Sized (TxOut BabbageEra))))
-> (RawType (TxBody TopTx BabbageEra)
    -> StrictMaybe (Sized (TxOut BabbageEra))
    -> RawType (TxBody TopTx BabbageEra))
-> Lens'
     (TxBody TopTx BabbageEra) (StrictMaybe (Sized (TxOut BabbageEra)))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx BabbageEra)
txBodyRaw StrictMaybe (Sized (TxOut BabbageEra))
collateralReturn ->
      RawType (TxBody TopTx BabbageEra)
txBodyRaw {btbrCollateralReturn = collateralReturn}
  {-# INLINE sizedCollateralReturnTxBodyL #-}

  allSizedOutputsTxBodyF :: forall (l :: TxLevel).
SimpleGetter
  (TxBody l BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
allSizedOutputsTxBodyF = (TxBody l BabbageEra
 -> StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> SimpleGetter
     (TxBody l BabbageEra) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall s a. (s -> a) -> SimpleGetter s a
to (TxBody l BabbageEra
-> (TxBody TopTx BabbageEra
    -> StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> StrictSeq (Sized (BabbageTxOut BabbageEra))
forall (t :: TxLevel -> * -> *) era (l :: TxLevel) a.
(HasEraTxLevel t era, STxLevel l era ~ STxTopLevel l era) =>
t l era -> (t TopTx era -> a) -> a
`withTopTxLevelOnly` (TxBody TopTx BabbageEra
-> Getting
     (StrictSeq (Sized (BabbageTxOut BabbageEra)))
     (TxBody TopTx BabbageEra)
     (StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> StrictSeq (Sized (BabbageTxOut BabbageEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (Sized (BabbageTxOut BabbageEra)))
  (TxBody TopTx BabbageEra)
  (StrictSeq (Sized (TxOut BabbageEra)))
Getting
  (StrictSeq (Sized (BabbageTxOut BabbageEra)))
  (TxBody TopTx BabbageEra)
  (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody TopTx era) (StrictSeq (Sized (TxOut era)))
SimpleGetter
  (TxBody TopTx BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
allSizedOutputsBabbageTxBodyF))
  {-# INLINE allSizedOutputsTxBodyF #-}

instance EqRaw (TxBody l BabbageEra) where
  eqRaw :: TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
eqRaw = (RawType (TxBody l BabbageEra)
 -> RawType (TxBody l BabbageEra) -> Bool)
-> TxBody l BabbageEra -> TxBody l BabbageEra -> Bool
forall t1 t2 a.
(Memoized t1, Memoized t2) =>
(RawType t1 -> RawType t2 -> a) -> t1 -> t2 -> a
zipMemoRawType RawType (TxBody l BabbageEra)
-> RawType (TxBody l BabbageEra) -> Bool
BabbageTxBodyRaw l BabbageEra
-> BabbageTxBodyRaw l BabbageEra -> Bool
forall a. EqRaw a => a -> a -> Bool
eqRaw

deriving instance Typeable l => NoThunks (TxBody l BabbageEra)

deriving instance Show (TxBody l BabbageEra)

pattern BabbageTxBody ::
  Set TxIn ->
  Set TxIn ->
  Set TxIn ->
  StrictSeq (Sized (TxOut BabbageEra)) ->
  StrictMaybe (Sized (TxOut BabbageEra)) ->
  StrictMaybe Coin ->
  StrictSeq (TxCert BabbageEra) ->
  Withdrawals ->
  Coin ->
  ValidityInterval ->
  StrictMaybe (Update BabbageEra) ->
  Set (KeyHash Guard) ->
  MultiAsset ->
  StrictMaybe ScriptIntegrityHash ->
  StrictMaybe TxAuxDataHash ->
  StrictMaybe Network ->
  TxBody TopTx BabbageEra
pattern $mBabbageTxBody :: forall {r}.
TxBody TopTx BabbageEra
-> (Set TxIn
    -> Set TxIn
    -> Set TxIn
    -> StrictSeq (Sized (TxOut BabbageEra))
    -> StrictMaybe (Sized (TxOut BabbageEra))
    -> StrictMaybe Coin
    -> StrictSeq (TxCert BabbageEra)
    -> Withdrawals
    -> Coin
    -> ValidityInterval
    -> StrictMaybe (Update BabbageEra)
    -> Set (KeyHash Guard)
    -> MultiAsset
    -> StrictMaybe ScriptIntegrityHash
    -> StrictMaybe TxAuxDataHash
    -> StrictMaybe Network
    -> r)
-> ((# #) -> r)
-> r
$bBabbageTxBody :: Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut BabbageEra))
-> StrictMaybe (Sized (TxOut BabbageEra))
-> StrictMaybe Coin
-> StrictSeq (TxCert BabbageEra)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update BabbageEra)
-> Set (KeyHash Guard)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> TxBody TopTx BabbageEra
BabbageTxBody
  { TxBody TopTx BabbageEra -> Set TxIn
btbInputs
  , TxBody TopTx BabbageEra -> Set TxIn
btbCollateral
  , TxBody TopTx BabbageEra -> Set TxIn
btbReferenceInputs
  , TxBody TopTx BabbageEra -> StrictSeq (Sized (TxOut BabbageEra))
btbOutputs
  , TxBody TopTx BabbageEra -> StrictMaybe (Sized (TxOut BabbageEra))
btbCollateralReturn
  , TxBody TopTx BabbageEra -> StrictMaybe Coin
btbTotalCollateral
  , TxBody TopTx BabbageEra -> StrictSeq (TxCert BabbageEra)
btbCerts
  , TxBody TopTx BabbageEra -> Withdrawals
btbWithdrawals
  , TxBody TopTx BabbageEra -> Coin
btbTxFee
  , TxBody TopTx BabbageEra -> ValidityInterval
btbValidityInterval
  , TxBody TopTx BabbageEra -> StrictMaybe (Update BabbageEra)
btbUpdate
  , TxBody TopTx BabbageEra -> Set (KeyHash Guard)
btbReqSignerHashes
  , TxBody TopTx BabbageEra -> MultiAsset
btbMint
  , TxBody TopTx BabbageEra -> StrictMaybe ScriptIntegrityHash
btbScriptIntegrityHash
  , TxBody TopTx BabbageEra -> StrictMaybe TxAuxDataHash
btbAuxDataHash
  , TxBody TopTx BabbageEra -> StrictMaybe Network
btbTxNetworkId
  } <-
  ( getMemoRawType ->
      BabbageTxBodyRaw
        { btbrInputs = btbInputs
        , btbrCollateralInputs = btbCollateral
        , btbrReferenceInputs = btbReferenceInputs
        , btbrOutputs = btbOutputs
        , btbrCollateralReturn = btbCollateralReturn
        , btbrTotalCollateral = btbTotalCollateral
        , btbrCerts = btbCerts
        , btbrWithdrawals = btbWithdrawals
        , btbrFee = btbTxFee
        , btbrValidityInterval = btbValidityInterval
        , btbrUpdate = btbUpdate
        , btbrReqSignerHashes = btbReqSignerHashes
        , btbrMint = btbMint
        , btbrScriptIntegrityHash = btbScriptIntegrityHash
        , btbrAuxDataHash = btbAuxDataHash
        , btbrNetworkId = btbTxNetworkId
        }
    )
  where
    BabbageTxBody
      Set TxIn
inputs
      Set TxIn
collateral
      Set TxIn
referenceInputs
      StrictSeq (Sized (TxOut BabbageEra))
outputs
      StrictMaybe (Sized (TxOut BabbageEra))
collateralReturn
      StrictMaybe Coin
totalCollateral
      StrictSeq (TxCert BabbageEra)
certs
      Withdrawals
withdrawals
      Coin
txFee
      ValidityInterval
validityInterval
      StrictMaybe (Update BabbageEra)
update
      Set (KeyHash Guard)
reqSignerHashes
      MultiAsset
mint
      StrictMaybe ScriptIntegrityHash
scriptIntegrityHash
      StrictMaybe TxAuxDataHash
auxDataHash
      StrictMaybe Network
txNetworkId =
        forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @BabbageEra (RawType (TxBody TopTx BabbageEra) -> TxBody TopTx BabbageEra)
-> RawType (TxBody TopTx BabbageEra) -> TxBody TopTx BabbageEra
forall a b. (a -> b) -> a -> b
$
          BabbageTxBodyRaw
            { btbrInputs :: Set TxIn
btbrInputs = Set TxIn
inputs
            , btbrCollateralInputs :: Set TxIn
btbrCollateralInputs = Set TxIn
collateral
            , btbrReferenceInputs :: Set TxIn
btbrReferenceInputs = Set TxIn
referenceInputs
            , btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs = StrictSeq (Sized (TxOut BabbageEra))
outputs
            , btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn = StrictMaybe (Sized (TxOut BabbageEra))
collateralReturn
            , btbrTotalCollateral :: StrictMaybe Coin
btbrTotalCollateral = StrictMaybe Coin
totalCollateral
            , btbrCerts :: StrictSeq (TxCert BabbageEra)
btbrCerts = StrictSeq (TxCert BabbageEra)
certs
            , btbrWithdrawals :: Withdrawals
btbrWithdrawals = Withdrawals
withdrawals
            , btbrFee :: Coin
btbrFee = Coin
txFee
            , btbrValidityInterval :: ValidityInterval
btbrValidityInterval = ValidityInterval
validityInterval
            , btbrUpdate :: StrictMaybe (Update BabbageEra)
btbrUpdate = StrictMaybe (Update BabbageEra)
update
            , btbrReqSignerHashes :: Set (KeyHash Guard)
btbrReqSignerHashes = Set (KeyHash Guard)
reqSignerHashes
            , btbrMint :: MultiAsset
btbrMint = MultiAsset
mint
            , btbrScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash = StrictMaybe ScriptIntegrityHash
scriptIntegrityHash
            , btbrAuxDataHash :: StrictMaybe TxAuxDataHash
btbrAuxDataHash = StrictMaybe TxAuxDataHash
auxDataHash
            , btbrNetworkId :: StrictMaybe Network
btbrNetworkId = StrictMaybe Network
txNetworkId
            }

{-# COMPLETE BabbageTxBody #-}

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

--------------------------------------------------------------------------------
-- Serialisation
--------------------------------------------------------------------------------

-- | Encodes memoized bytes created upon construction.
deriving newtype instance EncCBOR (TxBody l BabbageEra)

instance EncCBOR (BabbageTxBodyRaw l BabbageEra) where
  encCBOR :: BabbageTxBodyRaw l BabbageEra -> Encoding
encCBOR
    BabbageTxBodyRaw
      { Set TxIn
btbrInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrInputs :: Set TxIn
btbrInputs
      , Set TxIn
btbrCollateralInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrCollateralInputs :: Set TxIn
btbrCollateralInputs
      , Set TxIn
btbrReferenceInputs :: forall era. BabbageTxBodyRaw TopTx era -> Set TxIn
btbrReferenceInputs :: Set TxIn
btbrReferenceInputs
      , StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: forall era.
BabbageTxBodyRaw TopTx era -> StrictSeq (Sized (TxOut era))
btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs
      , StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe (Sized (TxOut era))
btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn
      , StrictMaybe Coin
btbrTotalCollateral :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Coin
btbrTotalCollateral :: StrictMaybe Coin
btbrTotalCollateral
      , StrictSeq (TxCert BabbageEra)
btbrCerts :: forall era. BabbageTxBodyRaw TopTx era -> StrictSeq (TxCert era)
btbrCerts :: StrictSeq (TxCert BabbageEra)
btbrCerts
      , Withdrawals
btbrWithdrawals :: forall era. BabbageTxBodyRaw TopTx era -> Withdrawals
btbrWithdrawals :: Withdrawals
btbrWithdrawals
      , Coin
btbrFee :: forall era. BabbageTxBodyRaw TopTx era -> Coin
btbrFee :: Coin
btbrFee
      , btbrValidityInterval :: forall era. BabbageTxBodyRaw TopTx era -> ValidityInterval
btbrValidityInterval = ValidityInterval StrictMaybe SlotNo
bot StrictMaybe SlotNo
top
      , StrictMaybe (Update BabbageEra)
btbrUpdate :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe (Update era)
btbrUpdate :: StrictMaybe (Update BabbageEra)
btbrUpdate
      , Set (KeyHash Guard)
btbrReqSignerHashes :: forall era. BabbageTxBodyRaw TopTx era -> Set (KeyHash Guard)
btbrReqSignerHashes :: Set (KeyHash Guard)
btbrReqSignerHashes
      , MultiAsset
btbrMint :: forall era. BabbageTxBodyRaw TopTx era -> MultiAsset
btbrMint :: MultiAsset
btbrMint
      , StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: forall era.
BabbageTxBodyRaw TopTx era -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash
      , StrictMaybe TxAuxDataHash
btbrAuxDataHash :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
btbrAuxDataHash :: StrictMaybe TxAuxDataHash
btbrAuxDataHash
      , StrictMaybe Network
btbrNetworkId :: forall era. BabbageTxBodyRaw TopTx era -> StrictMaybe Network
btbrNetworkId :: StrictMaybe Network
btbrNetworkId
      } =
      Encode (Closed Sparse) (BabbageTxBodyRaw TopTx BabbageEra)
-> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode (Closed Sparse) (BabbageTxBodyRaw TopTx BabbageEra)
 -> Encoding)
-> Encode (Closed Sparse) (BabbageTxBodyRaw TopTx BabbageEra)
-> Encoding
forall a b. (a -> b) -> a -> b
$
        (Set TxIn
 -> Set TxIn
 -> Set TxIn
 -> StrictSeq (Sized (BabbageTxOut BabbageEra))
 -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
 -> StrictMaybe Coin
 -> Coin
 -> StrictMaybe SlotNo
 -> StrictSeq (ShelleyTxCert BabbageEra)
 -> Withdrawals
 -> StrictMaybe (Update BabbageEra)
 -> StrictMaybe SlotNo
 -> Set (KeyHash Guard)
 -> MultiAsset
 -> StrictMaybe ScriptIntegrityHash
 -> StrictMaybe TxAuxDataHash
 -> StrictMaybe Network
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode
     (Closed Sparse)
     (Set TxIn
      -> Set TxIn
      -> Set TxIn
      -> StrictSeq (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall t. t -> Encode (Closed Sparse) t
Keyed
          ( \Set TxIn
i Set TxIn
ifee Set TxIn
ri StrictSeq (Sized (BabbageTxOut BabbageEra))
o StrictMaybe (Sized (BabbageTxOut BabbageEra))
cr StrictMaybe Coin
tc Coin
f StrictMaybe SlotNo
t StrictSeq (ShelleyTxCert BabbageEra)
c Withdrawals
w StrictMaybe (Update BabbageEra)
u StrictMaybe SlotNo
b Set (KeyHash Guard)
rsh MultiAsset
mi StrictMaybe ScriptIntegrityHash
sh StrictMaybe TxAuxDataHash
ah StrictMaybe Network
ni ->
              Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut BabbageEra))
-> StrictMaybe (Sized (TxOut BabbageEra))
-> StrictMaybe Coin
-> StrictSeq (TxCert BabbageEra)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update BabbageEra)
-> Set (KeyHash Guard)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw TopTx BabbageEra
forall era.
Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut era))
-> StrictMaybe (Sized (TxOut era))
-> StrictMaybe Coin
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> Set (KeyHash Guard)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw TopTx era
BabbageTxBodyRaw Set TxIn
i Set TxIn
ifee Set TxIn
ri StrictSeq (Sized (TxOut BabbageEra))
StrictSeq (Sized (BabbageTxOut BabbageEra))
o StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
cr StrictMaybe Coin
tc StrictSeq (TxCert BabbageEra)
StrictSeq (ShelleyTxCert BabbageEra)
c Withdrawals
w Coin
f (StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
b StrictMaybe SlotNo
t) StrictMaybe (Update BabbageEra)
u Set (KeyHash Guard)
rsh MultiAsset
mi StrictMaybe ScriptIntegrityHash
sh StrictMaybe TxAuxDataHash
ah StrictMaybe Network
ni
          )
          Encode
  (Closed Sparse)
  (Set TxIn
   -> Set TxIn
   -> Set TxIn
   -> StrictSeq (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode
     (Closed Sparse)
     (Set TxIn
      -> Set TxIn
      -> StrictSeq (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> Encode (Closed Dense) (Set TxIn)
-> Encode (Closed Sparse) (Set TxIn)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
0 (Set TxIn -> Encode (Closed Dense) (Set TxIn)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set TxIn
btbrInputs)
          Encode
  (Closed Sparse)
  (Set TxIn
   -> Set TxIn
   -> StrictSeq (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode
     (Closed Sparse)
     (Set TxIn
      -> StrictSeq (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Set TxIn -> Bool)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode (Closed Sparse) (Set TxIn)
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Set TxIn -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Set TxIn)
-> Encode (Closed Sparse) (Set TxIn)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
13 (Set TxIn -> Encode (Closed Dense) (Set TxIn)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set TxIn
btbrCollateralInputs))
          Encode
  (Closed Sparse)
  (Set TxIn
   -> StrictSeq (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode
     (Closed Sparse)
     (StrictSeq (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Set TxIn -> Bool)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode (Closed Sparse) (Set TxIn)
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Set TxIn -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Set TxIn)
-> Encode (Closed Sparse) (Set TxIn)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
18 (Set TxIn -> Encode (Closed Dense) (Set TxIn)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set TxIn
btbrReferenceInputs))
          Encode
  (Closed Sparse)
  (StrictSeq (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode
     (Closed Sparse) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> Encode
     (Closed Sparse)
     (StrictMaybe (Sized (BabbageTxOut BabbageEra))
      -> StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> Encode
     (Closed Dense) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> Encode
     (Closed Sparse) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
1 (StrictSeq (Sized (BabbageTxOut BabbageEra))
-> Encode
     (Closed Dense) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To StrictSeq (Sized (TxOut BabbageEra))
StrictSeq (Sized (BabbageTxOut BabbageEra))
btbrOutputs)
          Encode
  (Closed Sparse)
  (StrictMaybe (Sized (BabbageTxOut BabbageEra))
   -> StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode
     (Closed Sparse) (StrictMaybe (Sized (BabbageTxOut BabbageEra)))
-> Encode
     (Closed Sparse)
     (StrictMaybe Coin
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe (Sized (BabbageTxOut BabbageEra))
-> Encode
     (Closed Sparse) (StrictMaybe (Sized (BabbageTxOut BabbageEra)))
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
16 StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
btbrCollateralReturn
          Encode
  (Closed Sparse)
  (StrictMaybe Coin
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe Coin)
-> Encode
     (Closed Sparse)
     (Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe Coin -> Encode (Closed Sparse) (StrictMaybe Coin)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
17 StrictMaybe Coin
btbrTotalCollateral
          Encode
  (Closed Sparse)
  (Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) Coin
-> Encode
     (Closed Sparse)
     (StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word -> Encode (Closed Dense) Coin -> Encode (Closed Sparse) Coin
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
2 (Coin -> Encode (Closed Dense) Coin
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Coin
btbrFee)
          Encode
  (Closed Sparse)
  (StrictMaybe SlotNo
   -> StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
-> Encode
     (Closed Sparse)
     (StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe SlotNo
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
3 StrictMaybe SlotNo
top
          Encode
  (Closed Sparse)
  (StrictSeq (ShelleyTxCert BabbageEra)
   -> Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictSeq (ShelleyTxCert BabbageEra))
-> Encode
     (Closed Sparse)
     (Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (StrictSeq (ShelleyTxCert BabbageEra) -> Bool)
-> Encode (Closed Sparse) (StrictSeq (ShelleyTxCert BabbageEra))
-> Encode (Closed Sparse) (StrictSeq (ShelleyTxCert BabbageEra))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit StrictSeq (ShelleyTxCert BabbageEra) -> Bool
forall a. StrictSeq a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (StrictSeq (ShelleyTxCert BabbageEra))
-> Encode (Closed Sparse) (StrictSeq (ShelleyTxCert BabbageEra))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
4 (StrictSeq (ShelleyTxCert BabbageEra)
-> Encode (Closed Dense) (StrictSeq (ShelleyTxCert BabbageEra))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To StrictSeq (TxCert BabbageEra)
StrictSeq (ShelleyTxCert BabbageEra)
btbrCerts))
          Encode
  (Closed Sparse)
  (Withdrawals
   -> StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) Withdrawals
-> Encode
     (Closed Sparse)
     (StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Withdrawals -> Bool)
-> Encode (Closed Sparse) Withdrawals
-> Encode (Closed Sparse) Withdrawals
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit (Map RewardAccount Coin -> Bool
forall a. Map RewardAccount a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Map RewardAccount Coin -> Bool)
-> (Withdrawals -> Map RewardAccount Coin) -> Withdrawals -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Withdrawals -> Map RewardAccount Coin
unWithdrawals) (Word
-> Encode (Closed Dense) Withdrawals
-> Encode (Closed Sparse) Withdrawals
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
5 (Withdrawals -> Encode (Closed Dense) Withdrawals
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Withdrawals
btbrWithdrawals))
          Encode
  (Closed Sparse)
  (StrictMaybe (Update BabbageEra)
   -> StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe (Update BabbageEra))
-> Encode
     (Closed Sparse)
     (StrictMaybe SlotNo
      -> Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe (Update BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe (Update BabbageEra))
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
6 StrictMaybe (Update BabbageEra)
btbrUpdate
          Encode
  (Closed Sparse)
  (StrictMaybe SlotNo
   -> Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
-> Encode
     (Closed Sparse)
     (Set (KeyHash Guard)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe SlotNo
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
8 StrictMaybe SlotNo
bot
          Encode
  (Closed Sparse)
  (Set (KeyHash Guard)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (Set (KeyHash Guard))
-> Encode
     (Closed Sparse)
     (MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Set (KeyHash Guard) -> Bool)
-> Encode (Closed Sparse) (Set (KeyHash Guard))
-> Encode (Closed Sparse) (Set (KeyHash Guard))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Set (KeyHash Guard) -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Set (KeyHash Guard))
-> Encode (Closed Sparse) (Set (KeyHash Guard))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
14 (Set (KeyHash Guard) -> Encode (Closed Dense) (Set (KeyHash Guard))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set (KeyHash Guard)
btbrReqSignerHashes))
          Encode
  (Closed Sparse)
  (MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) MultiAsset
-> Encode
     (Closed Sparse)
     (StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (MultiAsset -> Bool)
-> Encode (Closed Sparse) MultiAsset
-> Encode (Closed Sparse) MultiAsset
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit (MultiAsset -> MultiAsset -> Bool
forall a. Eq a => a -> a -> Bool
== MultiAsset
forall a. Monoid a => a
mempty) (Word
-> Encode (Closed Dense) MultiAsset
-> Encode (Closed Sparse) MultiAsset
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
9 (MultiAsset -> Encode (Closed Dense) MultiAsset
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To MultiAsset
btbrMint))
          Encode
  (Closed Sparse)
  (StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe ScriptIntegrityHash)
-> Encode
     (Closed Sparse)
     (StrictMaybe TxAuxDataHash
      -> StrictMaybe Network -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe ScriptIntegrityHash
-> Encode (Closed Sparse) (StrictMaybe ScriptIntegrityHash)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
11 StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash
          Encode
  (Closed Sparse)
  (StrictMaybe TxAuxDataHash
   -> StrictMaybe Network -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe TxAuxDataHash)
-> Encode
     (Closed Sparse)
     (StrictMaybe Network -> BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe TxAuxDataHash
-> Encode (Closed Sparse) (StrictMaybe TxAuxDataHash)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
7 StrictMaybe TxAuxDataHash
btbrAuxDataHash
          Encode
  (Closed Sparse)
  (StrictMaybe Network -> BabbageTxBodyRaw TopTx BabbageEra)
-> Encode (Closed Sparse) (StrictMaybe Network)
-> Encode (Closed Sparse) (BabbageTxBodyRaw TopTx BabbageEra)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe Network
-> Encode (Closed Sparse) (StrictMaybe Network)
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
15 StrictMaybe Network
btbrNetworkId

instance Typeable l => DecCBOR (BabbageTxBodyRaw l BabbageEra) where
  decCBOR :: forall s. Decoder s (BabbageTxBodyRaw l BabbageEra)
decCBOR =
    (BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw l BabbageEra)
-> Decoder s (BabbageTxBodyRaw TopTx BabbageEra)
-> Decoder s (BabbageTxBodyRaw l BabbageEra)
forall a b. (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BabbageTxBodyRaw TopTx BabbageEra -> BabbageTxBodyRaw l BabbageEra
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel (Decoder s (BabbageTxBodyRaw TopTx BabbageEra)
 -> Decoder s (BabbageTxBodyRaw l BabbageEra))
-> (Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
    -> Decoder s (BabbageTxBodyRaw TopTx BabbageEra))
-> Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
-> Decoder s (BabbageTxBodyRaw l BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
-> Decoder s (BabbageTxBodyRaw TopTx BabbageEra)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
 -> Decoder s (BabbageTxBodyRaw l BabbageEra))
-> Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
-> Decoder s (BabbageTxBodyRaw l BabbageEra)
forall a b. (a -> b) -> a -> b
$
      String
-> BabbageTxBodyRaw TopTx BabbageEra
-> (Word -> Field (BabbageTxBodyRaw TopTx BabbageEra))
-> [(Word, String)]
-> Decode (Closed Dense) (BabbageTxBodyRaw TopTx BabbageEra)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode (Closed Dense) t
SparseKeyed
        String
"BabbageTxBodyRaw"
        (BabbageTxBodyRaw TopTx BabbageEra
-> BabbageTxBodyRaw TopTx BabbageEra
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel BabbageTxBodyRaw TopTx BabbageEra
forall era. BabbageTxBodyRaw TopTx era
basicBabbageTxBodyRaw)
        Word -> Field (BabbageTxBodyRaw TopTx BabbageEra)
bodyFields
        [(Word, String)]
requiredFields
    where
      bodyFields :: Word -> Field (BabbageTxBodyRaw TopTx BabbageEra)
      bodyFields :: Word -> Field (BabbageTxBodyRaw TopTx BabbageEra)
bodyFields Word
0 = (Set TxIn
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 0)) (Set TxIn)
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrInputs = x}) Decode (Closed (ZonkAny 0)) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
13 = (Set TxIn
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 1)) (Set TxIn)
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrCollateralInputs = x}) Decode (Closed (ZonkAny 1)) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
18 = (Set TxIn
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 2)) (Set TxIn)
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrReferenceInputs = x}) Decode (Closed (ZonkAny 2)) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
1 = (StrictSeq (Sized (BabbageTxOut BabbageEra))
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode
     (Closed (ZonkAny 3)) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (Sized (BabbageTxOut BabbageEra))
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrOutputs = x}) Decode
  (Closed (ZonkAny 3)) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
16 = (StrictMaybe (Sized (BabbageTxOut BabbageEra))
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 4)) (Sized (BabbageTxOut BabbageEra))
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe (Sized (BabbageTxOut BabbageEra))
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrCollateralReturn = x}) Decode (Closed (ZonkAny 4)) (Sized (BabbageTxOut BabbageEra))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
17 = (StrictMaybe Coin
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 5)) Coin
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe Coin
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrTotalCollateral = x}) Decode (Closed (ZonkAny 5)) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
2 = (Coin
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 6)) Coin
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Coin
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrFee = x}) Decode (Closed (ZonkAny 6)) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
3 =
        (StrictMaybe SlotNo
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 7)) SlotNo
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield
          (\StrictMaybe SlotNo
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrValidityInterval = (btbrValidityInterval tx) {invalidHereafter = x}})
          Decode (Closed (ZonkAny 7)) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
4 = (StrictSeq (ShelleyTxCert BabbageEra)
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode
     (Closed (ZonkAny 8)) (StrictSeq (ShelleyTxCert BabbageEra))
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (ShelleyTxCert BabbageEra)
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrCerts = x}) Decode (Closed (ZonkAny 8)) (StrictSeq (ShelleyTxCert BabbageEra))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
5 = (Withdrawals
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 9)) Withdrawals
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Withdrawals
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrWithdrawals = x}) Decode (Closed (ZonkAny 9)) Withdrawals
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
6 = (StrictMaybe (Update BabbageEra)
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 10)) (Update BabbageEra)
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe (Update BabbageEra)
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrUpdate = x}) Decode (Closed (ZonkAny 10)) (Update BabbageEra)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
7 = (StrictMaybe TxAuxDataHash
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 11)) TxAuxDataHash
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe TxAuxDataHash
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrAuxDataHash = x}) Decode (Closed (ZonkAny 11)) TxAuxDataHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
8 =
        (StrictMaybe SlotNo
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 12)) SlotNo
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield
          (\StrictMaybe SlotNo
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrValidityInterval = (btbrValidityInterval tx) {invalidBefore = x}})
          Decode (Closed (ZonkAny 12)) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
9 = (MultiAsset
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 13)) MultiAsset
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\MultiAsset
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrMint = x}) Decode (Closed (ZonkAny 13)) MultiAsset
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
11 = (StrictMaybe ScriptIntegrityHash
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 14)) ScriptIntegrityHash
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe ScriptIntegrityHash
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrScriptIntegrityHash = x}) Decode (Closed (ZonkAny 14)) ScriptIntegrityHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
14 = (Set (KeyHash Guard)
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 15)) (Set (KeyHash Guard))
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set (KeyHash Guard)
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrReqSignerHashes = x}) Decode (Closed (ZonkAny 15)) (Set (KeyHash Guard))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
15 = (StrictMaybe Network
 -> BabbageTxBodyRaw TopTx BabbageEra
 -> BabbageTxBodyRaw TopTx BabbageEra)
-> Decode (Closed (ZonkAny 16)) Network
-> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe Network
x BabbageTxBodyRaw TopTx BabbageEra
tx -> BabbageTxBodyRaw TopTx BabbageEra
tx {btbrNetworkId = x}) Decode (Closed (ZonkAny 16)) Network
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
n = Word -> Field (BabbageTxBodyRaw TopTx BabbageEra)
forall t. Word -> Field t
invalidField Word
n
      {-# INLINE bodyFields #-}
      requiredFields :: [(Word, String)]
      requiredFields :: [(Word, String)]
requiredFields =
        [ (Word
0, String
"inputs")
        , (Word
1, String
"outputs")
        , (Word
2, String
"fee")
        ]
  {-# INLINE decCBOR #-}

instance Typeable l => DecCBOR (Annotator (BabbageTxBodyRaw l BabbageEra)) where
  decCBOR :: forall s. Decoder s (Annotator (BabbageTxBodyRaw l BabbageEra))
decCBOR = BabbageTxBodyRaw l BabbageEra
-> Annotator (BabbageTxBodyRaw l BabbageEra)
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxBodyRaw l BabbageEra
 -> Annotator (BabbageTxBodyRaw l BabbageEra))
-> Decoder s (BabbageTxBodyRaw l BabbageEra)
-> Decoder s (Annotator (BabbageTxBodyRaw l BabbageEra))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (BabbageTxBodyRaw l BabbageEra)
forall s. Decoder s (BabbageTxBodyRaw l BabbageEra)
forall a s. DecCBOR a => Decoder s a
decCBOR

basicBabbageTxBodyRaw :: BabbageTxBodyRaw TopTx era
basicBabbageTxBodyRaw :: forall era. BabbageTxBodyRaw TopTx era
basicBabbageTxBodyRaw =
  Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut era))
-> StrictMaybe (Sized (TxOut era))
-> StrictMaybe Coin
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> Set (KeyHash Guard)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw TopTx era
forall era.
Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut era))
-> StrictMaybe (Sized (TxOut era))
-> StrictMaybe Coin
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> Set (KeyHash Guard)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw TopTx era
BabbageTxBodyRaw
    Set TxIn
forall a. Monoid a => a
mempty
    Set TxIn
forall a. Monoid a => a
mempty
    Set TxIn
forall a. Monoid a => a
mempty
    StrictSeq (Sized (TxOut era))
forall a. StrictSeq a
StrictSeq.empty
    StrictMaybe (Sized (TxOut era))
forall a. StrictMaybe a
SNothing
    StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    StrictSeq (TxCert era)
forall a. StrictSeq a
StrictSeq.empty
    (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
forall a. Monoid a => a
mempty)
    Coin
forall a. Monoid a => a
mempty
    (StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing)
    StrictMaybe (Update era)
forall a. StrictMaybe a
SNothing
    Set (KeyHash Guard)
forall a. Monoid a => a
mempty
    MultiAsset
forall a. Monoid a => a
mempty
    StrictMaybe ScriptIntegrityHash
forall a. StrictMaybe a
SNothing
    StrictMaybe TxAuxDataHash
forall a. StrictMaybe a
SNothing
    StrictMaybe Network
forall a. StrictMaybe a
SNothing