{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# 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 (..),
  BabbageTxBodyUpgradeError (..),
  babbageAllInputsTxBodyF,
  babbageSpendableInputsTxBodyF,
  BabbageEraTxBody (..),
  spendInputs',
  collateralInputs',
  referenceInputs',
  outputs',
  collateralReturn',
  totalCollateral',
  certs',
  withdrawals',
  txfee',
  vldt',
  update',
  reqSignerHashes',
  mint',
  scriptIntegrityHash',
  adHash',
  txnetworkid',
  getEitherAddrBabbageTxOut,
  EraIndependentScriptIntegrity,
  ScriptIntegrityHash,
  txOutData,
  txOutDataHash,
  txOutScript,
) where

import Cardano.Ledger.Alonzo (AlonzoEra)
import Cardano.Ledger.Alonzo.Core
import Cardano.Ledger.Alonzo.PParams (AlonzoPParams (appExtraEntropy), appD)
import Cardano.Ledger.Alonzo.TxBody (alonzoRedeemerPointer, alonzoRedeemerPointerInverse)
import Cardano.Ledger.Babbage.Era (BabbageEra)
import Cardano.Ledger.Babbage.PParams (upgradeBabbagePParams)
import Cardano.Ledger.Babbage.Scripts ()
import Cardano.Ledger.Babbage.TxCert ()
import Cardano.Ledger.Babbage.TxOut hiding (TxOut)
import Cardano.Ledger.BaseTypes (
  Network (..),
  StrictMaybe (..),
  isSJust,
 )
import Cardano.Ledger.Binary (
  DecCBOR (..),
  EncCBOR (..),
  Sized (..),
  ToCBOR (..),
  mkSized,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Mary.Value (MultiAsset, policies)
import Cardano.Ledger.MemoBytes (
  EqRaw,
  MemoBytes,
  MemoHashIndex,
  Memoized (..),
  eqRaw,
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
  zipMemoRawType,
 )
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (ProposedPPUpdates), Update (..))
import Cardano.Ledger.Shelley.TxBody (getShelleyGenesisKeyHashCountTxBody)
import Cardano.Ledger.TxIn (TxIn (..))
import Control.Arrow (left)
import Control.DeepSeq (NFData)
import Control.Monad (when)
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.Void (absurd)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks)

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

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

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

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

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

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

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

data BabbageTxBodyRaw = BabbageTxBodyRaw
  { BabbageTxBodyRaw -> Set TxIn
btbrInputs :: !(Set TxIn)
  , BabbageTxBodyRaw -> Set TxIn
btbrCollateralInputs :: !(Set TxIn)
  , BabbageTxBodyRaw -> Set TxIn
btbrReferenceInputs :: !(Set TxIn)
  , BabbageTxBodyRaw -> StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: !(StrictSeq (Sized (TxOut BabbageEra)))
  , BabbageTxBodyRaw -> StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: !(StrictMaybe (Sized (TxOut BabbageEra)))
  , BabbageTxBodyRaw -> StrictMaybe Coin
btbrTotalCollateral :: !(StrictMaybe Coin)
  , BabbageTxBodyRaw -> StrictSeq (TxCert BabbageEra)
btbrCerts :: !(StrictSeq (TxCert BabbageEra))
  , BabbageTxBodyRaw -> Withdrawals
btbrWithdrawals :: !Withdrawals
  , BabbageTxBodyRaw -> Coin
btbrFee :: !Coin
  , BabbageTxBodyRaw -> ValidityInterval
btbrValidityInterval :: !ValidityInterval
  , BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra)
btbrUpdate :: !(StrictMaybe (Update BabbageEra))
  , BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes :: !(Set (KeyHash 'Witness))
  , BabbageTxBodyRaw -> 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.
    BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: !(StrictMaybe ScriptIntegrityHash)
  , BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash
btbrAuxDataHash :: !(StrictMaybe TxAuxDataHash)
  , BabbageTxBodyRaw -> StrictMaybe Network
btbrNetworkId :: !(StrictMaybe Network)
  }
  deriving ((forall x. BabbageTxBodyRaw -> Rep BabbageTxBodyRaw x)
-> (forall x. Rep BabbageTxBodyRaw x -> BabbageTxBodyRaw)
-> Generic BabbageTxBodyRaw
forall x. Rep BabbageTxBodyRaw x -> BabbageTxBodyRaw
forall x. BabbageTxBodyRaw -> Rep BabbageTxBodyRaw x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BabbageTxBodyRaw -> Rep BabbageTxBodyRaw x
from :: forall x. BabbageTxBodyRaw -> Rep BabbageTxBodyRaw x
$cto :: forall x. Rep BabbageTxBodyRaw x -> BabbageTxBodyRaw
to :: forall x. Rep BabbageTxBodyRaw x -> BabbageTxBodyRaw
Generic)

-- 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 where
  eqRaw :: BabbageTxBodyRaw -> BabbageTxBodyRaw -> Bool
eqRaw BabbageTxBodyRaw
a BabbageTxBodyRaw
b =
    BabbageTxBodyRaw -> Set TxIn
btbrInputs BabbageTxBodyRaw
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Set TxIn
btbrInputs BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> Set TxIn
btbrCollateralInputs BabbageTxBodyRaw
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Set TxIn
btbrCollateralInputs BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> Set TxIn
btbrReferenceInputs BabbageTxBodyRaw
a Set TxIn -> Set TxIn -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Set TxIn
btbrReferenceInputs BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs BabbageTxBodyRaw
a StrictSeq (Sized (BabbageTxOut BabbageEra))
-> StrictSeq (Sized (BabbageTxOut BabbageEra)) -> Bool
forall {a}.
Eq a =>
StrictSeq (Sized a) -> StrictSeq (Sized a) -> Bool
`eqSeqUnsized` BabbageTxBodyRaw -> StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn BabbageTxBodyRaw
a StrictMaybe (Sized (BabbageTxOut BabbageEra))
-> StrictMaybe (Sized (BabbageTxOut BabbageEra)) -> Bool
forall {a}.
Eq a =>
StrictMaybe (Sized a) -> StrictMaybe (Sized a) -> Bool
`eqMbUnsized` BabbageTxBodyRaw -> StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe Coin
btbrTotalCollateral BabbageTxBodyRaw
a StrictMaybe Coin -> StrictMaybe Coin -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictMaybe Coin
btbrTotalCollateral BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictSeq (TxCert BabbageEra)
btbrCerts BabbageTxBodyRaw
a StrictSeq (ShelleyTxCert BabbageEra)
-> StrictSeq (ShelleyTxCert BabbageEra) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictSeq (TxCert BabbageEra)
btbrCerts BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> Withdrawals
btbrWithdrawals BabbageTxBodyRaw
a Withdrawals -> Withdrawals -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Withdrawals
btbrWithdrawals BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> Coin
btbrFee BabbageTxBodyRaw
a Coin -> Coin -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Coin
btbrFee BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> ValidityInterval
btbrValidityInterval BabbageTxBodyRaw
a ValidityInterval -> ValidityInterval -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> ValidityInterval
btbrValidityInterval BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra)
btbrUpdate BabbageTxBodyRaw
a StrictMaybe (Update BabbageEra)
-> StrictMaybe (Update BabbageEra) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra)
btbrUpdate BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes BabbageTxBodyRaw
a Set (KeyHash 'Witness) -> Set (KeyHash 'Witness) -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> MultiAsset
btbrMint BabbageTxBodyRaw
a MultiAsset -> MultiAsset -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> MultiAsset
btbrMint BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash BabbageTxBodyRaw
a StrictMaybe ScriptIntegrityHash
-> StrictMaybe ScriptIntegrityHash -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash
btbrAuxDataHash BabbageTxBodyRaw
a StrictMaybe TxAuxDataHash -> StrictMaybe TxAuxDataHash -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash
btbrAuxDataHash BabbageTxBodyRaw
b
      Bool -> Bool -> Bool
&& BabbageTxBodyRaw -> StrictMaybe Network
btbrNetworkId BabbageTxBodyRaw
a StrictMaybe Network -> StrictMaybe Network -> Bool
forall a. Eq a => a -> a -> Bool
== BabbageTxBodyRaw -> StrictMaybe Network
btbrNetworkId BabbageTxBodyRaw
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 = EraIndependentTxBody

deriving instance Eq BabbageTxBodyRaw

instance NoThunks BabbageTxBodyRaw

instance NFData BabbageTxBodyRaw

deriving instance Show BabbageTxBodyRaw

deriving newtype instance DecCBOR (TxBody BabbageEra)

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

deriving newtype instance NFData (TxBody BabbageEra)

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

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

allSizedOutputsBabbageTxBodyF ::
  BabbageEraTxBody era =>
  SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era)))
allSizedOutputsBabbageTxBodyF :: forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era)))
allSizedOutputsBabbageTxBodyF =
  (TxBody era -> StrictSeq (Sized (TxOut era)))
-> SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era)))
forall s a. (s -> a) -> SimpleGetter s a
to ((TxBody era -> StrictSeq (Sized (TxOut era)))
 -> SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era))))
-> (TxBody era -> StrictSeq (Sized (TxOut era)))
-> SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era)))
forall a b. (a -> b) -> a -> b
$ \TxBody era
txBody ->
    let txOuts :: StrictSeq (Sized (TxOut era))
txOuts = TxBody era
txBody TxBody era
-> Getting
     (StrictSeq (Sized (TxOut era)))
     (TxBody era)
     (StrictSeq (Sized (TxOut era)))
-> StrictSeq (Sized (TxOut era))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (Sized (TxOut era)))
  (TxBody era)
  (StrictSeq (Sized (TxOut era)))
forall era.
BabbageEraTxBody era =>
Lens' (TxBody era) (StrictSeq (Sized (TxOut era)))
Lens' (TxBody era) (StrictSeq (Sized (TxOut era)))
sizedOutputsTxBodyL
     in case TxBody era
txBody TxBody era
-> Getting
     (StrictMaybe (Sized (TxOut era)))
     (TxBody era)
     (StrictMaybe (Sized (TxOut era)))
-> StrictMaybe (Sized (TxOut era))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (Sized (TxOut era)))
  (TxBody era)
  (StrictMaybe (Sized (TxOut era)))
forall era.
BabbageEraTxBody era =>
Lens' (TxBody era) (StrictMaybe (Sized (TxOut era)))
Lens' (TxBody 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 #-}

data BabbageTxBodyUpgradeError
  = -- | The update attempts to update the decentralistion parameter, which is
    -- dropped in Babbage.
    BTBUEUpdatesD
  | -- | The update attempts to update the extra entropy, which is dropped in
    --   Babbage.
    BTBUEUpdatesExtraEntropy
  deriving (BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool
(BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool)
-> (BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool)
-> Eq BabbageTxBodyUpgradeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool
== :: BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool
$c/= :: BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool
/= :: BabbageTxBodyUpgradeError -> BabbageTxBodyUpgradeError -> Bool
Eq, Int -> BabbageTxBodyUpgradeError -> ShowS
[BabbageTxBodyUpgradeError] -> ShowS
BabbageTxBodyUpgradeError -> String
(Int -> BabbageTxBodyUpgradeError -> ShowS)
-> (BabbageTxBodyUpgradeError -> String)
-> ([BabbageTxBodyUpgradeError] -> ShowS)
-> Show BabbageTxBodyUpgradeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BabbageTxBodyUpgradeError -> ShowS
showsPrec :: Int -> BabbageTxBodyUpgradeError -> ShowS
$cshow :: BabbageTxBodyUpgradeError -> String
show :: BabbageTxBodyUpgradeError -> String
$cshowList :: [BabbageTxBodyUpgradeError] -> ShowS
showList :: [BabbageTxBodyUpgradeError] -> ShowS
Show)

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

  mkBasicTxBody :: TxBody BabbageEra
mkBasicTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @BabbageEra RawType (TxBody BabbageEra)
BabbageTxBodyRaw
basicBabbageTxBodyRaw

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

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

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

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

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

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

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

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

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

  upgradeTxBody :: EraTxBody (PreviousEra BabbageEra) =>
TxBody (PreviousEra BabbageEra)
-> Either (TxBodyUpgradeError BabbageEra) (TxBody BabbageEra)
upgradeTxBody TxBody (PreviousEra BabbageEra)
txBody = do
    StrictSeq (TxCert BabbageEra)
certs <-
      (TxCert (PreviousEra BabbageEra)
 -> Either BabbageTxBodyUpgradeError (TxCert BabbageEra))
-> StrictSeq (TxCert (PreviousEra BabbageEra))
-> Either BabbageTxBodyUpgradeError (StrictSeq (TxCert BabbageEra))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> StrictSeq a -> f (StrictSeq b)
traverse
        ((Void -> BabbageTxBodyUpgradeError)
-> Either Void (TxCert BabbageEra)
-> Either BabbageTxBodyUpgradeError (TxCert BabbageEra)
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left Void -> BabbageTxBodyUpgradeError
forall a. Void -> a
absurd (Either Void (TxCert BabbageEra)
 -> Either BabbageTxBodyUpgradeError (TxCert BabbageEra))
-> (TxCert (PreviousEra BabbageEra)
    -> Either Void (TxCert BabbageEra))
-> TxCert (PreviousEra BabbageEra)
-> Either BabbageTxBodyUpgradeError (TxCert BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxCert (PreviousEra BabbageEra) -> Either Void (TxCert BabbageEra)
TxCert (PreviousEra BabbageEra)
-> Either (TxCertUpgradeError BabbageEra) (TxCert BabbageEra)
forall era.
(EraTxCert era, EraTxCert (PreviousEra era)) =>
TxCert (PreviousEra era)
-> Either (TxCertUpgradeError era) (TxCert era)
upgradeTxCert)
        (TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictSeq (TxCert (PreviousEra BabbageEra)))
     (TxBody AlonzoEra)
     (StrictSeq (TxCert (PreviousEra BabbageEra)))
-> StrictSeq (TxCert (PreviousEra BabbageEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (TxCert (PreviousEra BabbageEra)))
  (TxBody AlonzoEra)
  (StrictSeq (TxCert (PreviousEra BabbageEra)))
(StrictSeq (TxCert AlonzoEra)
 -> Const
      (StrictSeq (TxCert (PreviousEra BabbageEra)))
      (StrictSeq (TxCert AlonzoEra)))
-> TxBody AlonzoEra
-> Const
     (StrictSeq (TxCert (PreviousEra BabbageEra))) (TxBody AlonzoEra)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxCert era))
Lens' (TxBody AlonzoEra) (StrictSeq (TxCert AlonzoEra))
certsTxBodyL)
    StrictMaybe (Update BabbageEra)
updates <- (Update AlonzoEra
 -> Either BabbageTxBodyUpgradeError (Update BabbageEra))
-> StrictMaybe (Update AlonzoEra)
-> Either
     BabbageTxBodyUpgradeError (StrictMaybe (Update BabbageEra))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> StrictMaybe a -> f (StrictMaybe b)
traverse Update AlonzoEra
-> Either BabbageTxBodyUpgradeError (Update BabbageEra)
upgradeUpdate (TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictMaybe (Update AlonzoEra))
     (TxBody AlonzoEra)
     (StrictMaybe (Update AlonzoEra))
-> StrictMaybe (Update AlonzoEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (Update AlonzoEra))
  (TxBody AlonzoEra)
  (StrictMaybe (Update AlonzoEra))
forall era.
ShelleyEraTxBody era =>
Lens' (TxBody era) (StrictMaybe (Update era))
Lens' (TxBody AlonzoEra) (StrictMaybe (Update AlonzoEra))
updateTxBodyL)
    TxBody BabbageEra
-> Either BabbageTxBodyUpgradeError (TxBody BabbageEra)
forall a. a -> Either BabbageTxBodyUpgradeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxBody BabbageEra
 -> Either BabbageTxBodyUpgradeError (TxBody BabbageEra))
-> TxBody BabbageEra
-> Either BabbageTxBodyUpgradeError (TxBody BabbageEra)
forall a b. (a -> b) -> a -> b
$
      BabbageTxBody
        { btbInputs :: Set TxIn
btbInputs = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting (Set TxIn) (TxBody AlonzoEra) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody AlonzoEra) (Set TxIn)
forall era. EraTxBody era => Lens' (TxBody era) (Set TxIn)
Lens' (TxBody AlonzoEra) (Set TxIn)
inputsTxBodyL
        , btbOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbOutputs =
            Version
-> BabbageTxOut BabbageEra -> Sized (BabbageTxOut BabbageEra)
forall a. EncCBOR a => Version -> a -> Sized a
mkSized (forall era. Era era => Version
eraProtVerLow @BabbageEra) (BabbageTxOut BabbageEra -> Sized (BabbageTxOut BabbageEra))
-> (TxOut (PreviousEra BabbageEra) -> BabbageTxOut BabbageEra)
-> TxOut (PreviousEra BabbageEra)
-> Sized (BabbageTxOut BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut (PreviousEra BabbageEra) -> TxOut BabbageEra
TxOut (PreviousEra BabbageEra) -> BabbageTxOut BabbageEra
forall era.
(EraTxOut era, EraTxOut (PreviousEra era)) =>
TxOut (PreviousEra era) -> TxOut era
upgradeTxOut (TxOut (PreviousEra BabbageEra) -> Sized (BabbageTxOut BabbageEra))
-> StrictSeq (TxOut (PreviousEra BabbageEra))
-> StrictSeq (Sized (BabbageTxOut BabbageEra))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictSeq (TxOut (PreviousEra BabbageEra)))
     (TxBody AlonzoEra)
     (StrictSeq (TxOut (PreviousEra BabbageEra)))
-> StrictSeq (TxOut (PreviousEra BabbageEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (TxOut (PreviousEra BabbageEra)))
  (TxBody AlonzoEra)
  (StrictSeq (TxOut (PreviousEra BabbageEra)))
(StrictSeq (TxOut AlonzoEra)
 -> Const
      (StrictSeq (TxOut (PreviousEra BabbageEra)))
      (StrictSeq (TxOut AlonzoEra)))
-> TxBody AlonzoEra
-> Const
     (StrictSeq (TxOut (PreviousEra BabbageEra))) (TxBody AlonzoEra)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody AlonzoEra) (StrictSeq (TxOut AlonzoEra))
outputsTxBodyL)
        , btbCerts :: StrictSeq (TxCert BabbageEra)
btbCerts = StrictSeq (TxCert BabbageEra)
certs
        , btbWithdrawals :: Withdrawals
btbWithdrawals = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting Withdrawals (TxBody AlonzoEra) Withdrawals
-> Withdrawals
forall s a. s -> Getting a s a -> a
^. Getting Withdrawals (TxBody AlonzoEra) Withdrawals
forall era. EraTxBody era => Lens' (TxBody era) Withdrawals
Lens' (TxBody AlonzoEra) Withdrawals
withdrawalsTxBodyL
        , btbTxFee :: Coin
btbTxFee = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra -> Getting Coin (TxBody AlonzoEra) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. Getting Coin (TxBody AlonzoEra) Coin
forall era. EraTxBody era => Lens' (TxBody era) Coin
Lens' (TxBody AlonzoEra) Coin
feeTxBodyL
        , btbValidityInterval :: ValidityInterval
btbValidityInterval = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting ValidityInterval (TxBody AlonzoEra) ValidityInterval
-> ValidityInterval
forall s a. s -> Getting a s a -> a
^. Getting ValidityInterval (TxBody AlonzoEra) ValidityInterval
forall era.
AllegraEraTxBody era =>
Lens' (TxBody era) ValidityInterval
Lens' (TxBody AlonzoEra) ValidityInterval
vldtTxBodyL
        , btbUpdate :: StrictMaybe (Update BabbageEra)
btbUpdate = StrictMaybe (Update BabbageEra)
updates
        , btbAuxDataHash :: StrictMaybe TxAuxDataHash
btbAuxDataHash = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictMaybe TxAuxDataHash)
     (TxBody AlonzoEra)
     (StrictMaybe TxAuxDataHash)
-> StrictMaybe TxAuxDataHash
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe TxAuxDataHash)
  (TxBody AlonzoEra)
  (StrictMaybe TxAuxDataHash)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictMaybe TxAuxDataHash)
Lens' (TxBody AlonzoEra) (StrictMaybe TxAuxDataHash)
auxDataHashTxBodyL
        , btbMint :: MultiAsset
btbMint = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting MultiAsset (TxBody AlonzoEra) MultiAsset -> MultiAsset
forall s a. s -> Getting a s a -> a
^. Getting MultiAsset (TxBody AlonzoEra) MultiAsset
forall era. MaryEraTxBody era => Lens' (TxBody era) MultiAsset
Lens' (TxBody AlonzoEra) MultiAsset
mintTxBodyL
        , btbCollateral :: Set TxIn
btbCollateral = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting (Set TxIn) (TxBody AlonzoEra) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody AlonzoEra) (Set TxIn)
forall era. AlonzoEraTxBody era => Lens' (TxBody era) (Set TxIn)
Lens' (TxBody AlonzoEra) (Set TxIn)
collateralInputsTxBodyL
        , btbReqSignerHashes :: Set (KeyHash 'Witness)
btbReqSignerHashes = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (Set (KeyHash 'Witness))
     (TxBody AlonzoEra)
     (Set (KeyHash 'Witness))
-> Set (KeyHash 'Witness)
forall s a. s -> Getting a s a -> a
^. Getting
  (Set (KeyHash 'Witness))
  (TxBody AlonzoEra)
  (Set (KeyHash 'Witness))
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody era) (Set (KeyHash 'Witness))
Lens' (TxBody AlonzoEra) (Set (KeyHash 'Witness))
reqSignerHashesTxBodyL
        , btbScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbScriptIntegrityHash = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictMaybe ScriptIntegrityHash)
     (TxBody AlonzoEra)
     (StrictMaybe ScriptIntegrityHash)
-> StrictMaybe ScriptIntegrityHash
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe ScriptIntegrityHash)
  (TxBody AlonzoEra)
  (StrictMaybe ScriptIntegrityHash)
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody era) (StrictMaybe ScriptIntegrityHash)
Lens' (TxBody AlonzoEra) (StrictMaybe ScriptIntegrityHash)
scriptIntegrityHashTxBodyL
        , btbTxNetworkId :: StrictMaybe Network
btbTxNetworkId = TxBody (PreviousEra BabbageEra)
TxBody AlonzoEra
txBody TxBody AlonzoEra
-> Getting
     (StrictMaybe Network) (TxBody AlonzoEra) (StrictMaybe Network)
-> StrictMaybe Network
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe Network) (TxBody AlonzoEra) (StrictMaybe Network)
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody era) (StrictMaybe Network)
Lens' (TxBody AlonzoEra) (StrictMaybe Network)
networkIdTxBodyL
        , btbReferenceInputs :: Set TxIn
btbReferenceInputs = Set TxIn
forall a. Monoid a => a
mempty
        , btbCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbCollateralReturn = StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
forall a. StrictMaybe a
SNothing
        , btbTotalCollateral :: StrictMaybe Coin
btbTotalCollateral = StrictMaybe Coin
forall a. StrictMaybe a
SNothing
        }
    where
      upgradeUpdate ::
        Update AlonzoEra ->
        Either BabbageTxBodyUpgradeError (Update BabbageEra)
      upgradeUpdate :: Update AlonzoEra
-> Either BabbageTxBodyUpgradeError (Update BabbageEra)
upgradeUpdate (Update ProposedPPUpdates AlonzoEra
pp EpochNo
epoch) =
        ProposedPPUpdates BabbageEra -> EpochNo -> Update BabbageEra
forall era. ProposedPPUpdates era -> EpochNo -> Update era
Update (ProposedPPUpdates BabbageEra -> EpochNo -> Update BabbageEra)
-> Either BabbageTxBodyUpgradeError (ProposedPPUpdates BabbageEra)
-> Either BabbageTxBodyUpgradeError (EpochNo -> Update BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProposedPPUpdates AlonzoEra
-> Either BabbageTxBodyUpgradeError (ProposedPPUpdates BabbageEra)
upgradeProposedPPUpdates ProposedPPUpdates AlonzoEra
pp Either BabbageTxBodyUpgradeError (EpochNo -> Update BabbageEra)
-> Either BabbageTxBodyUpgradeError EpochNo
-> Either BabbageTxBodyUpgradeError (Update BabbageEra)
forall a b.
Either BabbageTxBodyUpgradeError (a -> b)
-> Either BabbageTxBodyUpgradeError a
-> Either BabbageTxBodyUpgradeError b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> EpochNo -> Either BabbageTxBodyUpgradeError EpochNo
forall a. a -> Either BabbageTxBodyUpgradeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EpochNo
epoch

      -- Note that here we use 'upgradeBabbagePParams False' in order to
      -- preserve 'CoinsPerUTxOWord', in spite of the value now being
      -- semantically incorrect. Anything else will result in an invalid
      -- transaction.
      upgradeProposedPPUpdates ::
        ProposedPPUpdates AlonzoEra ->
        Either BabbageTxBodyUpgradeError (ProposedPPUpdates BabbageEra)
      upgradeProposedPPUpdates :: ProposedPPUpdates AlonzoEra
-> Either BabbageTxBodyUpgradeError (ProposedPPUpdates BabbageEra)
upgradeProposedPPUpdates (ProposedPPUpdates Map (KeyHash 'Genesis) (PParamsUpdate AlonzoEra)
m) =
        Map (KeyHash 'Genesis) (PParamsUpdate BabbageEra)
-> ProposedPPUpdates BabbageEra
forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates
          (Map (KeyHash 'Genesis) (PParamsUpdate BabbageEra)
 -> ProposedPPUpdates BabbageEra)
-> Either
     BabbageTxBodyUpgradeError
     (Map (KeyHash 'Genesis) (PParamsUpdate BabbageEra))
-> Either BabbageTxBodyUpgradeError (ProposedPPUpdates BabbageEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PParamsUpdate AlonzoEra
 -> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra))
-> Map (KeyHash 'Genesis) (PParamsUpdate AlonzoEra)
-> Either
     BabbageTxBodyUpgradeError
     (Map (KeyHash 'Genesis) (PParamsUpdate BabbageEra))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Map (KeyHash 'Genesis) a -> f (Map (KeyHash 'Genesis) b)
traverse
            ( \(PParamsUpdate PParamsHKD StrictMaybe AlonzoEra
pphkd) -> do
                Bool
-> Either BabbageTxBodyUpgradeError ()
-> Either BabbageTxBodyUpgradeError ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (StrictMaybe UnitInterval -> Bool
forall a. StrictMaybe a -> Bool
isSJust (StrictMaybe UnitInterval -> Bool)
-> StrictMaybe UnitInterval -> Bool
forall a b. (a -> b) -> a -> b
$ AlonzoPParams StrictMaybe AlonzoEra -> HKD StrictMaybe UnitInterval
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appD PParamsHKD StrictMaybe AlonzoEra
AlonzoPParams StrictMaybe AlonzoEra
pphkd) (Either BabbageTxBodyUpgradeError ()
 -> Either BabbageTxBodyUpgradeError ())
-> Either BabbageTxBodyUpgradeError ()
-> Either BabbageTxBodyUpgradeError ()
forall a b. (a -> b) -> a -> b
$
                  BabbageTxBodyUpgradeError -> Either BabbageTxBodyUpgradeError ()
forall a b. a -> Either a b
Left BabbageTxBodyUpgradeError
BTBUEUpdatesD
                Bool
-> Either BabbageTxBodyUpgradeError ()
-> Either BabbageTxBodyUpgradeError ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (StrictMaybe Nonce -> Bool
forall a. StrictMaybe a -> Bool
isSJust (StrictMaybe Nonce -> Bool) -> StrictMaybe Nonce -> Bool
forall a b. (a -> b) -> a -> b
$ AlonzoPParams StrictMaybe AlonzoEra -> HKD StrictMaybe Nonce
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Nonce
appExtraEntropy PParamsHKD StrictMaybe AlonzoEra
AlonzoPParams StrictMaybe AlonzoEra
pphkd) (Either BabbageTxBodyUpgradeError ()
 -> Either BabbageTxBodyUpgradeError ())
-> Either BabbageTxBodyUpgradeError ()
-> Either BabbageTxBodyUpgradeError ()
forall a b. (a -> b) -> a -> b
$
                  BabbageTxBodyUpgradeError -> Either BabbageTxBodyUpgradeError ()
forall a b. a -> Either a b
Left BabbageTxBodyUpgradeError
BTBUEUpdatesExtraEntropy
                PParamsUpdate BabbageEra
-> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra)
forall a. a -> Either BabbageTxBodyUpgradeError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PParamsUpdate BabbageEra
 -> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra))
-> (BabbagePParams StrictMaybe BabbageEra
    -> PParamsUpdate BabbageEra)
-> BabbagePParams StrictMaybe BabbageEra
-> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PParamsHKD StrictMaybe BabbageEra -> PParamsUpdate BabbageEra
BabbagePParams StrictMaybe BabbageEra -> PParamsUpdate BabbageEra
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate (BabbagePParams StrictMaybe BabbageEra
 -> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra))
-> BabbagePParams StrictMaybe BabbageEra
-> Either BabbageTxBodyUpgradeError (PParamsUpdate BabbageEra)
forall a b. (a -> b) -> a -> b
$ Bool
-> PParamsHKD StrictMaybe AlonzoEra
-> BabbagePParams StrictMaybe BabbageEra
forall (f :: * -> *).
HKDFunctor f =>
Bool -> PParamsHKD f AlonzoEra -> BabbagePParams f BabbageEra
upgradeBabbagePParams Bool
False PParamsHKD StrictMaybe AlonzoEra
pphkd
            )
            Map (KeyHash 'Genesis) (PParamsUpdate AlonzoEra)
m

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

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

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

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

  mintedTxBodyF :: SimpleGetter (TxBody BabbageEra) (Set PolicyID)
mintedTxBodyF = (TxBody BabbageEra -> Set PolicyID)
-> SimpleGetter (TxBody BabbageEra) (Set PolicyID)
forall s a. (s -> a) -> SimpleGetter s a
to (MultiAsset -> Set PolicyID
policies (MultiAsset -> Set PolicyID)
-> (TxBody BabbageEra -> MultiAsset)
-> TxBody BabbageEra
-> Set PolicyID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxBodyRaw -> MultiAsset
btbrMint (BabbageTxBodyRaw -> MultiAsset)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> MultiAsset
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType)
  {-# INLINE mintedTxBodyF #-}

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

  reqSignerHashesTxBodyL :: Lens' (TxBody BabbageEra) (Set (KeyHash 'Witness))
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 RawType (TxBody BabbageEra) -> Set (KeyHash 'Witness)
BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes ((RawType (TxBody BabbageEra)
  -> Set (KeyHash 'Witness) -> RawType (TxBody BabbageEra))
 -> Lens' (TxBody BabbageEra) (Set (KeyHash 'Witness)))
-> (RawType (TxBody BabbageEra)
    -> Set (KeyHash 'Witness) -> RawType (TxBody BabbageEra))
-> Lens' (TxBody BabbageEra) (Set (KeyHash 'Witness))
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody BabbageEra)
txBodyRaw Set (KeyHash 'Witness)
reqSignerHashes ->
      RawType (TxBody BabbageEra)
txBodyRaw {btbrReqSignerHashes = reqSignerHashes}
  {-# INLINE reqSignerHashesTxBodyL #-}

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

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

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

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

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

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

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

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

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

  allSizedOutputsTxBodyF :: SimpleGetter
  (TxBody BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
allSizedOutputsTxBodyF = Getting
  r (TxBody BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
forall era.
BabbageEraTxBody era =>
SimpleGetter (TxBody era) (StrictSeq (Sized (TxOut era)))
SimpleGetter
  (TxBody BabbageEra) (StrictSeq (Sized (TxOut BabbageEra)))
allSizedOutputsBabbageTxBodyF
  {-# INLINE allSizedOutputsTxBodyF #-}

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

deriving newtype instance Eq (TxBody BabbageEra)

deriving instance NoThunks (TxBody BabbageEra)

deriving instance Show (TxBody 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 'Witness) ->
  MultiAsset ->
  StrictMaybe ScriptIntegrityHash ->
  StrictMaybe TxAuxDataHash ->
  StrictMaybe Network ->
  TxBody BabbageEra
pattern $mBabbageTxBody :: forall {r}.
TxBody 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 'Witness)
    -> 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 'Witness)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> TxBody BabbageEra
BabbageTxBody
  { TxBody BabbageEra -> Set TxIn
btbInputs
  , TxBody BabbageEra -> Set TxIn
btbCollateral
  , TxBody BabbageEra -> Set TxIn
btbReferenceInputs
  , TxBody BabbageEra -> StrictSeq (Sized (TxOut BabbageEra))
btbOutputs
  , TxBody BabbageEra -> StrictMaybe (Sized (TxOut BabbageEra))
btbCollateralReturn
  , TxBody BabbageEra -> StrictMaybe Coin
btbTotalCollateral
  , TxBody BabbageEra -> StrictSeq (TxCert BabbageEra)
btbCerts
  , TxBody BabbageEra -> Withdrawals
btbWithdrawals
  , TxBody BabbageEra -> Coin
btbTxFee
  , TxBody BabbageEra -> ValidityInterval
btbValidityInterval
  , TxBody BabbageEra -> StrictMaybe (Update BabbageEra)
btbUpdate
  , TxBody BabbageEra -> Set (KeyHash 'Witness)
btbReqSignerHashes
  , TxBody BabbageEra -> MultiAsset
btbMint
  , TxBody BabbageEra -> StrictMaybe ScriptIntegrityHash
btbScriptIntegrityHash
  , TxBody BabbageEra -> StrictMaybe TxAuxDataHash
btbAuxDataHash
  , TxBody 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 'Witness)
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 BabbageEra) -> TxBody BabbageEra)
-> RawType (TxBody BabbageEra) -> TxBody 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 'Witness)
btbrReqSignerHashes = Set (KeyHash 'Witness)
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 BabbageEra) EraIndependentTxBody where
  hashAnnotated :: TxBody BabbageEra -> SafeHash EraIndependentTxBody
hashAnnotated = TxBody BabbageEra -> SafeHash EraIndependentTxBody
TxBody BabbageEra
-> SafeHash (MemoHashIndex (RawType (TxBody BabbageEra)))
forall t. Memoized t => t -> SafeHash (MemoHashIndex (RawType t))
getMemoSafeHash

-- ==============================================================================
-- We define these accessor functions manually, because if we define them using
-- the record syntax in the TxBody pattern, they inherit the (BabbageBody era)
-- constraint as a precondition. This is unnecessary, as one can see below
-- they need not be constrained at all. This should be fixed in the GHC compiler.

spendInputs' :: TxBody BabbageEra -> Set TxIn
collateralInputs' :: TxBody BabbageEra -> Set TxIn
referenceInputs' :: TxBody BabbageEra -> Set TxIn
outputs' :: TxBody BabbageEra -> StrictSeq (TxOut BabbageEra)
collateralReturn' :: TxBody BabbageEra -> StrictMaybe (TxOut BabbageEra)
totalCollateral' :: TxBody BabbageEra -> StrictMaybe Coin
certs' :: TxBody BabbageEra -> StrictSeq (TxCert BabbageEra)
txfee' :: TxBody BabbageEra -> Coin
withdrawals' :: TxBody BabbageEra -> Withdrawals
vldt' :: TxBody BabbageEra -> ValidityInterval
update' :: TxBody BabbageEra -> StrictMaybe (Update BabbageEra)
reqSignerHashes' :: TxBody BabbageEra -> Set (KeyHash 'Witness)
adHash' :: TxBody BabbageEra -> StrictMaybe TxAuxDataHash
mint' :: TxBody BabbageEra -> MultiAsset
scriptIntegrityHash' :: TxBody BabbageEra -> StrictMaybe ScriptIntegrityHash
txnetworkid' :: TxBody BabbageEra -> StrictMaybe Network
spendInputs' :: TxBody BabbageEra -> Set TxIn
spendInputs' = BabbageTxBodyRaw -> Set TxIn
btbrInputs (BabbageTxBodyRaw -> Set TxIn)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Set TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED spendInputs' "In favor of `inputsTxBodyL`" #-}

collateralInputs' :: TxBody BabbageEra -> Set TxIn
collateralInputs' = BabbageTxBodyRaw -> Set TxIn
btbrCollateralInputs (BabbageTxBodyRaw -> Set TxIn)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Set TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED collateralInputs' "In favor of `collateralInputsTxBodyL`" #-}

referenceInputs' :: TxBody BabbageEra -> Set TxIn
referenceInputs' = BabbageTxBodyRaw -> Set TxIn
btbrReferenceInputs (BabbageTxBodyRaw -> Set TxIn)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Set TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED referenceInputs' "In favor of `referenceInputsTxBodyL`" #-}

outputs' :: TxBody BabbageEra -> StrictSeq (TxOut BabbageEra)
outputs' = (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))
-> (TxBody BabbageEra
    -> StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> TxBody BabbageEra
-> StrictSeq (BabbageTxOut BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxBodyRaw -> StrictSeq (Sized (TxOut BabbageEra))
BabbageTxBodyRaw -> StrictSeq (Sized (BabbageTxOut BabbageEra))
btbrOutputs (BabbageTxBodyRaw -> StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictSeq (Sized (BabbageTxOut BabbageEra))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED outputs' "In favor of `outputsTxBodyL`" #-}

collateralReturn' :: TxBody BabbageEra -> StrictMaybe (TxOut BabbageEra)
collateralReturn' = (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))
-> (TxBody BabbageEra
    -> StrictMaybe (Sized (BabbageTxOut BabbageEra)))
-> TxBody BabbageEra
-> StrictMaybe (BabbageTxOut BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxBodyRaw -> StrictMaybe (Sized (TxOut BabbageEra))
BabbageTxBodyRaw -> StrictMaybe (Sized (BabbageTxOut BabbageEra))
btbrCollateralReturn (BabbageTxBodyRaw -> StrictMaybe (Sized (BabbageTxOut BabbageEra)))
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe (Sized (BabbageTxOut BabbageEra))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED collateralReturn' "In favor of `collateralReturnTxBodyL`" #-}

totalCollateral' :: TxBody BabbageEra -> StrictMaybe Coin
totalCollateral' = BabbageTxBodyRaw -> StrictMaybe Coin
btbrTotalCollateral (BabbageTxBodyRaw -> StrictMaybe Coin)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED totalCollateral' "In favor of `totalCollateralTxBodyL`" #-}

certs' :: TxBody BabbageEra -> StrictSeq (TxCert BabbageEra)
certs' = BabbageTxBodyRaw -> StrictSeq (TxCert BabbageEra)
BabbageTxBodyRaw -> StrictSeq (ShelleyTxCert BabbageEra)
btbrCerts (BabbageTxBodyRaw -> StrictSeq (ShelleyTxCert BabbageEra))
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictSeq (ShelleyTxCert BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED certs' "In favor of `certsTxBodyL`" #-}

withdrawals' :: TxBody BabbageEra -> Withdrawals
withdrawals' = BabbageTxBodyRaw -> Withdrawals
btbrWithdrawals (BabbageTxBodyRaw -> Withdrawals)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Withdrawals
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED withdrawals' "In favor of `withdrawalsTxBodyL`" #-}

txfee' :: TxBody BabbageEra -> Coin
txfee' = BabbageTxBodyRaw -> Coin
btbrFee (BabbageTxBodyRaw -> Coin)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED txfee' "In favor of `feeTxBodyL`" #-}

vldt' :: TxBody BabbageEra -> ValidityInterval
vldt' = BabbageTxBodyRaw -> ValidityInterval
btbrValidityInterval (BabbageTxBodyRaw -> ValidityInterval)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> ValidityInterval
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED vldt' "In favor of `vldtTxBodyL`" #-}

update' :: TxBody BabbageEra -> StrictMaybe (Update BabbageEra)
update' = BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra)
btbrUpdate (BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra))
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe (Update BabbageEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED update' "In favor of `updateTxBodyL`" #-}

reqSignerHashes' :: TxBody BabbageEra -> Set (KeyHash 'Witness)
reqSignerHashes' = BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes (BabbageTxBodyRaw -> Set (KeyHash 'Witness))
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> Set (KeyHash 'Witness)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED reqSignerHashes' "In favor of `reqSignerHashesTxBodyL`" #-}

adHash' :: TxBody BabbageEra -> StrictMaybe TxAuxDataHash
adHash' = BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash
btbrAuxDataHash (BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe TxAuxDataHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED adHash' "In favor of `auxDataHashTxBodyL`" #-}

mint' :: TxBody BabbageEra -> MultiAsset
mint' = BabbageTxBodyRaw -> MultiAsset
btbrMint (BabbageTxBodyRaw -> MultiAsset)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> MultiAsset
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED mint' "In favor of `mintTxBodyL`" #-}

scriptIntegrityHash' :: TxBody BabbageEra -> StrictMaybe ScriptIntegrityHash
scriptIntegrityHash' = BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash (BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe ScriptIntegrityHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED scriptIntegrityHash' "In favor of `scriptIntegrityHashTxBodyL`" #-}

txnetworkid' :: TxBody BabbageEra -> StrictMaybe Network
txnetworkid' = BabbageTxBodyRaw -> StrictMaybe Network
btbrNetworkId (BabbageTxBodyRaw -> StrictMaybe Network)
-> (TxBody BabbageEra -> BabbageTxBodyRaw)
-> TxBody BabbageEra
-> StrictMaybe Network
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody BabbageEra -> RawType (TxBody BabbageEra)
TxBody BabbageEra -> BabbageTxBodyRaw
forall t. Memoized t => t -> RawType t
getMemoRawType
{-# DEPRECATED txnetworkid' "In favor of `networkIdTxBodyL`" #-}

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

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

instance EncCBOR BabbageTxBodyRaw where
  encCBOR :: BabbageTxBodyRaw -> Encoding
encCBOR
    BabbageTxBodyRaw
      { Set TxIn
btbrInputs :: BabbageTxBodyRaw -> Set TxIn
btbrInputs :: Set TxIn
btbrInputs
      , Set TxIn
btbrCollateralInputs :: BabbageTxBodyRaw -> Set TxIn
btbrCollateralInputs :: Set TxIn
btbrCollateralInputs
      , Set TxIn
btbrReferenceInputs :: BabbageTxBodyRaw -> Set TxIn
btbrReferenceInputs :: Set TxIn
btbrReferenceInputs
      , StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: BabbageTxBodyRaw -> StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs :: StrictSeq (Sized (TxOut BabbageEra))
btbrOutputs
      , StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: BabbageTxBodyRaw -> StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn :: StrictMaybe (Sized (TxOut BabbageEra))
btbrCollateralReturn
      , StrictMaybe Coin
btbrTotalCollateral :: BabbageTxBodyRaw -> StrictMaybe Coin
btbrTotalCollateral :: StrictMaybe Coin
btbrTotalCollateral
      , StrictSeq (TxCert BabbageEra)
btbrCerts :: BabbageTxBodyRaw -> StrictSeq (TxCert BabbageEra)
btbrCerts :: StrictSeq (TxCert BabbageEra)
btbrCerts
      , Withdrawals
btbrWithdrawals :: BabbageTxBodyRaw -> Withdrawals
btbrWithdrawals :: Withdrawals
btbrWithdrawals
      , Coin
btbrFee :: BabbageTxBodyRaw -> Coin
btbrFee :: Coin
btbrFee
      , btbrValidityInterval :: BabbageTxBodyRaw -> ValidityInterval
btbrValidityInterval = ValidityInterval StrictMaybe SlotNo
bot StrictMaybe SlotNo
top
      , StrictMaybe (Update BabbageEra)
btbrUpdate :: BabbageTxBodyRaw -> StrictMaybe (Update BabbageEra)
btbrUpdate :: StrictMaybe (Update BabbageEra)
btbrUpdate
      , Set (KeyHash 'Witness)
btbrReqSignerHashes :: BabbageTxBodyRaw -> Set (KeyHash 'Witness)
btbrReqSignerHashes :: Set (KeyHash 'Witness)
btbrReqSignerHashes
      , MultiAsset
btbrMint :: BabbageTxBodyRaw -> MultiAsset
btbrMint :: MultiAsset
btbrMint
      , StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: BabbageTxBodyRaw -> StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash :: StrictMaybe ScriptIntegrityHash
btbrScriptIntegrityHash
      , StrictMaybe TxAuxDataHash
btbrAuxDataHash :: BabbageTxBodyRaw -> StrictMaybe TxAuxDataHash
btbrAuxDataHash :: StrictMaybe TxAuxDataHash
btbrAuxDataHash
      , StrictMaybe Network
btbrNetworkId :: BabbageTxBodyRaw -> StrictMaybe Network
btbrNetworkId :: StrictMaybe Network
btbrNetworkId
      } =
      Encode ('Closed 'Sparse) BabbageTxBodyRaw -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode ('Closed 'Sparse) BabbageTxBodyRaw -> Encoding)
-> Encode ('Closed 'Sparse) BabbageTxBodyRaw -> 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 'Witness)
 -> MultiAsset
 -> StrictMaybe ScriptIntegrityHash
 -> StrictMaybe TxAuxDataHash
 -> StrictMaybe Network
 -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
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 'Witness)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw
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 'Witness)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> 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 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (StrictMaybe Coin)
-> Encode
     ('Closed 'Sparse)
     (Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) Coin
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe SlotNo
      -> StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (StrictMaybe SlotNo)
-> Encode
     ('Closed 'Sparse)
     (StrictSeq (ShelleyTxCert BabbageEra)
      -> Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (StrictSeq (ShelleyTxCert BabbageEra))
-> Encode
     ('Closed 'Sparse)
     (Withdrawals
      -> StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) Withdrawals
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe (Update BabbageEra)
      -> StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (StrictMaybe (Update BabbageEra))
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe SlotNo
      -> Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (StrictMaybe SlotNo)
-> Encode
     ('Closed 'Sparse)
     (Set (KeyHash 'Witness)
      -> MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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 'Witness)
   -> MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) (Set (KeyHash 'Witness))
-> Encode
     ('Closed 'Sparse)
     (MultiAsset
      -> StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> (Set (KeyHash 'Witness) -> Bool)
-> Encode ('Closed 'Sparse) (Set (KeyHash 'Witness))
-> Encode ('Closed 'Sparse) (Set (KeyHash 'Witness))
forall t.
(t -> Bool)
-> Encode ('Closed 'Sparse) t -> Encode ('Closed 'Sparse) t
Omit Set (KeyHash 'Witness) -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode ('Closed 'Dense) (Set (KeyHash 'Witness))
-> Encode ('Closed 'Sparse) (Set (KeyHash 'Witness))
forall t.
Word -> Encode ('Closed 'Dense) t -> Encode ('Closed 'Sparse) t
Key Word
14 (Set (KeyHash 'Witness)
-> Encode ('Closed 'Dense) (Set (KeyHash 'Witness))
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To Set (KeyHash 'Witness)
btbrReqSignerHashes))
          Encode
  ('Closed 'Sparse)
  (MultiAsset
   -> StrictMaybe ScriptIntegrityHash
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe Network
   -> BabbageTxBodyRaw)
-> Encode ('Closed 'Sparse) MultiAsset
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe ScriptIntegrityHash
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe Network
      -> BabbageTxBodyRaw)
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)
-> Encode ('Closed 'Sparse) (StrictMaybe ScriptIntegrityHash)
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe TxAuxDataHash
      -> StrictMaybe Network -> BabbageTxBodyRaw)
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)
-> Encode ('Closed 'Sparse) (StrictMaybe TxAuxDataHash)
-> Encode
     ('Closed 'Sparse) (StrictMaybe Network -> BabbageTxBodyRaw)
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)
-> Encode ('Closed 'Sparse) (StrictMaybe Network)
-> Encode ('Closed 'Sparse) BabbageTxBodyRaw
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 DecCBOR BabbageTxBodyRaw where
  decCBOR :: forall s. Decoder s BabbageTxBodyRaw
decCBOR =
    Decode ('Closed 'Dense) BabbageTxBodyRaw
-> Decoder s BabbageTxBodyRaw
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) BabbageTxBodyRaw
 -> Decoder s BabbageTxBodyRaw)
-> Decode ('Closed 'Dense) BabbageTxBodyRaw
-> Decoder s BabbageTxBodyRaw
forall a b. (a -> b) -> a -> b
$
      String
-> BabbageTxBodyRaw
-> (Word -> Field BabbageTxBodyRaw)
-> [(Word, String)]
-> Decode ('Closed 'Dense) BabbageTxBodyRaw
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode ('Closed 'Dense) t
SparseKeyed
        String
"BabbageTxBodyRaw"
        BabbageTxBodyRaw
basicBabbageTxBodyRaw
        Word -> Field BabbageTxBodyRaw
bodyFields
        [(Word, String)]
requiredFields
    where
      bodyFields :: Word -> Field BabbageTxBodyRaw
      bodyFields :: Word -> Field BabbageTxBodyRaw
bodyFields Word
0 = (Set TxIn -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Set TxIn) -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrInputs = x}) Decode ('Closed Any) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
13 = (Set TxIn -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Set TxIn) -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrCollateralInputs = x}) Decode ('Closed Any) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
18 = (Set TxIn -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Set TxIn) -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Set TxIn
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrReferenceInputs = x}) Decode ('Closed Any) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
1 = (StrictSeq (Sized (BabbageTxOut BabbageEra))
 -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode
     ('Closed Any) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\StrictSeq (Sized (BabbageTxOut BabbageEra))
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrOutputs = x}) Decode ('Closed Any) (StrictSeq (Sized (BabbageTxOut BabbageEra)))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
16 = (StrictMaybe (Sized (BabbageTxOut BabbageEra))
 -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Sized (BabbageTxOut BabbageEra))
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe (Sized (BabbageTxOut BabbageEra))
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrCollateralReturn = x}) Decode ('Closed Any) (Sized (BabbageTxOut BabbageEra))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
17 = (StrictMaybe Coin -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) Coin -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe Coin
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrTotalCollateral = x}) Decode ('Closed Any) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
2 = (Coin -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) Coin -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Coin
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrFee = x}) Decode ('Closed Any) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
3 =
        (StrictMaybe SlotNo -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) SlotNo -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield
          (\StrictMaybe SlotNo
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrValidityInterval = (btbrValidityInterval tx) {invalidHereafter = x}})
          Decode ('Closed Any) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
4 = (StrictSeq (ShelleyTxCert BabbageEra)
 -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (StrictSeq (ShelleyTxCert BabbageEra))
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\StrictSeq (ShelleyTxCert BabbageEra)
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrCerts = x}) Decode ('Closed Any) (StrictSeq (ShelleyTxCert BabbageEra))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
5 = (Withdrawals -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) Withdrawals -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Withdrawals
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrWithdrawals = x}) Decode ('Closed Any) Withdrawals
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
6 = (StrictMaybe (Update BabbageEra)
 -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Update BabbageEra)
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe (Update BabbageEra)
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrUpdate = x}) Decode ('Closed Any) (Update BabbageEra)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
7 = (StrictMaybe TxAuxDataHash -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) TxAuxDataHash -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe TxAuxDataHash
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrAuxDataHash = x}) Decode ('Closed Any) TxAuxDataHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
8 =
        (StrictMaybe SlotNo -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) SlotNo -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield
          (\StrictMaybe SlotNo
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrValidityInterval = (btbrValidityInterval tx) {invalidBefore = x}})
          Decode ('Closed Any) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
9 = (MultiAsset -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) MultiAsset -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\MultiAsset
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrMint = x}) Decode ('Closed Any) MultiAsset
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
11 = (StrictMaybe ScriptIntegrityHash
 -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) ScriptIntegrityHash
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe ScriptIntegrityHash
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrScriptIntegrityHash = x}) Decode ('Closed Any) ScriptIntegrityHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
14 = (Set (KeyHash 'Witness) -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) (Set (KeyHash 'Witness))
-> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field (\Set (KeyHash 'Witness)
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrReqSignerHashes = x}) Decode ('Closed Any) (Set (KeyHash 'Witness))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
15 = (StrictMaybe Network -> BabbageTxBodyRaw -> BabbageTxBodyRaw)
-> Decode ('Closed Any) Network -> Field BabbageTxBodyRaw
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield (\StrictMaybe Network
x BabbageTxBodyRaw
tx -> BabbageTxBodyRaw
tx {btbrNetworkId = x}) Decode ('Closed Any) Network
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      bodyFields Word
n = Word -> Field BabbageTxBodyRaw
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 #-}

basicBabbageTxBodyRaw :: BabbageTxBodyRaw
basicBabbageTxBodyRaw :: BabbageTxBodyRaw
basicBabbageTxBodyRaw =
  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 'Witness)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> BabbageTxBodyRaw
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 BabbageEra))
StrictSeq (Sized (BabbageTxOut BabbageEra))
forall a. StrictSeq a
StrictSeq.empty
    StrictMaybe (Sized (TxOut BabbageEra))
StrictMaybe (Sized (BabbageTxOut BabbageEra))
forall a. StrictMaybe a
SNothing
    StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    StrictSeq (TxCert BabbageEra)
StrictSeq (ShelleyTxCert BabbageEra)
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 BabbageEra)
forall a. StrictMaybe a
SNothing
    Set (KeyHash 'Witness)
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