{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# 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
  ),
  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 (SlotNo, StrictMaybe (SJust, SNothing))
import Cardano.Ledger.Binary (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,
  MemoBytes,
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.PParams (Update (..), upgradeUpdate)
import Cardano.Ledger.Shelley.TxBody (getShelleyGenesisKeyHashCountTxBody)
import Cardano.Ledger.TxIn (TxIn (..))
import Control.DeepSeq (NFData (..))
import qualified Data.Map.Strict as Map
import Data.Sequence.Strict (StrictSeq, fromList)
import Data.Set (Set, empty)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks (..))

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

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

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

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

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

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

deriving instance Generic (AllegraTxBodyRaw ma era)

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

instance (DecCBOR ma, Monoid ma, AllegraEraTxBody era) => DecCBOR (AllegraTxBodyRaw ma era) where
  decCBOR :: forall s. Decoder s (AllegraTxBodyRaw ma era)
decCBOR =
    Decode ('Closed 'Dense) (AllegraTxBodyRaw ma era)
-> Decoder s (AllegraTxBodyRaw ma era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode
      ( String
-> AllegraTxBodyRaw ma era
-> (Word -> Field (AllegraTxBodyRaw ma era))
-> [(Word, String)]
-> Decode ('Closed 'Dense) (AllegraTxBodyRaw ma era)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode ('Closed 'Dense) t
SparseKeyed
          String
"AllegraTxBodyRaw"
          AllegraTxBodyRaw ma era
forall ma era. Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw
          Word -> Field (AllegraTxBodyRaw ma era)
forall ma era.
(DecCBOR ma, EraTxOut era, EraTxCert era) =>
Word -> Field (AllegraTxBodyRaw ma era)
bodyFields
          [(Word
0, String
"atbrInputs"), (Word
1, String
"atbrOutputs"), (Word
2, String
"atbrFee")]
      )

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

emptyAllegraTxBodyRaw :: Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw :: forall ma era. Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw =
  Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ma
-> AllegraTxBodyRaw ma era
forall ma era.
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> ValidityInterval
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ma
-> AllegraTxBodyRaw ma era
AllegraTxBodyRaw
    Set TxIn
forall a. Set a
empty
    ([TxOut era] -> StrictSeq (TxOut era)
forall a. [a] -> StrictSeq a
fromList [])
    ([TxCert era] -> StrictSeq (TxCert era)
forall a. [a] -> StrictSeq a
fromList [])
    (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
forall k a. Map k a
Map.empty)
    (Integer -> Coin
Coin Integer
0)
    (StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing)
    StrictMaybe (Update era)
forall a. StrictMaybe a
SNothing
    StrictMaybe TxAuxDataHash
forall a. StrictMaybe a
SNothing
    ma
forall a. Monoid a => a
mempty

-- ===========================================================================
-- Wrap it all up in a newtype, hiding the insides with a pattern construtor.

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

deriving instance Eq (TxBody AllegraEra)

deriving instance Show (TxBody AllegraEra)

deriving instance Generic (TxBody AllegraEra)

deriving newtype instance NoThunks (TxBody AllegraEra)

deriving newtype instance NFData (TxBody AllegraEra)

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

type instance MemoHashIndex (AllegraTxBodyRaw c era) = EraIndependentTxBody

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

-- | 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 AllegraEra
pattern $mAllegraTxBody :: forall {r}.
(EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody 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 AllegraEra
AllegraTxBody
  { (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> Set TxIn
atbInputs
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> StrictSeq (TxOut AllegraEra)
atbOutputs
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> StrictSeq (TxCert AllegraEra)
atbCerts
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> Withdrawals
atbWithdrawals
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> Coin
atbTxFee
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> ValidityInterval
atbValidityInterval
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody AllegraEra -> StrictMaybe (Update AllegraEra)
atbUpdate
  , (EraTxOut AllegraEra, EraTxCert AllegraEra) =>
TxBody 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 AllegraEra) -> TxBody AllegraEra)
-> RawType (TxBody AllegraEra) -> TxBody 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 AllegraEra = MkAllegraTxBody (MemoBytes (AllegraTxBodyRaw () AllegraEra))
    deriving newtype (TxBody AllegraEra -> Int
TxBody AllegraEra -> ByteString
(TxBody AllegraEra -> ByteString)
-> (TxBody AllegraEra -> Int)
-> (forall i. Proxy i -> TxBody AllegraEra -> SafeHash i)
-> SafeToHash (TxBody AllegraEra)
forall i. Proxy i -> TxBody AllegraEra -> SafeHash i
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
$coriginalBytes :: TxBody AllegraEra -> ByteString
originalBytes :: TxBody AllegraEra -> ByteString
$coriginalBytesSize :: TxBody AllegraEra -> Int
originalBytesSize :: TxBody AllegraEra -> Int
$cmakeHashWithExplicitProxys :: forall i. Proxy i -> TxBody AllegraEra -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxBody AllegraEra -> SafeHash i
SafeToHash, Typeable (TxBody AllegraEra)
Typeable (TxBody AllegraEra) =>
(TxBody AllegraEra -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxBody AllegraEra) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxBody AllegraEra] -> Size)
-> ToCBOR (TxBody AllegraEra)
TxBody AllegraEra -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody AllegraEra] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody 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
$ctoCBOR :: TxBody AllegraEra -> Encoding
toCBOR :: TxBody AllegraEra -> Encoding
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody AllegraEra) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxBody AllegraEra) -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody AllegraEra] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxBody AllegraEra] -> Size
ToCBOR, Typeable (TxBody AllegraEra)
Typeable (TxBody AllegraEra) =>
(forall s. Decoder s (TxBody AllegraEra))
-> (forall s. Proxy (TxBody AllegraEra) -> Decoder s ())
-> (Proxy (TxBody AllegraEra) -> Text)
-> DecCBOR (TxBody AllegraEra)
Proxy (TxBody AllegraEra) -> Text
forall s. Decoder s (TxBody AllegraEra)
forall a.
Typeable a =>
(forall s. Decoder s a)
-> (forall s. Proxy a -> Decoder s ())
-> (Proxy a -> Text)
-> DecCBOR a
forall s. Proxy (TxBody AllegraEra) -> Decoder s ()
$cdecCBOR :: forall s. Decoder s (TxBody AllegraEra)
decCBOR :: forall s. Decoder s (TxBody AllegraEra)
$cdropCBOR :: forall s. Proxy (TxBody AllegraEra) -> Decoder s ()
dropCBOR :: forall s. Proxy (TxBody AllegraEra) -> Decoder s ()
$clabel :: Proxy (TxBody AllegraEra) -> Text
label :: Proxy (TxBody AllegraEra) -> Text
DecCBOR)

  mkBasicTxBody :: TxBody AllegraEra
mkBasicTxBody = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @AllegraEra RawType (TxBody AllegraEra)
AllegraTxBodyRaw () AllegraEra
forall ma era. Monoid ma => AllegraTxBodyRaw ma era
emptyAllegraTxBodyRaw

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

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

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

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

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

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

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

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

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

  upgradeTxBody :: EraTxBody (PreviousEra AllegraEra) =>
TxBody (PreviousEra AllegraEra)
-> Either (TxBodyUpgradeError AllegraEra) (TxBody AllegraEra)
upgradeTxBody TxBody (PreviousEra AllegraEra)
txBody = do
    StrictSeq (TxCert AllegraEra)
certs <- (TxCert (PreviousEra AllegraEra)
 -> Either Void (TxCert AllegraEra))
-> StrictSeq (TxCert (PreviousEra AllegraEra))
-> Either Void (StrictSeq (TxCert AllegraEra))
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 TxCert (PreviousEra AllegraEra) -> Either Void (TxCert AllegraEra)
TxCert (PreviousEra AllegraEra)
-> Either (TxCertUpgradeError AllegraEra) (TxCert AllegraEra)
forall era.
(EraTxCert era, EraTxCert (PreviousEra era)) =>
TxCert (PreviousEra era)
-> Either (TxCertUpgradeError era) (TxCert era)
upgradeTxCert (TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting
     (StrictSeq (TxCert (PreviousEra AllegraEra)))
     (TxBody ShelleyEra)
     (StrictSeq (TxCert (PreviousEra AllegraEra)))
-> StrictSeq (TxCert (PreviousEra AllegraEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (TxCert (PreviousEra AllegraEra)))
  (TxBody ShelleyEra)
  (StrictSeq (TxCert (PreviousEra AllegraEra)))
(StrictSeq (TxCert ShelleyEra)
 -> Const
      (StrictSeq (TxCert (PreviousEra AllegraEra)))
      (StrictSeq (TxCert ShelleyEra)))
-> TxBody ShelleyEra
-> Const
     (StrictSeq (TxCert (PreviousEra AllegraEra))) (TxBody ShelleyEra)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxCert era))
Lens' (TxBody ShelleyEra) (StrictSeq (TxCert ShelleyEra))
certsTxBodyL)
    TxBody AllegraEra -> Either Void (TxBody AllegraEra)
forall a. a -> Either Void a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxBody AllegraEra -> Either Void (TxBody AllegraEra))
-> TxBody AllegraEra -> Either Void (TxBody AllegraEra)
forall a b. (a -> b) -> a -> b
$
      AllegraTxBody
        { atbInputs :: Set TxIn
atbInputs = TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting (Set TxIn) (TxBody ShelleyEra) (Set TxIn) -> Set TxIn
forall s a. s -> Getting a s a -> a
^. Getting (Set TxIn) (TxBody ShelleyEra) (Set TxIn)
forall era. EraTxBody era => Lens' (TxBody era) (Set TxIn)
Lens' (TxBody ShelleyEra) (Set TxIn)
inputsTxBodyL
        , atbOutputs :: StrictSeq (TxOut AllegraEra)
atbOutputs = TxOut (PreviousEra AllegraEra) -> TxOut AllegraEra
TxOut (PreviousEra AllegraEra) -> ShelleyTxOut AllegraEra
forall era.
(EraTxOut era, EraTxOut (PreviousEra era)) =>
TxOut (PreviousEra era) -> TxOut era
upgradeTxOut (TxOut (PreviousEra AllegraEra) -> ShelleyTxOut AllegraEra)
-> StrictSeq (TxOut (PreviousEra AllegraEra))
-> StrictSeq (ShelleyTxOut AllegraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting
     (StrictSeq (TxOut (PreviousEra AllegraEra)))
     (TxBody ShelleyEra)
     (StrictSeq (TxOut (PreviousEra AllegraEra)))
-> StrictSeq (TxOut (PreviousEra AllegraEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (TxOut (PreviousEra AllegraEra)))
  (TxBody ShelleyEra)
  (StrictSeq (TxOut (PreviousEra AllegraEra)))
(StrictSeq (TxOut ShelleyEra)
 -> Const
      (StrictSeq (TxOut (PreviousEra AllegraEra)))
      (StrictSeq (TxOut ShelleyEra)))
-> TxBody ShelleyEra
-> Const
     (StrictSeq (TxOut (PreviousEra AllegraEra))) (TxBody ShelleyEra)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody ShelleyEra) (StrictSeq (TxOut ShelleyEra))
outputsTxBodyL)
        , atbCerts :: StrictSeq (TxCert AllegraEra)
atbCerts = StrictSeq (TxCert AllegraEra)
certs
        , atbWithdrawals :: Withdrawals
atbWithdrawals = TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting Withdrawals (TxBody ShelleyEra) Withdrawals
-> Withdrawals
forall s a. s -> Getting a s a -> a
^. Getting Withdrawals (TxBody ShelleyEra) Withdrawals
forall era. EraTxBody era => Lens' (TxBody era) Withdrawals
Lens' (TxBody ShelleyEra) Withdrawals
withdrawalsTxBodyL
        , atbTxFee :: Coin
atbTxFee = TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra -> Getting Coin (TxBody ShelleyEra) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. Getting Coin (TxBody ShelleyEra) Coin
forall era. EraTxBody era => Lens' (TxBody era) Coin
Lens' (TxBody ShelleyEra) Coin
feeTxBodyL
        , atbValidityInterval :: ValidityInterval
atbValidityInterval = SlotNo -> ValidityInterval
ttlToValidityInterval (TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting SlotNo (TxBody ShelleyEra) SlotNo -> SlotNo
forall s a. s -> Getting a s a -> a
^. Getting SlotNo (TxBody ShelleyEra) SlotNo
forall era.
(ShelleyEraTxBody era, ExactEra ShelleyEra era) =>
Lens' (TxBody era) SlotNo
Lens' (TxBody ShelleyEra) SlotNo
ttlTxBodyL)
        , atbUpdate :: StrictMaybe (Update AllegraEra)
atbUpdate = UpgradePParams StrictMaybe AllegraEra
-> Update (PreviousEra AllegraEra) -> Update AllegraEra
forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
UpgradePParams StrictMaybe era
-> Update (PreviousEra era) -> Update era
upgradeUpdate () (Update ShelleyEra -> Update AllegraEra)
-> StrictMaybe (Update ShelleyEra)
-> StrictMaybe (Update AllegraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting
     (StrictMaybe (Update ShelleyEra))
     (TxBody ShelleyEra)
     (StrictMaybe (Update ShelleyEra))
-> StrictMaybe (Update ShelleyEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (Update ShelleyEra))
  (TxBody ShelleyEra)
  (StrictMaybe (Update ShelleyEra))
forall era.
ShelleyEraTxBody era =>
Lens' (TxBody era) (StrictMaybe (Update era))
Lens' (TxBody ShelleyEra) (StrictMaybe (Update ShelleyEra))
updateTxBodyL)
        , atbAuxDataHash :: StrictMaybe TxAuxDataHash
atbAuxDataHash = TxBody (PreviousEra AllegraEra)
TxBody ShelleyEra
txBody TxBody ShelleyEra
-> Getting
     (StrictMaybe TxAuxDataHash)
     (TxBody ShelleyEra)
     (StrictMaybe TxAuxDataHash)
-> StrictMaybe TxAuxDataHash
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe TxAuxDataHash)
  (TxBody ShelleyEra)
  (StrictMaybe TxAuxDataHash)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictMaybe TxAuxDataHash)
Lens' (TxBody ShelleyEra) (StrictMaybe TxAuxDataHash)
auxDataHashTxBodyL
        }
    where
      ttlToValidityInterval :: SlotNo -> ValidityInterval
      ttlToValidityInterval :: SlotNo -> ValidityInterval
ttlToValidityInterval SlotNo
ttl = StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval StrictMaybe SlotNo
forall a. StrictMaybe a
SNothing (SlotNo -> StrictMaybe SlotNo
forall a. a -> StrictMaybe a
SJust SlotNo
ttl)

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

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

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

instance EqRaw (TxBody AllegraEra)