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

module Cardano.Ledger.Shelley.TxBody (
  TxBody (
    ShelleyTxBody,
    MkShelleyTxBody,
    stbInputs,
    stbOutputs,
    stbCerts,
    stbWithdrawals,
    stbTxFee,
    stbTTL,
    stbUpdate,
    stbMDHash
  ),
  ShelleyEraTxBody (..),
  ShelleyTxBodyRaw (..),
  EraIndependentTxBody,
  RewardAccount (..),
  Withdrawals (..),
  getShelleyGenesisKeyHashCountTxBody,
) where

import Cardano.Ledger.Address (RewardAccount (..), Withdrawals (..))
import Cardano.Ledger.BaseTypes (StrictMaybe (..))
import Cardano.Ledger.Binary (
  Annotator,
  DecCBOR (decCBOR),
  EncCBOR (..),
  ToCBOR (..),
 )
import Cardano.Ledger.Binary.Coders (
  Decode (..),
  Density (..),
  Encode (..),
  Field,
  Wrapped (..),
  decode,
  encode,
  encodeKeyedStrictMaybe,
  field,
  invalidField,
  ofield,
  (!>),
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Core
import Cardano.Ledger.MemoBytes (
  EqRaw (..),
  Mem,
  MemoBytes,
  MemoHashIndex,
  Memoized (..),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.Era (ShelleyEra)
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (..), Update (..))
import Cardano.Ledger.Shelley.TxCert (ShelleyEraTxCert (..))
import Cardano.Ledger.Shelley.TxOut ()
import Cardano.Ledger.Slot (SlotNo (..))
import Cardano.Ledger.TxIn (TxIn)
import Control.DeepSeq (NFData (..), deepseq)
import qualified Data.Map.Strict as Map
import Data.Sequence.Strict (StrictSeq)
import qualified Data.Sequence.Strict as StrictSeq
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Typeable
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (InspectHeap (..), NoThunks (..))

class (ShelleyEraTxCert era, EraTxBody era, AtMostEra "Babbage" era) => ShelleyEraTxBody era where
  ttlTxBodyL :: ExactEra ShelleyEra era => Lens' (TxBody TopTx era) SlotNo

  updateTxBodyL :: Lens' (TxBody TopTx era) (StrictMaybe (Update era))

-- ==============================
-- The underlying type for TxBody

data ShelleyTxBodyRaw l era where
  ShelleyTxBodyRaw ::
    { forall era. ShelleyTxBodyRaw TopTx era -> Set TxIn
stbrInputs :: !(Set TxIn)
    , forall era. ShelleyTxBodyRaw TopTx era -> StrictSeq (TxOut era)
stbrOutputs :: !(StrictSeq (TxOut era))
    , forall era. ShelleyTxBodyRaw TopTx era -> StrictSeq (TxCert era)
stbrCerts :: !(StrictSeq (TxCert era))
    , forall era. ShelleyTxBodyRaw TopTx era -> Withdrawals
stbrWithdrawals :: !Withdrawals
    , forall era. ShelleyTxBodyRaw TopTx era -> Coin
stbrFee :: !Coin
    , forall era. ShelleyTxBodyRaw TopTx era -> SlotNo
stbrTtl :: !SlotNo
    , forall era. ShelleyTxBodyRaw TopTx era -> StrictMaybe (Update era)
stbrUpdate :: !(StrictMaybe (Update era))
    , forall era. ShelleyTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
stbrAuxDataHash :: !(StrictMaybe TxAuxDataHash)
    } ->
    ShelleyTxBodyRaw TopTx era

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

deriving via
  InspectHeap (ShelleyTxBodyRaw l era)
  instance
    (Typeable era, Typeable l) => NoThunks (ShelleyTxBodyRaw l era)

instance EraTxBody era => NFData (ShelleyTxBodyRaw t era) where
  rnf :: ShelleyTxBodyRaw t era -> ()
rnf ShelleyTxBodyRaw {Withdrawals
stbrWithdrawals :: forall era. ShelleyTxBodyRaw TopTx era -> Withdrawals
stbrWithdrawals :: Withdrawals
stbrWithdrawals, StrictMaybe (Update era)
stbrUpdate :: forall era. ShelleyTxBodyRaw TopTx era -> StrictMaybe (Update era)
stbrUpdate :: StrictMaybe (Update era)
stbrUpdate, StrictMaybe TxAuxDataHash
stbrAuxDataHash :: forall era. ShelleyTxBodyRaw TopTx era -> StrictMaybe TxAuxDataHash
stbrAuxDataHash :: StrictMaybe TxAuxDataHash
stbrAuxDataHash} =
    Withdrawals
stbrWithdrawals Withdrawals -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` StrictMaybe (Update era)
stbrUpdate StrictMaybe (Update era) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` StrictMaybe TxAuxDataHash -> ()
forall a. NFData a => a -> ()
rnf StrictMaybe TxAuxDataHash
stbrAuxDataHash

deriving instance EraTxBody era => Eq (ShelleyTxBodyRaw l era)

deriving instance EraTxBody era => Show (ShelleyTxBodyRaw l era)

instance Typeable l => DecCBOR (ShelleyTxBodyRaw l ShelleyEra) where
  decCBOR :: forall s. Decoder s (ShelleyTxBodyRaw l ShelleyEra)
decCBOR =
    forall (l :: TxLevel) (t :: TxLevel -> * -> *) (m :: * -> *) era.
(Typeable l, Monad m, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
m (t TopTx era) -> m (t l era)
mkSTxTopLevelM @l (Decoder s (ShelleyTxBodyRaw TopTx ShelleyEra)
 -> Decoder s (ShelleyTxBodyRaw l ShelleyEra))
-> Decoder s (ShelleyTxBodyRaw TopTx ShelleyEra)
-> Decoder s (ShelleyTxBodyRaw l ShelleyEra)
forall a b. (a -> b) -> a -> b
$
      Decode (Closed Dense) (ShelleyTxBodyRaw TopTx ShelleyEra)
-> Decoder s (ShelleyTxBodyRaw TopTx ShelleyEra)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode (Closed Dense) (ShelleyTxBodyRaw TopTx ShelleyEra)
 -> Decoder s (ShelleyTxBodyRaw TopTx ShelleyEra))
-> Decode (Closed Dense) (ShelleyTxBodyRaw TopTx ShelleyEra)
-> Decoder s (ShelleyTxBodyRaw TopTx ShelleyEra)
forall a b. (a -> b) -> a -> b
$
        String
-> ShelleyTxBodyRaw TopTx ShelleyEra
-> (Word -> Field (ShelleyTxBodyRaw TopTx ShelleyEra))
-> [(Word, String)]
-> Decode (Closed Dense) (ShelleyTxBodyRaw TopTx ShelleyEra)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode (Closed Dense) t
SparseKeyed
          String
"TxBody"
          ShelleyTxBodyRaw TopTx ShelleyEra
forall era. ShelleyTxBodyRaw TopTx era
basicShelleyTxBodyRaw
          Word -> Field (ShelleyTxBodyRaw TopTx ShelleyEra)
forall era (t :: TxLevel).
EraTxBody era =>
Word -> Field (ShelleyTxBodyRaw t era)
boxBody
          [(Word
0, String
"inputs"), (Word
1, String
"outputs"), (Word
2, String
"fee"), (Word
3, String
"ttl")]

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

-- =================================================================
-- Composable components for building TxBody optional sparse serialisers.
-- The order of serializing optional fields, and their key values is
-- demanded by backward compatibility concerns.

-- | Choose a de-serialiser when given the key (of type Word).
--   Wrap it in a Field which pairs it with its update function which
--   changes only the field being deserialised.
boxBody :: EraTxBody era => Word -> Field (ShelleyTxBodyRaw t era)
boxBody :: forall era (t :: TxLevel).
EraTxBody era =>
Word -> Field (ShelleyTxBodyRaw t era)
boxBody Word
0 = (Set TxIn -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 0)) (Set TxIn)
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set TxIn
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrInputs = x}) Decode (Closed (ZonkAny 0)) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
1 = (StrictSeq (TxOut era)
 -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 1)) (StrictSeq (TxOut era))
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (TxOut era)
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrOutputs = x}) Decode (Closed (ZonkAny 1)) (StrictSeq (TxOut era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
4 = (StrictSeq (TxCert era)
 -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 2)) (StrictSeq (TxCert era))
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (TxCert era)
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrCerts = x}) Decode (Closed (ZonkAny 2)) (StrictSeq (TxCert era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
5 = (Withdrawals -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 3)) Withdrawals
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Withdrawals
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrWithdrawals = x}) Decode (Closed (ZonkAny 3)) Withdrawals
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
2 = (Coin -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 4)) Coin
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Coin
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrFee = x}) Decode (Closed (ZonkAny 4)) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
3 = (SlotNo -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 5)) SlotNo
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\SlotNo
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrTtl = x}) Decode (Closed (ZonkAny 5)) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
6 = (StrictMaybe (Update era)
 -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 6)) (Update era)
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe (Update era)
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrUpdate = x}) Decode (Closed (ZonkAny 6)) (Update era)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
7 = (StrictMaybe TxAuxDataHash
 -> ShelleyTxBodyRaw t era -> ShelleyTxBodyRaw t era)
-> Decode (Closed (ZonkAny 7)) TxAuxDataHash
-> Field (ShelleyTxBodyRaw t era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe TxAuxDataHash
x ShelleyTxBodyRaw t era
tx -> ShelleyTxBodyRaw t era
tx {stbrAuxDataHash = x}) Decode (Closed (ZonkAny 7)) TxAuxDataHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
boxBody Word
n = Word -> Field (ShelleyTxBodyRaw t era)
forall t. Word -> Field t
invalidField Word
n

-- | Tells how to serialise each field, and what tag to label it with in the
--   serialisation. boxBody and txSparse should be Duals, visually inspect
--   The key order looks strange but was choosen for backward compatibility.
txSparse ::
  EraTxBody era =>
  ShelleyTxBodyRaw t era -> Encode (Closed Sparse) (ShelleyTxBodyRaw t era)
txSparse :: forall era (t :: TxLevel).
EraTxBody era =>
ShelleyTxBodyRaw t era
-> Encode (Closed Sparse) (ShelleyTxBodyRaw t era)
txSparse (ShelleyTxBodyRaw Set TxIn
input StrictSeq (TxOut era)
output StrictSeq (TxCert era)
cert Withdrawals
wdrl Coin
fee SlotNo
ttl StrictMaybe (Update era)
update StrictMaybe TxAuxDataHash
hash) =
  (Set TxIn
 -> StrictSeq (TxOut era)
 -> Coin
 -> SlotNo
 -> StrictSeq (TxCert era)
 -> Withdrawals
 -> StrictMaybe (Update era)
 -> StrictMaybe TxAuxDataHash
 -> ShelleyTxBodyRaw t era)
-> Encode
     (Closed Sparse)
     (Set TxIn
      -> StrictSeq (TxOut era)
      -> Coin
      -> SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
forall t. t -> Encode (Closed Sparse) t
Keyed (\Set TxIn
i StrictSeq (TxOut era)
o Coin
f SlotNo
t StrictSeq (TxCert era)
c Withdrawals
w StrictMaybe (Update era)
u StrictMaybe TxAuxDataHash
h -> Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBodyRaw TopTx era
forall era.
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBodyRaw TopTx era
ShelleyTxBodyRaw Set TxIn
i StrictSeq (TxOut era)
o StrictSeq (TxCert era)
c Withdrawals
w Coin
f SlotNo
t StrictMaybe (Update era)
u StrictMaybe TxAuxDataHash
h)
    Encode
  (Closed Sparse)
  (Set TxIn
   -> StrictSeq (TxOut era)
   -> Coin
   -> SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode
     (Closed Sparse)
     (StrictSeq (TxOut era)
      -> Coin
      -> SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
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
input) -- We don't have to send these in ShelleyTxBodyRaw order
    Encode
  (Closed Sparse)
  (StrictSeq (TxOut era)
   -> Coin
   -> SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) (StrictSeq (TxOut era))
-> Encode
     (Closed Sparse)
     (Coin
      -> SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> Encode (Closed Dense) (StrictSeq (TxOut era))
-> Encode (Closed Sparse) (StrictSeq (TxOut era))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
1 (StrictSeq (TxOut era)
-> Encode (Closed Dense) (StrictSeq (TxOut era))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To StrictSeq (TxOut era)
output) -- Just hack up a fake constructor with the lambda.
    Encode
  (Closed Sparse)
  (Coin
   -> SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) Coin
-> Encode
     (Closed Sparse)
     (SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
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
fee)
    Encode
  (Closed Sparse)
  (SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) SlotNo
-> Encode
     (Closed Sparse)
     (StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> Encode (Closed Dense) SlotNo -> Encode (Closed Sparse) SlotNo
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
3 (SlotNo -> Encode (Closed Dense) SlotNo
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To SlotNo
ttl)
    Encode
  (Closed Sparse)
  (StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) (StrictSeq (TxCert era))
-> Encode
     (Closed Sparse)
     (Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> ShelleyTxBodyRaw t era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (StrictSeq (TxCert era) -> Bool)
-> Encode (Closed Sparse) (StrictSeq (TxCert era))
-> Encode (Closed Sparse) (StrictSeq (TxCert era))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit StrictSeq (TxCert era) -> Bool
forall a. StrictSeq a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (StrictSeq (TxCert era))
-> Encode (Closed Sparse) (StrictSeq (TxCert era))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
4 (StrictSeq (TxCert era)
-> Encode (Closed Dense) (StrictSeq (TxCert era))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To StrictSeq (TxCert era)
cert))
    Encode
  (Closed Sparse)
  (Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) Withdrawals
-> Encode
     (Closed Sparse)
     (StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash -> ShelleyTxBodyRaw t era)
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
wdrl))
    Encode
  (Closed Sparse)
  (StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) (StrictMaybe (Update era))
-> Encode
     (Closed Sparse)
     (StrictMaybe TxAuxDataHash -> ShelleyTxBodyRaw t era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Word
-> StrictMaybe (Update era)
-> Encode (Closed Sparse) (StrictMaybe (Update era))
forall a.
EncCBOR a =>
Word -> StrictMaybe a -> Encode (Closed Sparse) (StrictMaybe a)
encodeKeyedStrictMaybe Word
6 StrictMaybe (Update era)
update
    Encode
  (Closed Sparse)
  (StrictMaybe TxAuxDataHash -> ShelleyTxBodyRaw t era)
-> Encode (Closed Sparse) (StrictMaybe TxAuxDataHash)
-> Encode (Closed Sparse) (ShelleyTxBodyRaw t era)
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
hash

-- The initial TxBody. We will overide some of these fields as we build a TxBody,
-- adding one field at a time, using optional serialisers, inside the Pattern.
basicShelleyTxBodyRaw :: ShelleyTxBodyRaw TopTx era
basicShelleyTxBodyRaw :: forall era. ShelleyTxBodyRaw TopTx era
basicShelleyTxBodyRaw =
  ShelleyTxBodyRaw
    { stbrInputs :: Set TxIn
stbrInputs = Set TxIn
forall a. Set a
Set.empty
    , stbrOutputs :: StrictSeq (TxOut era)
stbrOutputs = StrictSeq (TxOut era)
forall a. StrictSeq a
StrictSeq.empty
    , stbrFee :: Coin
stbrFee = Integer -> Coin
Coin Integer
0
    , stbrTtl :: SlotNo
stbrTtl = Word64 -> SlotNo
SlotNo Word64
forall a. Bounded a => a
maxBound -- transaction is eternally valid by default
    , stbrCerts :: StrictSeq (TxCert era)
stbrCerts = StrictSeq (TxCert era)
forall a. StrictSeq a
StrictSeq.empty
    , stbrWithdrawals :: Withdrawals
stbrWithdrawals = Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
forall k a. Map k a
Map.empty
    , stbrUpdate :: StrictMaybe (Update era)
stbrUpdate = StrictMaybe (Update era)
forall a. StrictMaybe a
SNothing
    , stbrAuxDataHash :: StrictMaybe TxAuxDataHash
stbrAuxDataHash = StrictMaybe TxAuxDataHash
forall a. StrictMaybe a
SNothing
    }

instance EraTxBody era => EncCBOR (ShelleyTxBodyRaw l era) where
  encCBOR :: ShelleyTxBodyRaw l era -> Encoding
encCBOR = Encode (Closed Sparse) (ShelleyTxBodyRaw l era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode (Closed Sparse) (ShelleyTxBodyRaw l era) -> Encoding)
-> (ShelleyTxBodyRaw l era
    -> Encode (Closed Sparse) (ShelleyTxBodyRaw l era))
-> ShelleyTxBodyRaw l era
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyTxBodyRaw l era
-> Encode (Closed Sparse) (ShelleyTxBodyRaw l era)
forall era (t :: TxLevel).
EraTxBody era =>
ShelleyTxBodyRaw t era
-> Encode (Closed Sparse) (ShelleyTxBodyRaw t era)
txSparse

instance Memoized (TxBody l ShelleyEra) where
  type RawType (TxBody l ShelleyEra) = ShelleyTxBodyRaw l ShelleyEra

instance EqRaw (TxBody l ShelleyEra)

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

instance EraTxBody ShelleyEra where
  newtype TxBody l ShelleyEra = MkShelleyTxBody (MemoBytes (ShelleyTxBodyRaw l ShelleyEra))
    deriving ((forall x. TxBody l ShelleyEra -> Rep (TxBody l ShelleyEra) x)
-> (forall x. Rep (TxBody l ShelleyEra) x -> TxBody l ShelleyEra)
-> Generic (TxBody l ShelleyEra)
forall x. Rep (TxBody l ShelleyEra) x -> TxBody l ShelleyEra
forall x. TxBody l ShelleyEra -> Rep (TxBody l ShelleyEra) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (l :: TxLevel) x.
Rep (TxBody l ShelleyEra) x -> TxBody l ShelleyEra
forall (l :: TxLevel) x.
TxBody l ShelleyEra -> Rep (TxBody l ShelleyEra) x
$cfrom :: forall (l :: TxLevel) x.
TxBody l ShelleyEra -> Rep (TxBody l ShelleyEra) x
from :: forall x. TxBody l ShelleyEra -> Rep (TxBody l ShelleyEra) x
$cto :: forall (l :: TxLevel) x.
Rep (TxBody l ShelleyEra) x -> TxBody l ShelleyEra
to :: forall x. Rep (TxBody l ShelleyEra) x -> TxBody l ShelleyEra
Generic)
    deriving newtype (TxBody l ShelleyEra -> Int
TxBody l ShelleyEra -> ByteString
(TxBody l ShelleyEra -> ByteString)
-> (TxBody l ShelleyEra -> Int)
-> (forall i. Proxy i -> TxBody l ShelleyEra -> SafeHash i)
-> SafeToHash (TxBody l ShelleyEra)
forall i. Proxy i -> TxBody l ShelleyEra -> SafeHash i
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall (l :: TxLevel). TxBody l ShelleyEra -> Int
forall (l :: TxLevel). TxBody l ShelleyEra -> ByteString
forall (l :: TxLevel) i.
Proxy i -> TxBody l ShelleyEra -> SafeHash i
$coriginalBytes :: forall (l :: TxLevel). TxBody l ShelleyEra -> ByteString
originalBytes :: TxBody l ShelleyEra -> ByteString
$coriginalBytesSize :: forall (l :: TxLevel). TxBody l ShelleyEra -> Int
originalBytesSize :: TxBody l ShelleyEra -> Int
$cmakeHashWithExplicitProxys :: forall (l :: TxLevel) i.
Proxy i -> TxBody l ShelleyEra -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxBody l ShelleyEra -> SafeHash i
SafeToHash, Typeable (TxBody l ShelleyEra)
Typeable (TxBody l ShelleyEra) =>
(TxBody l ShelleyEra -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxBody l ShelleyEra) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxBody l ShelleyEra] -> Size)
-> ToCBOR (TxBody l ShelleyEra)
TxBody l ShelleyEra -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l ShelleyEra] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l ShelleyEra) -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall (l :: TxLevel). Typeable l => Typeable (TxBody l ShelleyEra)
forall (l :: TxLevel).
Typeable l =>
TxBody l ShelleyEra -> Encoding
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l ShelleyEra] -> Size
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l ShelleyEra) -> Size
$ctoCBOR :: forall (l :: TxLevel).
Typeable l =>
TxBody l ShelleyEra -> Encoding
toCBOR :: TxBody l ShelleyEra -> Encoding
$cencodedSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l ShelleyEra) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l ShelleyEra) -> Size
$cencodedListSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l ShelleyEra] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l ShelleyEra] -> Size
ToCBOR, TxBody l ShelleyEra -> Encoding
(TxBody l ShelleyEra -> Encoding) -> EncCBOR (TxBody l ShelleyEra)
forall a. (a -> Encoding) -> EncCBOR a
forall (l :: TxLevel). TxBody l ShelleyEra -> Encoding
$cencCBOR :: forall (l :: TxLevel). TxBody l ShelleyEra -> Encoding
encCBOR :: TxBody l ShelleyEra -> Encoding
EncCBOR)

  mkBasicTxBody :: forall (l :: TxLevel). Typeable l => TxBody l ShelleyEra
mkBasicTxBody = TxBody TopTx ShelleyEra -> TxBody l ShelleyEra
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel (TxBody TopTx ShelleyEra -> TxBody l ShelleyEra)
-> TxBody TopTx ShelleyEra -> TxBody l ShelleyEra
forall a b. (a -> b) -> a -> b
$ forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @ShelleyEra RawType (TxBody TopTx ShelleyEra)
ShelleyTxBodyRaw TopTx ShelleyEra
forall era. ShelleyTxBodyRaw TopTx era
basicShelleyTxBodyRaw

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

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

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

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

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

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

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

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

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

instance ShelleyEraTxBody ShelleyEra where
  ttlTxBodyL :: ExactEra ShelleyEra ShelleyEra =>
Lens' (TxBody TopTx ShelleyEra) SlotNo
ttlTxBodyL =
    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 @ShelleyEra RawType (TxBody TopTx ShelleyEra) -> SlotNo
ShelleyTxBodyRaw TopTx ShelleyEra -> SlotNo
forall era. ShelleyTxBodyRaw TopTx era -> SlotNo
stbrTtl ((RawType (TxBody TopTx ShelleyEra)
  -> SlotNo -> RawType (TxBody TopTx ShelleyEra))
 -> Lens' (TxBody TopTx ShelleyEra) SlotNo)
-> (RawType (TxBody TopTx ShelleyEra)
    -> SlotNo -> RawType (TxBody TopTx ShelleyEra))
-> Lens' (TxBody TopTx ShelleyEra) SlotNo
forall a b. (a -> b) -> a -> b
$ \RawType (TxBody TopTx ShelleyEra)
txBodyRaw SlotNo
ttl -> RawType (TxBody TopTx ShelleyEra)
txBodyRaw {stbrTtl = ttl}
  {-# INLINEABLE ttlTxBodyL #-}

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

deriving newtype instance Typeable l => NoThunks (TxBody l ShelleyEra)

deriving newtype instance NFData (TxBody l ShelleyEra)

deriving instance Show (TxBody l ShelleyEra)

deriving instance Eq (TxBody l ShelleyEra)

deriving via
  Mem (ShelleyTxBodyRaw l ShelleyEra)
  instance
    Typeable l => DecCBOR (Annotator (TxBody l ShelleyEra))

-- | Pattern for use by external users
pattern ShelleyTxBody ::
  Set TxIn ->
  StrictSeq (TxOut ShelleyEra) ->
  StrictSeq (TxCert ShelleyEra) ->
  Withdrawals ->
  Coin ->
  SlotNo ->
  StrictMaybe (Update ShelleyEra) ->
  StrictMaybe TxAuxDataHash ->
  TxBody TopTx ShelleyEra
pattern $mShelleyTxBody :: forall {r}.
TxBody TopTx ShelleyEra
-> (Set TxIn
    -> StrictSeq (TxOut ShelleyEra)
    -> StrictSeq (TxCert ShelleyEra)
    -> Withdrawals
    -> Coin
    -> SlotNo
    -> StrictMaybe (Update ShelleyEra)
    -> StrictMaybe TxAuxDataHash
    -> r)
-> ((# #) -> r)
-> r
$bShelleyTxBody :: Set TxIn
-> StrictSeq (TxOut ShelleyEra)
-> StrictSeq (TxCert ShelleyEra)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update ShelleyEra)
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx ShelleyEra
ShelleyTxBody
  { TxBody TopTx ShelleyEra -> Set TxIn
stbInputs
  , TxBody TopTx ShelleyEra -> StrictSeq (TxOut ShelleyEra)
stbOutputs
  , TxBody TopTx ShelleyEra -> StrictSeq (TxCert ShelleyEra)
stbCerts
  , TxBody TopTx ShelleyEra -> Withdrawals
stbWithdrawals
  , TxBody TopTx ShelleyEra -> Coin
stbTxFee
  , TxBody TopTx ShelleyEra -> SlotNo
stbTTL
  , TxBody TopTx ShelleyEra -> StrictMaybe (Update ShelleyEra)
stbUpdate
  , TxBody TopTx ShelleyEra -> StrictMaybe TxAuxDataHash
stbMDHash
  } <-
  ( getMemoRawType ->
      ShelleyTxBodyRaw
        { stbrInputs = stbInputs
        , stbrOutputs = stbOutputs
        , stbrCerts = stbCerts
        , stbrWithdrawals = stbWithdrawals
        , stbrFee = stbTxFee
        , stbrTtl = stbTTL
        , stbrUpdate = stbUpdate
        , stbrAuxDataHash = stbMDHash
        }
    )
  where
    ShelleyTxBody
      Set TxIn
inputs
      StrictSeq (TxOut ShelleyEra)
outputs
      StrictSeq (TxCert ShelleyEra)
certs
      Withdrawals
withdrawals
      Coin
fee
      SlotNo
ttl
      StrictMaybe (Update ShelleyEra)
update
      StrictMaybe TxAuxDataHash
auxDataHash =
        forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @ShelleyEra (RawType (TxBody TopTx ShelleyEra) -> TxBody TopTx ShelleyEra)
-> RawType (TxBody TopTx ShelleyEra) -> TxBody TopTx ShelleyEra
forall a b. (a -> b) -> a -> b
$
          ShelleyTxBodyRaw
            { stbrInputs :: Set TxIn
stbrInputs = Set TxIn
inputs
            , stbrOutputs :: StrictSeq (TxOut ShelleyEra)
stbrOutputs = StrictSeq (TxOut ShelleyEra)
outputs
            , stbrCerts :: StrictSeq (TxCert ShelleyEra)
stbrCerts = StrictSeq (TxCert ShelleyEra)
certs
            , stbrWithdrawals :: Withdrawals
stbrWithdrawals = Withdrawals
withdrawals
            , stbrFee :: Coin
stbrFee = Coin
fee
            , stbrTtl :: SlotNo
stbrTtl = SlotNo
ttl
            , stbrUpdate :: StrictMaybe (Update ShelleyEra)
stbrUpdate = StrictMaybe (Update ShelleyEra)
update
            , stbrAuxDataHash :: StrictMaybe TxAuxDataHash
stbrAuxDataHash = StrictMaybe TxAuxDataHash
auxDataHash
            }

{-# COMPLETE ShelleyTxBody #-}

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

type instance MemoHashIndex (ShelleyTxBodyRaw t era) = EraIndependentTxBody

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

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

-- | Count number of Genesis keys supplied in the `updateTxBodyL` field.
getShelleyGenesisKeyHashCountTxBody :: ShelleyEraTxBody era => TxBody TopTx era -> Int
getShelleyGenesisKeyHashCountTxBody :: forall era. ShelleyEraTxBody era => TxBody TopTx era -> Int
getShelleyGenesisKeyHashCountTxBody TxBody TopTx era
txBody =
  case TxBody TopTx era
txBody TxBody TopTx era
-> Getting
     (StrictMaybe (Update era))
     (TxBody TopTx era)
     (StrictMaybe (Update era))
-> StrictMaybe (Update era)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (Update era))
  (TxBody TopTx era)
  (StrictMaybe (Update era))
forall era.
ShelleyEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe (Update era))
Lens' (TxBody TopTx era) (StrictMaybe (Update era))
updateTxBodyL of
    SJust (Update (ProposedPPUpdates Map (KeyHash GenesisRole) (PParamsUpdate era)
m) EpochNo
_) -> Map (KeyHash GenesisRole) (PParamsUpdate era) -> Int
forall k a. Map k a -> Int
Map.size Map (KeyHash GenesisRole) (PParamsUpdate era)
m
    StrictMaybe (Update era)
_ -> Int
0