{-# 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 RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Allegra.TxBody (
  AllegraEraTxBody (..),
  TxBody (
    MkAllegraTxBody,
    AllegraTxBody,
    atbAuxDataHash,
    atbCerts,
    atbInputs,
    atbOutputs,
    atbTxFee,
    atbUpdate,
    atbValidityInterval,
    atbWithdrawals
  ),
  basicAllegraTxBody,
  emptyAllegraTxBodyRaw,
  AllegraTxBodyRaw (..),
  StrictMaybe (..),
  ValidityInterval (..),
) where

import Cardano.Ledger.Allegra.Era (AllegraEra)
import Cardano.Ledger.Allegra.Scripts (ValidityInterval (..))
import Cardano.Ledger.Allegra.TxCert ()
import Cardano.Ledger.Allegra.TxOut ()
import Cardano.Ledger.BaseTypes (StrictMaybe (SJust, SNothing))
import Cardano.Ledger.Binary (Annotator, DecCBOR (..), EncCBOR (..), ToCBOR)
import Cardano.Ledger.Binary.Coders (
  Decode (..),
  Encode (..),
  Field,
  decode,
  encode,
  encodeKeyedStrictMaybe,
  field,
  invalidField,
  ofield,
  (!>),
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Core
import Cardano.Ledger.MemoBytes (
  EqRaw,
  Mem,
  MemoBytes,
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.PParams (Update (..))
import Cardano.Ledger.Shelley.TxBody (getShelleyGenesisKeyHashCountTxBody)
import Cardano.Ledger.TxIn (TxIn (..))
import Control.DeepSeq (NFData (..), deepseq)
import qualified Data.Map.Strict as Map
import Data.Sequence.Strict (StrictSeq, fromList)
import Data.Set (Set, empty)
import Data.Typeable
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (InspectHeap (..), NoThunks (..))

class EraTxBody era => AllegraEraTxBody era where
  vldtTxBodyL :: Lens' (TxBody l era) ValidityInterval

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

data AllegraTxBodyRaw ma l era where
  AllegraTxBodyRaw ::
    { forall era ma. AllegraTxBodyRaw ma TopTx era -> Set TxIn
atbrInputs :: !(Set TxIn)
    , forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxOut era)
atbrOutputs :: !(StrictSeq (TxOut era))
    , forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxCert era)
atbrCerts :: !(StrictSeq (TxCert era))
    , forall era ma. AllegraTxBodyRaw ma TopTx era -> Withdrawals
atbrWithdrawals :: !Withdrawals
    , forall era ma. AllegraTxBodyRaw ma TopTx era -> Coin
atbrFee :: !Coin
    , forall era ma. AllegraTxBodyRaw ma TopTx era -> ValidityInterval
atbrValidityInterval :: !ValidityInterval
    , forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe (Update era)
atbrUpdate :: !(StrictMaybe (Update era))
    , forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe TxAuxDataHash
atbrAuxDataHash :: !(StrictMaybe TxAuxDataHash)
    , forall era ma. AllegraTxBodyRaw ma TopTx era -> ma
atbrMint :: !ma
    } ->
    AllegraTxBodyRaw ma TopTx era

deriving instance
  (Era era, Eq (PParamsUpdate era), Eq (TxOut era), Eq (TxCert era), Eq ma) =>
  Eq (AllegraTxBodyRaw ma l era)

deriving instance
  (Era era, Show (TxOut era), Show (TxCert era), Show (PParamsUpdate era), Show ma) =>
  Show (AllegraTxBodyRaw ma l era)

instance
  (Era era, NFData (TxOut era), NFData (TxCert era), NFData (PParamsUpdate era), NFData ma) =>
  NFData (AllegraTxBodyRaw ma l era)
  where
  rnf :: AllegraTxBodyRaw ma l era -> ()
rnf AllegraTxBodyRaw {ma
Set TxIn
StrictMaybe TxAuxDataHash
StrictMaybe (Update era)
Coin
Withdrawals
StrictSeq (TxCert era)
StrictSeq (TxOut era)
ValidityInterval
atbrInputs :: forall era ma. AllegraTxBodyRaw ma TopTx era -> Set TxIn
atbrOutputs :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxOut era)
atbrCerts :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictSeq (TxCert era)
atbrWithdrawals :: forall era ma. AllegraTxBodyRaw ma TopTx era -> Withdrawals
atbrFee :: forall era ma. AllegraTxBodyRaw ma TopTx era -> Coin
atbrValidityInterval :: forall era ma. AllegraTxBodyRaw ma TopTx era -> ValidityInterval
atbrUpdate :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe (Update era)
atbrAuxDataHash :: forall era ma.
AllegraTxBodyRaw ma TopTx era -> StrictMaybe TxAuxDataHash
atbrMint :: forall era ma. AllegraTxBodyRaw ma TopTx era -> ma
atbrInputs :: Set TxIn
atbrOutputs :: StrictSeq (TxOut era)
atbrCerts :: StrictSeq (TxCert era)
atbrWithdrawals :: Withdrawals
atbrFee :: Coin
atbrValidityInterval :: ValidityInterval
atbrUpdate :: StrictMaybe (Update era)
atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrMint :: ma
..} =
    Set TxIn
atbrInputs Set TxIn -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
      StrictSeq (TxOut era)
atbrOutputs StrictSeq (TxOut era) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
        StrictSeq (TxCert era)
atbrCerts StrictSeq (TxCert era) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
          Withdrawals
atbrWithdrawals Withdrawals -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
            Coin
atbrFee Coin -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
              ValidityInterval
atbrValidityInterval ValidityInterval -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                StrictMaybe (Update era)
atbrUpdate StrictMaybe (Update era) -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                  StrictMaybe TxAuxDataHash
atbrAuxDataHash StrictMaybe TxAuxDataHash -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq`
                    ma -> ()
forall a. NFData a => a -> ()
rnf ma
atbrMint

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

instance
  ( DecCBOR ma
  , Monoid ma
  , AllegraEraTxBody era
  , HasEraTxLevel (AllegraTxBodyRaw ma) era
  , STxLevel l era ~ STxTopLevel l era
  , Typeable l
  ) =>
  DecCBOR (AllegraTxBodyRaw ma l era)
  where
  decCBOR :: forall s. Decoder s (AllegraTxBodyRaw ma l era)
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 (AllegraTxBodyRaw ma TopTx era)
 -> Decoder s (AllegraTxBodyRaw ma l era))
-> Decoder s (AllegraTxBodyRaw ma TopTx era)
-> Decoder s (AllegraTxBodyRaw ma l era)
forall a b. (a -> b) -> a -> b
$
      Decode (Closed Dense) (AllegraTxBodyRaw ma TopTx era)
-> Decoder s (AllegraTxBodyRaw ma TopTx era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode (Closed Dense) (AllegraTxBodyRaw ma TopTx era)
 -> Decoder s (AllegraTxBodyRaw ma TopTx era))
-> Decode (Closed Dense) (AllegraTxBodyRaw ma TopTx era)
-> Decoder s (AllegraTxBodyRaw ma TopTx era)
forall a b. (a -> b) -> a -> b
$
        String
-> AllegraTxBodyRaw ma TopTx era
-> (Word -> Field (AllegraTxBodyRaw ma TopTx era))
-> [(Word, String)]
-> Decode (Closed Dense) (AllegraTxBodyRaw ma TopTx era)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode (Closed Dense) t
SparseKeyed
          String
"AllegraTxBodyRaw"
          AllegraTxBodyRaw ma TopTx era
forall ma era. Monoid ma => AllegraTxBodyRaw ma TopTx era
emptyAllegraTxBodyRaw
          Word -> Field (AllegraTxBodyRaw ma TopTx era)
forall ma era.
(DecCBOR ma, EraTxOut era, EraTxCert era) =>
Word -> Field (AllegraTxBodyRaw ma TopTx era)
bodyFields
          [(Word
0, String
"atbrInputs"), (Word
1, String
"atbrOutputs"), (Word
2, String
"atbrFee")]

instance
  ( DecCBOR ma
  , Monoid ma
  , AllegraEraTxBody era
  , HasEraTxLevel (AllegraTxBodyRaw ma) era
  , STxLevel l era ~ STxTopLevel l era
  , Typeable l
  ) =>
  DecCBOR (Annotator (AllegraTxBodyRaw ma l era))
  where
  decCBOR :: forall s. Decoder s (Annotator (AllegraTxBodyRaw ma l era))
decCBOR = AllegraTxBodyRaw ma l era -> Annotator (AllegraTxBodyRaw ma l era)
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AllegraTxBodyRaw ma l era
 -> Annotator (AllegraTxBodyRaw ma l era))
-> Decoder s (AllegraTxBodyRaw ma l era)
-> Decoder s (Annotator (AllegraTxBodyRaw ma l era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (AllegraTxBodyRaw ma l era)
forall s. Decoder s (AllegraTxBodyRaw ma l era)
forall a s. DecCBOR a => Decoder s a
decCBOR

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

-- Sparse encodings of AllegraTxBodyRaw, the key values are fixed by backward compatibility
-- concerns as we want the ShelleyTxBody to deserialise as AllegraTxBody.
-- txXparse and bodyFields should be Duals, visual inspection helps ensure this.
instance
  (EraTxOut era, EraTxCert era, Eq ma, EncCBOR ma, Monoid ma) =>
  EncCBOR (AllegraTxBodyRaw ma l era)
  where
  encCBOR :: AllegraTxBodyRaw ma l era -> Encoding
encCBOR (AllegraTxBodyRaw Set TxIn
inp StrictSeq (TxOut era)
out StrictSeq (TxCert era)
cert Withdrawals
wdrl Coin
fee (ValidityInterval StrictMaybe SlotNo
bot StrictMaybe SlotNo
top) StrictMaybe (Update era)
up StrictMaybe TxAuxDataHash
hash ma
frge) =
    Encode (Closed Sparse) (AllegraTxBodyRaw ma TopTx era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode (Closed Sparse) (AllegraTxBodyRaw ma TopTx era)
 -> Encoding)
-> Encode (Closed Sparse) (AllegraTxBodyRaw ma TopTx era)
-> Encoding
forall a b. (a -> b) -> a -> b
$
      (Set TxIn
 -> StrictSeq (TxOut era)
 -> Coin
 -> StrictMaybe SlotNo
 -> StrictSeq (TxCert era)
 -> Withdrawals
 -> StrictMaybe (Update era)
 -> StrictMaybe TxAuxDataHash
 -> StrictMaybe SlotNo
 -> ma
 -> AllegraTxBodyRaw ma TopTx era)
-> Encode
     (Closed Sparse)
     (Set TxIn
      -> StrictSeq (TxOut era)
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx era)
forall t. t -> Encode (Closed Sparse) t
Keyed
        ( \Set TxIn
i StrictSeq (TxOut era)
o Coin
f StrictMaybe SlotNo
topx StrictSeq (TxCert era)
c Withdrawals
w StrictMaybe (Update era)
u StrictMaybe TxAuxDataHash
h StrictMaybe SlotNo
botx ma
forg ->
            Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ma
-> AllegraTxBodyRaw ma TopTx era
forall era ma.
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ma
-> AllegraTxBodyRaw ma TopTx era
AllegraTxBodyRaw Set TxIn
i StrictSeq (TxOut era)
o StrictSeq (TxCert era)
c Withdrawals
w Coin
f (StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
botx StrictMaybe SlotNo
topx) StrictMaybe (Update era)
u StrictMaybe TxAuxDataHash
h ma
forg
        )
        Encode
  (Closed Sparse)
  (Set TxIn
   -> StrictSeq (TxOut era)
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (Set TxIn)
-> Encode
     (Closed Sparse)
     (StrictSeq (TxOut era)
      -> Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx 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
inp) -- We don't have to send these in TxBodyX order
        Encode
  (Closed Sparse)
  (StrictSeq (TxOut era)
   -> Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictSeq (TxOut era))
-> Encode
     (Closed Sparse)
     (Coin
      -> StrictMaybe SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx 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)
out) -- Just hack up a fake constructor with the lambda.
        Encode
  (Closed Sparse)
  (Coin
   -> StrictMaybe SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) Coin
-> Encode
     (Closed Sparse)
     (StrictMaybe SlotNo
      -> StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx 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)
  (StrictMaybe SlotNo
   -> StrictSeq (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
-> Encode
     (Closed Sparse)
     (StrictSeq (TxCert era)
      -> Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx era)
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 (TxCert era)
   -> Withdrawals
   -> StrictMaybe (Update era)
   -> StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictSeq (TxCert era))
-> Encode
     (Closed Sparse)
     (Withdrawals
      -> StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx 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
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) Withdrawals
-> Encode
     (Closed Sparse)
     (StrictMaybe (Update era)
      -> StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo
      -> ma
      -> AllegraTxBodyRaw ma TopTx 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
   -> StrictMaybe SlotNo
   -> ma
   -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictMaybe (Update era))
-> Encode
     (Closed Sparse)
     (StrictMaybe TxAuxDataHash
      -> StrictMaybe SlotNo -> ma -> AllegraTxBodyRaw ma TopTx 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)
up
        Encode
  (Closed Sparse)
  (StrictMaybe TxAuxDataHash
   -> StrictMaybe SlotNo -> ma -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictMaybe TxAuxDataHash)
-> Encode
     (Closed Sparse)
     (StrictMaybe SlotNo -> ma -> AllegraTxBodyRaw ma TopTx 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
        Encode
  (Closed Sparse)
  (StrictMaybe SlotNo -> ma -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) (StrictMaybe SlotNo)
-> Encode (Closed Sparse) (ma -> AllegraTxBodyRaw ma TopTx era)
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) (ma -> AllegraTxBodyRaw ma TopTx era)
-> Encode (Closed Sparse) ma
-> Encode (Closed Sparse) (AllegraTxBodyRaw ma TopTx era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (ma -> Bool)
-> Encode (Closed Sparse) ma -> Encode (Closed Sparse) ma
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit (ma -> ma -> Bool
forall a. Eq a => a -> a -> Bool
== ma
forall a. Monoid a => a
mempty) (Word -> Encode (Closed Dense) ma -> Encode (Closed Sparse) ma
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
9 (ma -> Encode (Closed Dense) ma
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To ma
frge))

bodyFields ::
  (DecCBOR ma, EraTxOut era, EraTxCert era) => Word -> Field (AllegraTxBodyRaw ma TopTx era)
bodyFields :: forall ma era.
(DecCBOR ma, EraTxOut era, EraTxCert era) =>
Word -> Field (AllegraTxBodyRaw ma TopTx era)
bodyFields Word
0 = (Set TxIn
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 0)) (Set TxIn)
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Set TxIn
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrInputs = x}) Decode (Closed (ZonkAny 0)) (Set TxIn)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
1 = (StrictSeq (TxOut era)
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 1)) (StrictSeq (TxOut era))
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (TxOut era)
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrOutputs = x}) Decode (Closed (ZonkAny 1)) (StrictSeq (TxOut era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
2 = (Coin
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 2)) Coin
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Coin
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrFee = x}) Decode (Closed (ZonkAny 2)) Coin
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
3 =
  (StrictMaybe SlotNo
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 3)) SlotNo
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield
    ( \StrictMaybe SlotNo
x AllegraTxBodyRaw ma TopTx era
tx ->
        AllegraTxBodyRaw ma TopTx era
tx
          { atbrValidityInterval =
              (atbrValidityInterval tx) {invalidHereafter = x}
          }
    )
    Decode (Closed (ZonkAny 3)) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
4 = (StrictSeq (TxCert era)
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 4)) (StrictSeq (TxCert era))
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\StrictSeq (TxCert era)
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrCerts = x}) Decode (Closed (ZonkAny 4)) (StrictSeq (TxCert era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
5 = (Withdrawals
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 5)) Withdrawals
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\Withdrawals
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrWithdrawals = x}) Decode (Closed (ZonkAny 5)) Withdrawals
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
6 = (StrictMaybe (Update era)
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 6)) (Update era)
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe (Update era)
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrUpdate = x}) Decode (Closed (ZonkAny 6)) (Update era)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
7 = (StrictMaybe TxAuxDataHash
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 7)) TxAuxDataHash
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield (\StrictMaybe TxAuxDataHash
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrAuxDataHash = x}) Decode (Closed (ZonkAny 7)) TxAuxDataHash
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
8 =
  (StrictMaybe SlotNo
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 8)) SlotNo
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode (Closed d) x -> Field t
ofield
    ( \StrictMaybe SlotNo
x AllegraTxBodyRaw ma TopTx era
tx ->
        AllegraTxBodyRaw ma TopTx era
tx
          { atbrValidityInterval =
              (atbrValidityInterval tx) {invalidBefore = x}
          }
    )
    Decode (Closed (ZonkAny 8)) SlotNo
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
9 = (ma
 -> AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma TopTx era)
-> Decode (Closed (ZonkAny 9)) ma
-> Field (AllegraTxBodyRaw ma TopTx era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (\ma
x AllegraTxBodyRaw ma TopTx era
tx -> AllegraTxBodyRaw ma TopTx era
tx {atbrMint = x}) Decode (Closed (ZonkAny 9)) ma
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
bodyFields Word
n = Word -> Field (AllegraTxBodyRaw ma TopTx era)
forall t. Word -> Field t
invalidField Word
n

basicAllegraTxBody ::
  forall era l ma.
  ( EraTxBody era
  , Memoized (TxBody l era)
  , RawType (TxBody l era) ~ AllegraTxBodyRaw ma l era
  , HasEraTxLevel (AllegraTxBodyRaw ma) era
  , STxLevel l era ~ STxTopLevel l era
  , Typeable l
  , EncCBOR ma
  , Monoid ma
  , Eq ma
  ) =>
  TxBody l era
basicAllegraTxBody :: forall era (l :: TxLevel) ma.
(EraTxBody era, Memoized (TxBody l era),
 RawType (TxBody l era) ~ AllegraTxBodyRaw ma l era,
 HasEraTxLevel (AllegraTxBodyRaw ma) era,
 STxLevel l era ~ STxTopLevel l era, Typeable l, EncCBOR ma,
 Monoid ma, Eq ma) =>
TxBody l era
basicAllegraTxBody =
  forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era (RawType (TxBody l era) -> TxBody l era)
-> RawType (TxBody l era) -> TxBody l era
forall a b. (a -> b) -> a -> b
$ AllegraTxBodyRaw ma TopTx era -> AllegraTxBodyRaw ma l era
forall (l :: TxLevel) (t :: TxLevel -> * -> *) era.
(Typeable l, HasEraTxLevel t era,
 STxLevel l era ~ STxTopLevel l era) =>
t TopTx era -> t l era
asSTxTopLevel (forall ma era. Monoid ma => AllegraTxBodyRaw ma TopTx era
emptyAllegraTxBodyRaw @ma @era)

emptyAllegraTxBodyRaw :: Monoid ma => AllegraTxBodyRaw ma TopTx era
emptyAllegraTxBodyRaw :: forall ma era. Monoid ma => AllegraTxBodyRaw ma TopTx era
emptyAllegraTxBodyRaw =
  AllegraTxBodyRaw
    { atbrInputs :: Set TxIn
atbrInputs = Set TxIn
forall a. Set a
empty
    , atbrOutputs :: StrictSeq (TxOut era)
atbrOutputs = [TxOut era] -> StrictSeq (TxOut era)
forall a. [a] -> StrictSeq a
fromList []
    , atbrCerts :: StrictSeq (TxCert era)
atbrCerts = [TxCert era] -> StrictSeq (TxCert era)
forall a. [a] -> StrictSeq a
fromList []
    , atbrWithdrawals :: Withdrawals
atbrWithdrawals = Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
forall k a. Map k a
Map.empty
    , atbrFee :: Coin
atbrFee = Integer -> Coin
Coin Integer
0
    , atbrValidityInterval :: ValidityInterval
atbrValidityInterval = StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing
    , atbrUpdate :: StrictMaybe (Update era)
atbrUpdate = StrictMaybe (Update era)
forall a. StrictMaybe a
SNothing
    , atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrAuxDataHash = StrictMaybe TxAuxDataHash
forall a. StrictMaybe a
SNothing
    , atbrMint :: ma
atbrMint = ma
forall a. Monoid a => a
mempty
    }

instance Memoized (TxBody l AllegraEra) where
  type RawType (TxBody l AllegraEra) = AllegraTxBodyRaw () l AllegraEra

deriving via
  Mem (AllegraTxBodyRaw () l AllegraEra)
  instance
    Typeable l => DecCBOR (Annotator (TxBody l AllegraEra))

deriving instance Eq (TxBody l AllegraEra)

deriving instance Show (TxBody l AllegraEra)

deriving instance Generic (TxBody l AllegraEra)

type instance MemoHashIndex (AllegraTxBodyRaw c l era) = EraIndependentTxBody

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

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

-- | A pattern to keep the newtype and the MemoBytes hidden
pattern AllegraTxBody ::
  (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
  Set TxIn ->
  StrictSeq (TxOut AllegraEra) ->
  StrictSeq (TxCert AllegraEra) ->
  Withdrawals ->
  Coin ->
  ValidityInterval ->
  StrictMaybe (Update AllegraEra) ->
  StrictMaybe TxAuxDataHash ->
  TxBody TopTx AllegraEra
pattern $mAllegraTxBody :: forall {r}.
(EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra
-> (Set TxIn
    -> StrictSeq (TxOut AllegraEra)
    -> StrictSeq (TxCert AllegraEra)
    -> Withdrawals
    -> Coin
    -> ValidityInterval
    -> StrictMaybe (Update AllegraEra)
    -> StrictMaybe TxAuxDataHash
    -> r)
-> ((# #) -> r)
-> r
$bAllegraTxBody :: (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
Set TxIn
-> StrictSeq (TxOut AllegraEra)
-> StrictSeq (TxCert AllegraEra)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update AllegraEra)
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx AllegraEra
AllegraTxBody
  { (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> Set TxIn
atbInputs
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> StrictSeq (TxOut AllegraEra)
atbOutputs
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> StrictSeq (TxCert AllegraEra)
atbCerts
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> Withdrawals
atbWithdrawals
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> Coin
atbTxFee
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> ValidityInterval
atbValidityInterval
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> StrictMaybe (Update AllegraEra)
atbUpdate
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody TopTx AllegraEra -> StrictMaybe TxAuxDataHash
atbAuxDataHash
  } <-
  ( getMemoRawType ->
      AllegraTxBodyRaw
        { atbrInputs = atbInputs
        , atbrOutputs = atbOutputs
        , atbrCerts = atbCerts
        , atbrWithdrawals = atbWithdrawals
        , atbrFee = atbTxFee
        , atbrValidityInterval = atbValidityInterval
        , atbrUpdate = atbUpdate
        , atbrAuxDataHash = atbAuxDataHash
        }
    )
  where
    AllegraTxBody
      Set TxIn
inputs
      StrictSeq (TxOut AllegraEra)
outputs
      StrictSeq (TxCert AllegraEra)
certs
      Withdrawals
withdrawals
      Coin
txFee
      ValidityInterval
validityInterval
      StrictMaybe (Update AllegraEra)
update
      StrictMaybe TxAuxDataHash
auxDataHash =
        forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @AllegraEra (RawType (TxBody TopTx AllegraEra) -> TxBody TopTx AllegraEra)
-> RawType (TxBody TopTx AllegraEra) -> TxBody TopTx AllegraEra
forall a b. (a -> b) -> a -> b
$
          AllegraTxBodyRaw
            { atbrInputs :: Set TxIn
atbrInputs = Set TxIn
inputs
            , atbrOutputs :: StrictSeq (TxOut AllegraEra)
atbrOutputs = StrictSeq (TxOut AllegraEra)
outputs
            , atbrCerts :: StrictSeq (TxCert AllegraEra)
atbrCerts = StrictSeq (TxCert AllegraEra)
certs
            , atbrWithdrawals :: Withdrawals
atbrWithdrawals = Withdrawals
withdrawals
            , atbrFee :: Coin
atbrFee = Coin
txFee
            , atbrValidityInterval :: ValidityInterval
atbrValidityInterval = ValidityInterval
validityInterval
            , atbrUpdate :: StrictMaybe (Update AllegraEra)
atbrUpdate = StrictMaybe (Update AllegraEra)
update
            , atbrAuxDataHash :: StrictMaybe TxAuxDataHash
atbrAuxDataHash = StrictMaybe TxAuxDataHash
auxDataHash
            , atbrMint :: ()
atbrMint = ()
            }

{-# COMPLETE AllegraTxBody #-}

instance EraTxBody AllegraEra where
  newtype TxBody l AllegraEra = MkAllegraTxBody (MemoBytes (AllegraTxBodyRaw () l AllegraEra))
    deriving newtype (TxBody l AllegraEra -> Int
TxBody l AllegraEra -> ByteString
(TxBody l AllegraEra -> ByteString)
-> (TxBody l AllegraEra -> Int)
-> (forall i. Proxy i -> TxBody l AllegraEra -> SafeHash i)
-> SafeToHash (TxBody l AllegraEra)
forall i. Proxy i -> TxBody l AllegraEra -> SafeHash i
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall (l :: TxLevel). TxBody l AllegraEra -> Int
forall (l :: TxLevel). TxBody l AllegraEra -> ByteString
forall (l :: TxLevel) i.
Proxy i -> TxBody l AllegraEra -> SafeHash i
$coriginalBytes :: forall (l :: TxLevel). TxBody l AllegraEra -> ByteString
originalBytes :: TxBody l AllegraEra -> ByteString
$coriginalBytesSize :: forall (l :: TxLevel). TxBody l AllegraEra -> Int
originalBytesSize :: TxBody l AllegraEra -> Int
$cmakeHashWithExplicitProxys :: forall (l :: TxLevel) i.
Proxy i -> TxBody l AllegraEra -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxBody l AllegraEra -> SafeHash i
SafeToHash, Typeable (TxBody l AllegraEra)
Typeable (TxBody l AllegraEra) =>
(TxBody l AllegraEra -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxBody l AllegraEra) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxBody l AllegraEra] -> Size)
-> ToCBOR (TxBody l AllegraEra)
TxBody l AllegraEra -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l AllegraEra] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l AllegraEra) -> 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 AllegraEra)
forall (l :: TxLevel).
Typeable l =>
TxBody l AllegraEra -> Encoding
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l AllegraEra] -> Size
forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l AllegraEra) -> Size
$ctoCBOR :: forall (l :: TxLevel).
Typeable l =>
TxBody l AllegraEra -> Encoding
toCBOR :: TxBody l AllegraEra -> Encoding
$cencodedSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l AllegraEra) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody l AllegraEra) -> Size
$cencodedListSizeExpr :: forall (l :: TxLevel).
Typeable l =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l AllegraEra] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody l AllegraEra] -> Size
ToCBOR, TxBody l AllegraEra -> Encoding
(TxBody l AllegraEra -> Encoding) -> EncCBOR (TxBody l AllegraEra)
forall a. (a -> Encoding) -> EncCBOR a
forall (l :: TxLevel). TxBody l AllegraEra -> Encoding
$cencCBOR :: forall (l :: TxLevel). TxBody l AllegraEra -> Encoding
encCBOR :: TxBody l AllegraEra -> Encoding
EncCBOR, Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
Proxy (TxBody l AllegraEra) -> String
(Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo))
-> (Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo))
-> (Proxy (TxBody l AllegraEra) -> String)
-> NoThunks (TxBody l AllegraEra)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
forall (l :: TxLevel).
Typeable l =>
Proxy (TxBody l AllegraEra) -> String
$cnoThunks :: forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall (l :: TxLevel).
Typeable l =>
Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxBody l AllegraEra -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall (l :: TxLevel).
Typeable l =>
Proxy (TxBody l AllegraEra) -> String
showTypeOf :: Proxy (TxBody l AllegraEra) -> String
NoThunks, TxBody l AllegraEra -> ()
(TxBody l AllegraEra -> ()) -> NFData (TxBody l AllegraEra)
forall a. (a -> ()) -> NFData a
forall (l :: TxLevel). TxBody l AllegraEra -> ()
$crnf :: forall (l :: TxLevel). TxBody l AllegraEra -> ()
rnf :: TxBody l AllegraEra -> ()
NFData)

  mkBasicTxBody :: forall (l :: TxLevel). Typeable l => TxBody l AllegraEra
mkBasicTxBody = forall era (l :: TxLevel) ma.
(EraTxBody era, Memoized (TxBody l era),
 RawType (TxBody l era) ~ AllegraTxBodyRaw ma l era,
 HasEraTxLevel (AllegraTxBodyRaw ma) era,
 STxLevel l era ~ STxTopLevel l era, Typeable l, EncCBOR ma,
 Monoid ma, Eq ma) =>
TxBody l era
basicAllegraTxBody @AllegraEra

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

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

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

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

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

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

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

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

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

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

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

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

instance EqRaw (TxBody l AllegraEra)