{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Test.Cardano.Ledger.Alonzo.Binary.Annotator (
  module Test.Cardano.Ledger.Mary.Binary.Annotator,
) where

import Cardano.Ledger.Alonzo (AlonzoEra)
import Cardano.Ledger.Alonzo.Scripts
import Cardano.Ledger.Alonzo.Tx hiding (wits)
import Cardano.Ledger.Alonzo.TxAuxData
import Cardano.Ledger.Alonzo.TxBody
import Cardano.Ledger.Alonzo.TxSeq.Internal
import Cardano.Ledger.Alonzo.TxWits
import Cardano.Ledger.Binary
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Core
import Cardano.Ledger.Plutus
import Cardano.Ledger.Shelley.BlockChain (auxDataSeqDecoder)
import qualified Data.List.NonEmpty as NE
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.MapExtras as Map (fromElems)
import Data.Maybe.Strict (maybeToStrictMaybe)
import qualified Data.Sequence as Seq
import qualified Data.Sequence.Strict as StrictSeq
import qualified Data.Set as Set
import Data.Typeable (Typeable)
import Lens.Micro
import Test.Cardano.Ledger.Common
import Test.Cardano.Ledger.Mary.Binary.Annotator
import Test.Cardano.Ledger.Shelley.Arbitrary ()

instance Era era => DecCBOR (Annotator (TxDatsRaw era)) where
  decCBOR :: forall s. Decoder s (Annotator (TxDatsRaw era))
decCBOR =
    Version
-> Decoder s (Annotator (TxDatsRaw era))
-> Decoder s (Annotator (TxDatsRaw era))
-> Decoder s (Annotator (TxDatsRaw era))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
      (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
          Decoder s ()
-> Decoder s (Annotator (TxDatsRaw era))
-> Decoder s (Annotator (TxDatsRaw era))
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s (NonEmpty (Annotator (Data era)))
-> (NonEmpty (Data era) -> TxDatsRaw era)
-> Decoder s (Annotator (TxDatsRaw era))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA
            (Decoder s (Annotator (Data era))
-> Decoder s (NonEmpty (Annotator (Data era)))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Annotator (Data era))
forall s. Decoder s (Annotator (Data era))
forall a s. DecCBOR a => Decoder s a
decCBOR)
            (Map DataHash (Data era) -> TxDatsRaw era
forall era. Map DataHash (Data era) -> TxDatsRaw era
TxDatsRaw (Map DataHash (Data era) -> TxDatsRaw era)
-> (NonEmpty (Data era) -> Map DataHash (Data era))
-> NonEmpty (Data era)
-> TxDatsRaw era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Data era -> DataHash) -> [Data era] -> Map DataHash (Data era)
forall (f :: * -> *) k v.
(Foldable f, Ord k) =>
(v -> k) -> f v -> Map k v
Map.fromElems Data era -> DataHash
forall era. Data era -> DataHash
hashData ([Data era] -> Map DataHash (Data era))
-> (NonEmpty (Data era) -> [Data era])
-> NonEmpty (Data era)
-> Map DataHash (Data era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Data era) -> [Data era]
forall a. NonEmpty a -> [a]
NE.toList)
      )
      (Decoder s [Annotator (Data era)]
-> ([Data era] -> TxDatsRaw era)
-> Decoder s (Annotator (TxDatsRaw era))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator (Data era))
-> Decoder s [Annotator (Data era)]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Annotator (Data era))
forall s. Decoder s (Annotator (Data era))
forall a s. DecCBOR a => Decoder s a
decCBOR) (Map DataHash (Data era) -> TxDatsRaw era
forall era. Map DataHash (Data era) -> TxDatsRaw era
TxDatsRaw (Map DataHash (Data era) -> TxDatsRaw era)
-> ([Data era] -> Map DataHash (Data era))
-> [Data era]
-> TxDatsRaw era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Data era -> DataHash) -> [Data era] -> Map DataHash (Data era)
forall (f :: * -> *) k v.
(Foldable f, Ord k) =>
(v -> k) -> f v -> Map k v
Map.fromElems Data era -> DataHash
forall era. Data era -> DataHash
hashData))
  {-# INLINE decCBOR #-}

deriving via
  Mem (TxDatsRaw era)
  instance
    Era era => DecCBOR (Annotator (TxDats era))

instance AlonzoEraScript era => DecCBOR (Annotator (RedeemersRaw era)) where
  decCBOR :: forall s. Decoder s (Annotator (RedeemersRaw era))
decCBOR = do
    Version
-> Decoder s (Annotator (RedeemersRaw era))
-> Decoder s (Annotator (RedeemersRaw era))
-> Decoder s (Annotator (RedeemersRaw era))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
      (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      ( Decoder s TokenType
forall s. Decoder s TokenType
peekTokenType Decoder s TokenType
-> (TokenType -> Decoder s (Annotator (RedeemersRaw era)))
-> Decoder s (Annotator (RedeemersRaw era))
forall a b. Decoder s a -> (a -> Decoder s b) -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
          TokenType
TypeMapLenIndef -> Decoder s (Annotator (RedeemersRaw era))
forall s. Decoder s (Annotator (RedeemersRaw era))
decodeMapRedeemers
          TokenType
TypeMapLen -> Decoder s (Annotator (RedeemersRaw era))
forall s. Decoder s (Annotator (RedeemersRaw era))
decodeMapRedeemers
          TokenType
_ -> Decoder s (Annotator (RedeemersRaw era))
decodeListRedeemers
      )
      ( Decoder s [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
-> ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> RedeemersRaw era)
-> Decoder s (Annotator (RedeemersRaw era))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA
          (Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder
     s [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall s.
Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
decodeAnnElement)
          (Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> RedeemersRaw era
forall era.
Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> RedeemersRaw era
RedeemersRaw (Map (PlutusPurpose AsIx era) (Data era, ExUnits)
 -> RedeemersRaw era)
-> ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
-> RedeemersRaw era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(PlutusPurpose AsIx era, (Data era, ExUnits))]
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList)
      )
    where
      decodeRedeemersWith :: Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw b))
decodeRedeemersWith Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
nonEmptyDecoder =
        Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
-> (NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
    -> RedeemersRaw b)
-> Decoder s (Annotator (RedeemersRaw b))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA
          Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
nonEmptyDecoder
          (Map (PlutusPurpose AsIx b) (Data b, ExUnits) -> RedeemersRaw b
forall era.
Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> RedeemersRaw era
RedeemersRaw (Map (PlutusPurpose AsIx b) (Data b, ExUnits) -> RedeemersRaw b)
-> (NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
    -> Map (PlutusPurpose AsIx b) (Data b, ExUnits))
-> NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
-> RedeemersRaw b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(PlutusPurpose AsIx b, (Data b, ExUnits))]
-> Map (PlutusPurpose AsIx b) (Data b, ExUnits)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(PlutusPurpose AsIx b, (Data b, ExUnits))]
 -> Map (PlutusPurpose AsIx b) (Data b, ExUnits))
-> (NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
    -> [(PlutusPurpose AsIx b, (Data b, ExUnits))])
-> NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
-> Map (PlutusPurpose AsIx b) (Data b, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (PlutusPurpose AsIx b, (Data b, ExUnits))
-> [(PlutusPurpose AsIx b, (Data b, ExUnits))]
forall a. NonEmpty a -> [a]
NE.toList)
      decodeMapRedeemers :: Decoder s (Annotator (RedeemersRaw era))
decodeMapRedeemers = Decoder
  s
  (NonEmpty
     (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw era))
forall {b} {s}.
Ord (PlutusPurpose AsIx b) =>
Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw b))
decodeRedeemersWith (Decoder
   s
   (NonEmpty
      (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
 -> Decoder s (Annotator (RedeemersRaw era)))
-> Decoder
     s
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw era))
forall a b. (a -> b) -> a -> b
$ do
        (Int
_, [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
xs) <- Decoder s (Maybe Int)
-> (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
    -> [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))])
-> ([Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> Decoder
         s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Decoder
     s (Int, [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))])
forall s a b.
Monoid b =>
Decoder s (Maybe Int)
-> (a -> b -> b) -> (b -> Decoder s a) -> Decoder s (Int, b)
decodeListLikeWithCount Decoder s (Maybe Int)
forall s. Decoder s (Maybe Int)
decodeMapLenOrIndef (:) (([Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
  -> Decoder
       s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
 -> Decoder
      s (Int, [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]))
-> ([Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> Decoder
         s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Decoder
     s (Int, [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))])
forall a b. (a -> b) -> a -> b
$ \[Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
_ -> do
          PlutusPurpose AsIx era
ptr <- Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          (Annotator (Data era)
annData, ExUnits
exUnits) <- Decoder s (Annotator (Data era), ExUnits)
forall s. Decoder s (Annotator (Data era), ExUnits)
forall a s. DecCBOR a => Decoder s a
decCBOR
          Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> Decoder
      s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a b. (a -> b) -> a -> b
$ (\Data era
d -> (PlutusPurpose AsIx era
ptr, (Data era
d, ExUnits
exUnits))) (Data era -> (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Annotator (Data era)
-> Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Annotator (Data era)
annData
        case [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
-> Maybe
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
forall a. [a] -> Maybe (NonEmpty a)
NE.nonEmpty [Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))]
xs of
          Maybe
  (NonEmpty
     (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
Nothing -> String
-> Decoder
     s
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected redeemers map to be non-empty"
          Just NonEmpty (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
neList -> NonEmpty (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder
     s
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NonEmpty (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
 -> Decoder
      s
      (NonEmpty
         (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))))
-> NonEmpty
     (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder
     s
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
forall a b. (a -> b) -> a -> b
$ NonEmpty (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> NonEmpty
     (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a. NonEmpty a -> NonEmpty a
NE.reverse NonEmpty (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
neList
      decodeListRedeemers :: Decoder s (Annotator (RedeemersRaw era))
decodeListRedeemers =
        Decoder
  s
  (NonEmpty
     (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw era))
forall {b} {s}.
Ord (PlutusPurpose AsIx b) =>
Decoder
  s (NonEmpty (Annotator (PlutusPurpose AsIx b, (Data b, ExUnits))))
-> Decoder s (Annotator (RedeemersRaw b))
decodeRedeemersWith (Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder
     s
     (NonEmpty
        (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall s.
Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
decodeAnnElement)
      decodeAnnElement ::
        forall s. Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
      decodeAnnElement :: forall s.
Decoder s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
decodeAnnElement = do
        (PlutusPurpose AsIx era
rdmrPtr, Annotator (Data era)
dat, ExUnits
ex) <- Decoder s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
forall s.
Decoder s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
decodeElement
        let f :: a -> a -> b -> (a, (a, b))
f a
x a
y b
z = (a
x, (a
y, b
z))
        Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> Decoder
      s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (Annotator (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a b. (a -> b) -> a -> b
$ PlutusPurpose AsIx era
-> Data era
-> ExUnits
-> (PlutusPurpose AsIx era, (Data era, ExUnits))
forall {a} {a} {b}. a -> a -> b -> (a, (a, b))
f PlutusPurpose AsIx era
rdmrPtr (Data era
 -> ExUnits -> (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Annotator (Data era)
-> Annotator
     (ExUnits -> (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Annotator (Data era)
dat Annotator
  (ExUnits -> (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Annotator ExUnits
-> Annotator (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a b. Annotator (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ExUnits -> Annotator ExUnits
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ExUnits
ex
      {-# INLINE decodeAnnElement #-}
      decodeElement ::
        forall s. Decoder s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
      decodeElement :: forall s.
Decoder s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
decodeElement = do
        Text
-> ((PlutusPurpose AsIx era, Annotator (Data era), ExUnits) -> Int)
-> Decoder
     s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
-> Decoder
     s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed
          Text
"Redeemer"
          (\(PlutusPurpose AsIx era
rdmrPtr, Annotator (Data era)
_, ExUnits
_) -> Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (PlutusPurpose AsIx era -> Word
forall a. EncCBORGroup a => a -> Word
listLen PlutusPurpose AsIx era
rdmrPtr) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
          (Decoder s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
 -> Decoder
      s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
-> Decoder
     s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
-> Decoder
     s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
forall a b. (a -> b) -> a -> b
$ (,,) (PlutusPurpose AsIx era
 -> Annotator (Data era)
 -> ExUnits
 -> (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
-> Decoder s (PlutusPurpose AsIx era)
-> Decoder
     s
     (Annotator (Data era)
      -> ExUnits
      -> (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBORGroup a => Decoder s a
decCBORGroup Decoder
  s
  (Annotator (Data era)
   -> ExUnits
   -> (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
-> Decoder s (Annotator (Data era))
-> Decoder
     s
     (ExUnits
      -> (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s (Annotator (Data era))
forall s. Decoder s (Annotator (Data era))
forall a s. DecCBOR a => Decoder s a
decCBOR Decoder
  s
  (ExUnits
   -> (PlutusPurpose AsIx era, Annotator (Data era), ExUnits))
-> Decoder s ExUnits
-> Decoder
     s (PlutusPurpose AsIx era, Annotator (Data era), ExUnits)
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Decoder s ExUnits
forall s. Decoder s ExUnits
forall a s. DecCBOR a => Decoder s a
decCBOR
      {-# INLINE decodeElement #-}
  {-# INLINE decCBOR #-}

deriving via
  Mem (RedeemersRaw era)
  instance
    AlonzoEraScript era => DecCBOR (Annotator (Redeemers era))

deriving via
  Mem (AlonzoTxWitsRaw era)
  instance
    ( AlonzoEraScript era
    , DecCBOR (Annotator (NativeScript era))
    ) =>
    DecCBOR (Annotator (AlonzoTxWits era))

instance
  (AlonzoEraScript era, DecCBOR (Annotator (NativeScript era))) =>
  DecCBOR (Annotator (AlonzoTxWitsRaw era))
  where
  decCBOR :: forall s. Decoder s (Annotator (AlonzoTxWitsRaw era))
decCBOR =
    Decode ('Closed 'Dense) (Annotator (AlonzoTxWitsRaw era))
-> Decoder s (Annotator (AlonzoTxWitsRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (Annotator (AlonzoTxWitsRaw era))
 -> Decoder s (Annotator (AlonzoTxWitsRaw era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxWitsRaw era))
-> Decoder s (Annotator (AlonzoTxWitsRaw era))
forall a b. (a -> b) -> a -> b
$
      String
-> Annotator (AlonzoTxWitsRaw era)
-> (Word -> Field (Annotator (AlonzoTxWitsRaw era)))
-> [(Word, String)]
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxWitsRaw era))
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode ('Closed 'Dense) t
SparseKeyed
        String
"AlonzoTxWits"
        (AlonzoTxWitsRaw era -> Annotator (AlonzoTxWitsRaw era)
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure AlonzoTxWitsRaw era
forall era. AlonzoEraScript era => AlonzoTxWitsRaw era
emptyTxWitsRaw)
        Word -> Field (Annotator (AlonzoTxWitsRaw era))
txWitnessField
        []
    where
      txWitnessField :: Word -> Field (Annotator (AlonzoTxWitsRaw era))
      txWitnessField :: Word -> Field (Annotator (AlonzoTxWitsRaw era))
txWitnessField Word
0 =
        (Set (WitVKey 'Witness)
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed 'Dense) (Annotator (Set (WitVKey 'Witness)))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA
          (\Set (WitVKey 'Witness)
x AlonzoTxWitsRaw era
wits -> AlonzoTxWitsRaw era
wits {atwrAddrTxWits = x})
          ( (forall s. Decoder s (Annotator (Set (WitVKey 'Witness))))
-> Decode ('Closed 'Dense) (Annotator (Set (WitVKey 'Witness)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D ((forall s. Decoder s (Annotator (Set (WitVKey 'Witness))))
 -> Decode ('Closed 'Dense) (Annotator (Set (WitVKey 'Witness))))
-> (forall s. Decoder s (Annotator (Set (WitVKey 'Witness))))
-> Decode ('Closed 'Dense) (Annotator (Set (WitVKey 'Witness)))
forall a b. (a -> b) -> a -> b
$
              Version
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
                (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
                ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
                    Decoder s ()
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s (NonEmpty (Annotator (WitVKey 'Witness)))
-> (NonEmpty (WitVKey 'Witness) -> Set (WitVKey 'Witness))
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator (WitVKey 'Witness))
-> Decoder s (NonEmpty (Annotator (WitVKey 'Witness)))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Annotator (WitVKey 'Witness))
forall s. Decoder s (Annotator (WitVKey 'Witness))
forall a s. DecCBOR a => Decoder s a
decCBOR) ([WitVKey 'Witness] -> Set (WitVKey 'Witness)
forall a. Ord a => [a] -> Set a
Set.fromList ([WitVKey 'Witness] -> Set (WitVKey 'Witness))
-> (NonEmpty (WitVKey 'Witness) -> [WitVKey 'Witness])
-> NonEmpty (WitVKey 'Witness)
-> Set (WitVKey 'Witness)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (WitVKey 'Witness) -> [WitVKey 'Witness]
forall a. NonEmpty a -> [a]
NE.toList)
                )
                (Decoder s [Annotator (WitVKey 'Witness)]
-> ([WitVKey 'Witness] -> Set (WitVKey 'Witness))
-> Decoder s (Annotator (Set (WitVKey 'Witness)))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator (WitVKey 'Witness))
-> Decoder s [Annotator (WitVKey 'Witness)]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Annotator (WitVKey 'Witness))
forall s. Decoder s (Annotator (WitVKey 'Witness))
forall a s. DecCBOR a => Decoder s a
decCBOR) [WitVKey 'Witness] -> Set (WitVKey 'Witness)
forall a. Ord a => [a] -> Set a
Set.fromList)
          )
      txWitnessField Word
1 =
        (Map ScriptHash (Script era)
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode
     ('Closed 'Dense) (Annotator (Map ScriptHash (Script era)))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA
          Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
forall era.
Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
addScriptsTxWitsRaw
          ((forall s. Decoder s (Annotator (Map ScriptHash (Script era))))
-> Decode
     ('Closed 'Dense) (Annotator (Map ScriptHash (Script era)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D Decoder s (Annotator (Map ScriptHash (Script era)))
forall s. Decoder s (Annotator (Map ScriptHash (Script era)))
nativeScriptsDecoder)
      txWitnessField Word
2 =
        (Set BootstrapWitness
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed 'Dense) (Annotator (Set BootstrapWitness))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA
          (\Set BootstrapWitness
x AlonzoTxWitsRaw era
wits -> AlonzoTxWitsRaw era
wits {atwrBootAddrTxWits = x})
          ( (forall s. Decoder s (Annotator (Set BootstrapWitness)))
-> Decode ('Closed 'Dense) (Annotator (Set BootstrapWitness))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D ((forall s. Decoder s (Annotator (Set BootstrapWitness)))
 -> Decode ('Closed 'Dense) (Annotator (Set BootstrapWitness)))
-> (forall s. Decoder s (Annotator (Set BootstrapWitness)))
-> Decode ('Closed 'Dense) (Annotator (Set BootstrapWitness))
forall a b. (a -> b) -> a -> b
$
              Version
-> Decoder s (Annotator (Set BootstrapWitness))
-> Decoder s (Annotator (Set BootstrapWitness))
-> Decoder s (Annotator (Set BootstrapWitness))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
                (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
                ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
                    Decoder s ()
-> Decoder s (Annotator (Set BootstrapWitness))
-> Decoder s (Annotator (Set BootstrapWitness))
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s (NonEmpty (Annotator BootstrapWitness))
-> (NonEmpty BootstrapWitness -> Set BootstrapWitness)
-> Decoder s (Annotator (Set BootstrapWitness))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator BootstrapWitness)
-> Decoder s (NonEmpty (Annotator BootstrapWitness))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Annotator BootstrapWitness)
forall s. Decoder s (Annotator BootstrapWitness)
forall a s. DecCBOR a => Decoder s a
decCBOR) ([BootstrapWitness] -> Set BootstrapWitness
forall a. Ord a => [a] -> Set a
Set.fromList ([BootstrapWitness] -> Set BootstrapWitness)
-> (NonEmpty BootstrapWitness -> [BootstrapWitness])
-> NonEmpty BootstrapWitness
-> Set BootstrapWitness
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty BootstrapWitness -> [BootstrapWitness]
forall a. NonEmpty a -> [a]
NE.toList)
                )
                (Decoder s [Annotator BootstrapWitness]
-> ([BootstrapWitness] -> Set BootstrapWitness)
-> Decoder s (Annotator (Set BootstrapWitness))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator BootstrapWitness)
-> Decoder s [Annotator BootstrapWitness]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Annotator BootstrapWitness)
forall s. Decoder s (Annotator BootstrapWitness)
forall a s. DecCBOR a => Decoder s a
decCBOR) [BootstrapWitness] -> Set BootstrapWitness
forall a. Ord a => [a] -> Set a
Set.fromList)
          )
      txWitnessField Word
3 = (Map ScriptHash (Script era)
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
forall era.
Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
addScriptsTxWitsRaw (SLanguage 'PlutusV1
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
forall era (l :: Language).
(AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
decodeAlonzoPlutusScript SLanguage 'PlutusV1
SPlutusV1)
      txWitnessField Word
4 =
        (TxDats era -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed Any) (Annotator (TxDats era))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA
          (\TxDats era
x AlonzoTxWitsRaw era
wits -> AlonzoTxWitsRaw era
wits {atwrDatsTxWits = x})
          Decode ('Closed Any) (Annotator (TxDats era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      txWitnessField Word
5 = (Redeemers era -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed Any) (Annotator (Redeemers era))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA (\Redeemers era
x AlonzoTxWitsRaw era
wits -> AlonzoTxWitsRaw era
wits {atwrRdmrsTxWits = x}) Decode ('Closed Any) (Annotator (Redeemers era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      txWitnessField Word
6 = (Map ScriptHash (Script era)
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
forall era.
Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
addScriptsTxWitsRaw (SLanguage 'PlutusV2
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
forall era (l :: Language).
(AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
decodeAlonzoPlutusScript SLanguage 'PlutusV2
SPlutusV2)
      txWitnessField Word
7 = (Map ScriptHash (Script era)
 -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
-> Field (Annotator (AlonzoTxWitsRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
forall era.
Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
addScriptsTxWitsRaw (SLanguage 'PlutusV3
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
forall era (l :: Language).
(AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l
-> Decode ('Closed 'Dense) (Map ScriptHash (Script era))
decodeAlonzoPlutusScript SLanguage 'PlutusV3
SPlutusV3)
      txWitnessField Word
n = Word -> Field (Annotator (AlonzoTxWitsRaw era))
forall t. Word -> Field t
invalidField Word
n
      {-# INLINE txWitnessField #-}

      nativeScriptsDecoder :: Decoder s (Annotator (Map ScriptHash (Script era)))
      nativeScriptsDecoder :: forall s. Decoder s (Annotator (Map ScriptHash (Script era)))
nativeScriptsDecoder =
        Version
-> Decoder s (Annotator (Map ScriptHash (Script era)))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
          (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
          ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
              Decoder s ()
-> Decoder s (Annotator (Map ScriptHash (Script era)))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s (NonEmpty (Annotator (ScriptHash, Script era)))
-> (NonEmpty (ScriptHash, Script era)
    -> Map ScriptHash (Script era))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator (ScriptHash, Script era))
-> Decoder s (NonEmpty (Annotator (ScriptHash, Script era)))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Annotator (ScriptHash, Script era))
forall s. Decoder s (Annotator (ScriptHash, Script era))
pairDecoder) ([(ScriptHash, Script era)] -> Map ScriptHash (Script era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ScriptHash, Script era)] -> Map ScriptHash (Script era))
-> (NonEmpty (ScriptHash, Script era)
    -> [(ScriptHash, Script era)])
-> NonEmpty (ScriptHash, Script era)
-> Map ScriptHash (Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (ScriptHash, Script era) -> [(ScriptHash, Script era)]
forall a. NonEmpty a -> [a]
NE.toList)
          )
          (Decoder s [Annotator (ScriptHash, Script era)]
-> ([(ScriptHash, Script era)] -> Map ScriptHash (Script era))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
forall (f :: * -> *) s a (m :: * -> *) b.
Traversable f =>
Decoder s (f (Annotator a))
-> (f a -> m b) -> Decoder s (Annotator (m b))
mapTraverseableDecoderA (Decoder s (Annotator (ScriptHash, Script era))
-> Decoder s [Annotator (ScriptHash, Script era)]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Annotator (ScriptHash, Script era))
forall s. Decoder s (Annotator (ScriptHash, Script era))
pairDecoder) [(ScriptHash, Script era)] -> Map ScriptHash (Script era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList)
        where
          pairDecoder :: Decoder s (Annotator (ScriptHash, Script era))
          pairDecoder :: forall s. Decoder s (Annotator (ScriptHash, Script era))
pairDecoder = (NativeScript era -> (ScriptHash, Script era))
-> Annotator (NativeScript era)
-> Annotator (ScriptHash, Script era)
forall a b. (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Script era -> (ScriptHash, Script era)
forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair (Script era -> (ScriptHash, Script era))
-> (NativeScript era -> Script era)
-> NativeScript era
-> (ScriptHash, Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NativeScript era -> Script era
forall era. EraScript era => NativeScript era -> Script era
fromNativeScript) (Annotator (NativeScript era)
 -> Annotator (ScriptHash, Script era))
-> Decoder s (Annotator (NativeScript era))
-> Decoder s (Annotator (ScriptHash, Script era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Annotator (NativeScript era))
forall s. Decoder s (Annotator (NativeScript era))
forall a s. DecCBOR a => Decoder s a
decCBOR
  {-# INLINE decCBOR #-}

instance AlonzoEraScript era => DecCBOR (Annotator (AlonzoScript era)) where
  decCBOR :: forall s. Decoder s (Annotator (AlonzoScript era))
decCBOR = Decode ('Closed 'Dense) (Annotator (AlonzoScript era))
-> Decoder s (Annotator (AlonzoScript era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Text
-> (Word -> Decode 'Open (Annotator (AlonzoScript era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoScript era))
forall t.
Text -> (Word -> Decode 'Open t) -> Decode ('Closed 'Dense) t
Summands Text
"AlonzoScript" Word -> Decode 'Open (Annotator (AlonzoScript era))
decodeScript)
    where
      decodeAnnPlutus :: SLanguage l -> Decode 'Open (Annotator (AlonzoScript era))
decodeAnnPlutus SLanguage l
slang =
        Decode 'Open (PlutusScript era -> AlonzoScript era)
-> Decode 'Open (Annotator (PlutusScript era -> AlonzoScript era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((PlutusScript era -> AlonzoScript era)
-> Decode 'Open (PlutusScript era -> AlonzoScript era)
forall t. t -> Decode 'Open t
SumD PlutusScript era -> AlonzoScript era
forall era. PlutusScript era -> AlonzoScript era
PlutusScript) Decode 'Open (Annotator (PlutusScript era -> AlonzoScript era))
-> Decode ('Closed 'Dense) (Annotator (PlutusScript era))
-> Decode 'Open (Annotator (AlonzoScript era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed 'Dense) (PlutusScript era)
-> Decode ('Closed 'Dense) (Annotator (PlutusScript era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((forall s. Decoder s (PlutusScript era))
-> Decode ('Closed 'Dense) (PlutusScript era)
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (SLanguage l -> Decoder s (PlutusScript era)
forall era (l :: Language) s.
(AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l -> Decoder s (PlutusScript era)
decodePlutusScript SLanguage l
slang))
      {-# INLINE decodeAnnPlutus #-}
      decodeScript :: Word -> Decode 'Open (Annotator (AlonzoScript era))
      decodeScript :: Word -> Decode 'Open (Annotator (AlonzoScript era))
decodeScript = \case
        Word
0 -> Decode 'Open (Timelock era -> AlonzoScript era)
-> Decode 'Open (Annotator (Timelock era -> AlonzoScript era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((Timelock era -> AlonzoScript era)
-> Decode 'Open (Timelock era -> AlonzoScript era)
forall t. t -> Decode 'Open t
SumD Timelock era -> AlonzoScript era
forall era. Timelock era -> AlonzoScript era
TimelockScript) Decode 'Open (Annotator (Timelock era -> AlonzoScript era))
-> Decode ('Closed Any) (Annotator (Timelock era))
-> Decode 'Open (Annotator (AlonzoScript era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Annotator (Timelock era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Word
1 -> SLanguage 'PlutusV1 -> Decode 'Open (Annotator (AlonzoScript era))
forall {era} {l :: Language}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l -> Decode 'Open (Annotator (AlonzoScript era))
decodeAnnPlutus SLanguage 'PlutusV1
SPlutusV1
        Word
2 -> SLanguage 'PlutusV2 -> Decode 'Open (Annotator (AlonzoScript era))
forall {era} {l :: Language}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l -> Decode 'Open (Annotator (AlonzoScript era))
decodeAnnPlutus SLanguage 'PlutusV2
SPlutusV2
        Word
3 -> SLanguage 'PlutusV3 -> Decode 'Open (Annotator (AlonzoScript era))
forall {era} {l :: Language}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l -> Decode 'Open (Annotator (AlonzoScript era))
decodeAnnPlutus SLanguage 'PlutusV3
SPlutusV3
        Word
n -> Word -> Decode 'Open (Annotator (AlonzoScript era))
forall (w :: Wrapped) t. Word -> Decode w t
Invalid Word
n
      {-# INLINE decodeScript #-}
  {-# INLINE decCBOR #-}

instance Era era => DecCBOR (Annotator (AlonzoTxAuxDataRaw era)) where
  decCBOR :: forall s. Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decCBOR =
    forall t s.
Decoder s t -> Decoder s t -> Decoder s t -> Decoder s t
decodeTxAuxDataByTokenType @(Annotator (AlonzoTxAuxDataRaw era))
      Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall s. Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeShelley
      Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall s. Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeAllegra
      Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeAlonzo
    where
      decodeShelley :: Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeShelley =
        Decode Any (Annotator (AlonzoTxAuxDataRaw era))
-> Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode
          ( Decode
  Any
  (Map Word64 Metadatum
   -> StrictSeq (Timelock era)
   -> Map Language (NonEmpty PlutusBinary)
   -> AlonzoTxAuxDataRaw era)
-> Decode
     Any
     (Annotator
        (Map Word64 Metadatum
         -> StrictSeq (Timelock era)
         -> Map Language (NonEmpty PlutusBinary)
         -> AlonzoTxAuxDataRaw era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((Map Word64 Metadatum
 -> StrictSeq (Timelock era)
 -> Map Language (NonEmpty PlutusBinary)
 -> AlonzoTxAuxDataRaw era)
-> Decode
     Any
     (Map Word64 Metadatum
      -> StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary)
      -> AlonzoTxAuxDataRaw era)
forall t (w :: Wrapped). t -> Decode w t
Emit Map Word64 Metadatum
-> StrictSeq (Timelock era)
-> Map Language (NonEmpty PlutusBinary)
-> AlonzoTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (Timelock era)
-> Map Language (NonEmpty PlutusBinary)
-> AlonzoTxAuxDataRaw era
AlonzoTxAuxDataRaw)
              Decode
  Any
  (Annotator
     (Map Word64 Metadatum
      -> StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary)
      -> AlonzoTxAuxDataRaw era))
-> Decode ('Closed Any) (Annotator (Map Word64 Metadatum))
-> Decode
     Any
     (Annotator
        (StrictSeq (Timelock era)
         -> Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Map Word64 Metadatum)
-> Decode ('Closed Any) (Annotator (Map Word64 Metadatum))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann Decode ('Closed Any) (Map Word64 Metadatum)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
              Decode
  Any
  (Annotator
     (StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
-> Decode ('Closed Any) (Annotator (StrictSeq (Timelock era)))
-> Decode
     Any
     (Annotator
        (Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (StrictSeq (Timelock era))
-> Decode ('Closed Any) (Annotator (StrictSeq (Timelock era)))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann (StrictSeq (Timelock era)
-> Decode ('Closed Any) (StrictSeq (Timelock era))
forall t (w :: Wrapped). t -> Decode w t
Emit StrictSeq (Timelock era)
forall a. StrictSeq a
StrictSeq.empty)
              Decode
  Any
  (Annotator
     (Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
-> Decode
     ('Closed Any) (Annotator (Map Language (NonEmpty PlutusBinary)))
-> Decode Any (Annotator (AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Map Language (NonEmpty PlutusBinary))
-> Decode
     ('Closed Any) (Annotator (Map Language (NonEmpty PlutusBinary)))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann (Map Language (NonEmpty PlutusBinary)
-> Decode ('Closed Any) (Map Language (NonEmpty PlutusBinary))
forall t (w :: Wrapped). t -> Decode w t
Emit Map Language (NonEmpty PlutusBinary)
forall k a. Map k a
Map.empty)
          )
      decodeAllegra :: Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeAllegra =
        Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
-> Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode
          ( Decode
  ('Closed 'Dense)
  (Map Word64 Metadatum
   -> StrictSeq (Timelock era)
   -> Map Language (NonEmpty PlutusBinary)
   -> AlonzoTxAuxDataRaw era)
-> Decode
     ('Closed 'Dense)
     (Annotator
        (Map Word64 Metadatum
         -> StrictSeq (Timelock era)
         -> Map Language (NonEmpty PlutusBinary)
         -> AlonzoTxAuxDataRaw era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((Map Word64 Metadatum
 -> StrictSeq (Timelock era)
 -> Map Language (NonEmpty PlutusBinary)
 -> AlonzoTxAuxDataRaw era)
-> Decode
     ('Closed 'Dense)
     (Map Word64 Metadatum
      -> StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary)
      -> AlonzoTxAuxDataRaw era)
forall t. t -> Decode ('Closed 'Dense) t
RecD Map Word64 Metadatum
-> StrictSeq (Timelock era)
-> Map Language (NonEmpty PlutusBinary)
-> AlonzoTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (Timelock era)
-> Map Language (NonEmpty PlutusBinary)
-> AlonzoTxAuxDataRaw era
AlonzoTxAuxDataRaw)
              Decode
  ('Closed 'Dense)
  (Annotator
     (Map Word64 Metadatum
      -> StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary)
      -> AlonzoTxAuxDataRaw era))
-> Decode ('Closed Any) (Annotator (Map Word64 Metadatum))
-> Decode
     ('Closed 'Dense)
     (Annotator
        (StrictSeq (Timelock era)
         -> Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Map Word64 Metadatum)
-> Decode ('Closed Any) (Annotator (Map Word64 Metadatum))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann Decode ('Closed Any) (Map Word64 Metadatum)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
              Decode
  ('Closed 'Dense)
  (Annotator
     (StrictSeq (Timelock era)
      -> Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
-> Decode ('Closed 'Dense) (Annotator (StrictSeq (Timelock era)))
-> Decode
     ('Closed 'Dense)
     (Annotator
        (Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! (forall s. Decoder s (Annotator (StrictSeq (Timelock era))))
-> Decode ('Closed 'Dense) (Annotator (StrictSeq (Timelock era)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D
                (StrictSeq (Annotator (Timelock era))
-> Annotator (StrictSeq (Timelock era))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a.
Monad m =>
StrictSeq (m a) -> m (StrictSeq a)
sequence (StrictSeq (Annotator (Timelock era))
 -> Annotator (StrictSeq (Timelock era)))
-> Decoder s (StrictSeq (Annotator (Timelock era)))
-> Decoder s (Annotator (StrictSeq (Timelock era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Annotator (Timelock era))
-> Decoder s (StrictSeq (Annotator (Timelock era)))
forall s a. Decoder s a -> Decoder s (StrictSeq a)
decodeStrictSeq Decoder s (Annotator (Timelock era))
forall s. Decoder s (Annotator (Timelock era))
forall a s. DecCBOR a => Decoder s a
decCBOR)
              Decode
  ('Closed 'Dense)
  (Annotator
     (Map Language (NonEmpty PlutusBinary) -> AlonzoTxAuxDataRaw era))
-> Decode
     ('Closed Any) (Annotator (Map Language (NonEmpty PlutusBinary)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Map Language (NonEmpty PlutusBinary))
-> Decode
     ('Closed Any) (Annotator (Map Language (NonEmpty PlutusBinary)))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann (Map Language (NonEmpty PlutusBinary)
-> Decode ('Closed Any) (Map Language (NonEmpty PlutusBinary))
forall t (w :: Wrapped). t -> Decode w t
Emit Map Language (NonEmpty PlutusBinary)
forall k a. Map k a
Map.empty)
          )
      decodeAlonzo :: Decoder s (Annotator (AlonzoTxAuxDataRaw era))
decodeAlonzo =
        Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
-> Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
 -> Decoder s (Annotator (AlonzoTxAuxDataRaw era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
-> Decoder s (Annotator (AlonzoTxAuxDataRaw era))
forall a b. (a -> b) -> a -> b
$
          Word
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
forall (x :: Density) t.
Word -> Decode ('Closed x) t -> Decode ('Closed x) t
TagD Word
259 (Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
 -> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
forall a b. (a -> b) -> a -> b
$
            String
-> Annotator (AlonzoTxAuxDataRaw era)
-> (Word -> Field (Annotator (AlonzoTxAuxDataRaw era)))
-> [(Word, String)]
-> Decode ('Closed 'Dense) (Annotator (AlonzoTxAuxDataRaw era))
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode ('Closed 'Dense) t
SparseKeyed String
"AlonzoTxAuxData" (AlonzoTxAuxDataRaw era -> Annotator (AlonzoTxAuxDataRaw era)
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure AlonzoTxAuxDataRaw era
forall era. AlonzoTxAuxDataRaw era
emptyAlonzoTxAuxDataRaw) Word -> Field (Annotator (AlonzoTxAuxDataRaw era))
auxDataField []

      auxDataField :: Word -> Field (Annotator (AlonzoTxAuxDataRaw era))
      auxDataField :: Word -> Field (Annotator (AlonzoTxAuxDataRaw era))
auxDataField Word
0 = (Map Word64 Metadatum
 -> AlonzoTxAuxDataRaw era -> AlonzoTxAuxDataRaw era)
-> Decode ('Closed Any) (Map Word64 Metadatum)
-> Field (Annotator (AlonzoTxAuxDataRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA (\Map Word64 Metadatum
x AlonzoTxAuxDataRaw era
ad -> AlonzoTxAuxDataRaw era
ad {atadrMetadata = x}) Decode ('Closed Any) (Map Word64 Metadatum)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      auxDataField Word
1 =
        (StrictSeq (Timelock era)
 -> AlonzoTxAuxDataRaw era -> AlonzoTxAuxDataRaw era)
-> Decode ('Closed 'Dense) (Annotator (StrictSeq (Timelock era)))
-> Field (Annotator (AlonzoTxAuxDataRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Typeable ann, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) (ann x) -> Field (ann t)
fieldAA
          (\StrictSeq (Timelock era)
x AlonzoTxAuxDataRaw era
ad -> AlonzoTxAuxDataRaw era
ad {atadrTimelock = atadrTimelock ad <> x})
          ((forall s. Decoder s (Annotator (StrictSeq (Timelock era))))
-> Decode ('Closed 'Dense) (Annotator (StrictSeq (Timelock era)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (StrictSeq (Annotator (Timelock era))
-> Annotator (StrictSeq (Timelock era))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a.
Monad m =>
StrictSeq (m a) -> m (StrictSeq a)
sequence (StrictSeq (Annotator (Timelock era))
 -> Annotator (StrictSeq (Timelock era)))
-> Decoder s (StrictSeq (Annotator (Timelock era)))
-> Decoder s (Annotator (StrictSeq (Timelock era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Annotator (Timelock era))
-> Decoder s (StrictSeq (Annotator (Timelock era)))
forall s a. Decoder s a -> Decoder s (StrictSeq a)
decodeStrictSeq Decoder s (Annotator (Timelock era))
forall s. Decoder s (Annotator (Timelock era))
forall a s. DecCBOR a => Decoder s a
decCBOR))
      auxDataField Word
2 = ([PlutusBinary]
 -> AlonzoTxAuxDataRaw era -> AlonzoTxAuxDataRaw era)
-> Decode ('Closed 'Dense) [PlutusBinary]
-> Field (Annotator (AlonzoTxAuxDataRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA (Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
forall era.
Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
addPlutusScripts Language
PlutusV1) ((forall s. Decoder s [PlutusBinary])
-> Decode ('Closed 'Dense) [PlutusBinary]
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (Language -> Decoder s ()
forall s. Language -> Decoder s ()
guardPlutus Language
PlutusV1 Decoder s ()
-> Decoder s [PlutusBinary] -> Decoder s [PlutusBinary]
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s [PlutusBinary]
forall s. Decoder s [PlutusBinary]
forall a s. DecCBOR a => Decoder s a
decCBOR))
      auxDataField Word
3 = ([PlutusBinary]
 -> AlonzoTxAuxDataRaw era -> AlonzoTxAuxDataRaw era)
-> Decode ('Closed 'Dense) [PlutusBinary]
-> Field (Annotator (AlonzoTxAuxDataRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA (Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
forall era.
Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
addPlutusScripts Language
PlutusV2) ((forall s. Decoder s [PlutusBinary])
-> Decode ('Closed 'Dense) [PlutusBinary]
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (Language -> Decoder s ()
forall s. Language -> Decoder s ()
guardPlutus Language
PlutusV2 Decoder s ()
-> Decoder s [PlutusBinary] -> Decoder s [PlutusBinary]
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s [PlutusBinary]
forall s. Decoder s [PlutusBinary]
forall a s. DecCBOR a => Decoder s a
decCBOR))
      auxDataField Word
4 = ([PlutusBinary]
 -> AlonzoTxAuxDataRaw era -> AlonzoTxAuxDataRaw era)
-> Decode ('Closed 'Dense) [PlutusBinary]
-> Field (Annotator (AlonzoTxAuxDataRaw era))
forall x (ann :: * -> *) t (d :: Density).
(Typeable x, Applicative ann) =>
(x -> t -> t) -> Decode ('Closed d) x -> Field (ann t)
fieldA (Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
forall era.
Language
-> [PlutusBinary]
-> AlonzoTxAuxDataRaw era
-> AlonzoTxAuxDataRaw era
addPlutusScripts Language
PlutusV3) ((forall s. Decoder s [PlutusBinary])
-> Decode ('Closed 'Dense) [PlutusBinary]
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (Language -> Decoder s ()
forall s. Language -> Decoder s ()
guardPlutus Language
PlutusV3 Decoder s ()
-> Decoder s [PlutusBinary] -> Decoder s [PlutusBinary]
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Decoder s [PlutusBinary]
forall s. Decoder s [PlutusBinary]
forall a s. DecCBOR a => Decoder s a
decCBOR))
      auxDataField Word
n = Word -> Field (Annotator (AlonzoTxAuxDataRaw era))
forall t. Word -> Field t
invalidField Word
n

deriving via
  Mem (AlonzoTxAuxDataRaw era)
  instance
    Era era => DecCBOR (Annotator (AlonzoTxAuxData era))

deriving via Mem AlonzoTxBodyRaw instance DecCBOR (Annotator (TxBody AlonzoEra))

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

instance
  ( AlonzoEraTx era
  , DecCBOR (Annotator (TxAuxData era))
  , DecCBOR (Annotator (TxBody era))
  , DecCBOR (Annotator (TxWits era))
  ) =>
  DecCBOR (Annotator (AlonzoTxSeq era))
  where
  decCBOR :: forall s. Decoder s (Annotator (AlonzoTxSeq era))
decCBOR = do
    (Seq (Annotator (TxBody era))
bodies, Annotator ByteString
bodiesAnn) <- Decoder s (Seq (Annotator (TxBody era)))
-> Decoder s (Seq (Annotator (TxBody era)), Annotator ByteString)
forall s a. Decoder s a -> Decoder s (a, Annotator ByteString)
withSlice Decoder s (Seq (Annotator (TxBody era)))
forall s. Decoder s (Seq (Annotator (TxBody era)))
forall a s. DecCBOR a => Decoder s a
decCBOR
    (Seq (Annotator (TxWits era))
wits, Annotator ByteString
witsAnn) <- Decoder s (Seq (Annotator (TxWits era)))
-> Decoder s (Seq (Annotator (TxWits era)), Annotator ByteString)
forall s a. Decoder s a -> Decoder s (a, Annotator ByteString)
withSlice Decoder s (Seq (Annotator (TxWits era)))
forall s. Decoder s (Seq (Annotator (TxWits era)))
forall a s. DecCBOR a => Decoder s a
decCBOR
    let bodiesLength :: Int
bodiesLength = Seq (Annotator (TxBody era)) -> Int
forall a. Seq a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Seq (Annotator (TxBody era))
bodies
        inRange :: Int -> Bool
inRange Int
x = (Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
x) Bool -> Bool -> Bool
&& (Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= (Int
bodiesLength Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))
        witsLength :: Int
witsLength = Seq (Annotator (TxWits era)) -> Int
forall a. Seq a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Seq (Annotator (TxWits era))
wits
    (Seq (Maybe (Annotator (TxAuxData era)))
auxData, Annotator ByteString
auxDataAnn) <- Decoder s (Seq (Maybe (Annotator (TxAuxData era))))
-> Decoder
     s (Seq (Maybe (Annotator (TxAuxData era))), Annotator ByteString)
forall s a. Decoder s a -> Decoder s (a, Annotator ByteString)
withSlice (Decoder s (Seq (Maybe (Annotator (TxAuxData era))))
 -> Decoder
      s (Seq (Maybe (Annotator (TxAuxData era))), Annotator ByteString))
-> Decoder s (Seq (Maybe (Annotator (TxAuxData era))))
-> Decoder
     s (Seq (Maybe (Annotator (TxAuxData era))), Annotator ByteString)
forall a b. (a -> b) -> a -> b
$ do
      IntMap (Annotator (TxAuxData era))
auxDataMap <- Decoder s (IntMap (Annotator (TxAuxData era)))
forall s. Decoder s (IntMap (Annotator (TxAuxData era)))
forall a s. DecCBOR a => Decoder s a
decCBOR
      Int
-> IntMap (Annotator (TxAuxData era))
-> Bool
-> Decoder s (Seq (Maybe (Annotator (TxAuxData era))))
forall a s. Int -> IntMap a -> Bool -> Decoder s (Seq (Maybe a))
auxDataSeqDecoder Int
bodiesLength IntMap (Annotator (TxAuxData era))
auxDataMap Bool
False

    ([Int]
isValIdxs, Annotator ByteString
isValAnn) <- Decoder s [Int] -> Decoder s ([Int], Annotator ByteString)
forall s a. Decoder s a -> Decoder s (a, Annotator ByteString)
withSlice Decoder s [Int]
forall s. Decoder s [Int]
forall a s. DecCBOR a => Decoder s a
decCBOR
    let validFlags :: Seq IsValid
validFlags = Int -> [Int] -> Seq IsValid
alignedValidFlags Int
bodiesLength [Int]
isValIdxs
    Bool -> Decoder s () -> Decoder s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless
      (Int
bodiesLength Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
witsLength)
      ( String -> Decoder s ()
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Decoder s ()) -> String -> Decoder s ()
forall a b. (a -> b) -> a -> b
$
          String
"different number of transaction bodies ("
            String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
bodiesLength
            String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
") and witness sets ("
            String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
witsLength
            String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
")"
      )
    Bool -> Decoder s () -> Decoder s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless
      ((Int -> Bool) -> [Int] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Int -> Bool
inRange [Int]
isValIdxs)
      ( String -> Decoder s ()
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail
          ( String
"Some IsValid index is not in the range: 0 .. "
              String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Int
bodiesLength Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
              String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", "
              String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Int] -> String
forall a. Show a => a -> String
show [Int]
isValIdxs
          )
      )

    let txns :: Annotator (StrictSeq (Tx era))
txns =
          StrictSeq (Annotator (Tx era)) -> Annotator (StrictSeq (Tx era))
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
StrictSeq (f a) -> f (StrictSeq a)
sequenceA (StrictSeq (Annotator (Tx era)) -> Annotator (StrictSeq (Tx era)))
-> StrictSeq (Annotator (Tx era)) -> Annotator (StrictSeq (Tx era))
forall a b. (a -> b) -> a -> b
$
            Seq (Annotator (Tx era)) -> StrictSeq (Annotator (Tx era))
forall a. Seq a -> StrictSeq a
StrictSeq.forceToStrict (Seq (Annotator (Tx era)) -> StrictSeq (Annotator (Tx era)))
-> Seq (Annotator (Tx era)) -> StrictSeq (Annotator (Tx era))
forall a b. (a -> b) -> a -> b
$
              (Annotator (TxBody era)
 -> Annotator (TxWits era)
 -> IsValid
 -> Maybe (Annotator (TxAuxData era))
 -> Annotator (Tx era))
-> Seq (Annotator (TxBody era))
-> Seq (Annotator (TxWits era))
-> Seq IsValid
-> Seq (Maybe (Annotator (TxAuxData era)))
-> Seq (Annotator (Tx era))
forall a b c d e.
(a -> b -> c -> d -> e)
-> Seq a -> Seq b -> Seq c -> Seq d -> Seq e
Seq.zipWith4 Annotator (TxBody era)
-> Annotator (TxWits era)
-> IsValid
-> Maybe (Annotator (TxAuxData era))
-> Annotator (Tx era)
forall era.
AlonzoEraTx era =>
Annotator (TxBody era)
-> Annotator (TxWits era)
-> IsValid
-> Maybe (Annotator (TxAuxData era))
-> Annotator (Tx era)
alonzoSegwitTx Seq (Annotator (TxBody era))
bodies Seq (Annotator (TxWits era))
wits Seq IsValid
validFlags Seq (Maybe (Annotator (TxAuxData era)))
auxData
    Annotator (AlonzoTxSeq era)
-> Decoder s (Annotator (AlonzoTxSeq era))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Annotator (AlonzoTxSeq era)
 -> Decoder s (Annotator (AlonzoTxSeq era)))
-> Annotator (AlonzoTxSeq era)
-> Decoder s (Annotator (AlonzoTxSeq era))
forall a b. (a -> b) -> a -> b
$
      StrictSeq (Tx era)
-> ByteString
-> ByteString
-> ByteString
-> ByteString
-> AlonzoTxSeq era
forall era.
StrictSeq (Tx era)
-> ByteString
-> ByteString
-> ByteString
-> ByteString
-> AlonzoTxSeq era
AlonzoTxSeqRaw
        (StrictSeq (Tx era)
 -> ByteString
 -> ByteString
 -> ByteString
 -> ByteString
 -> AlonzoTxSeq era)
-> Annotator (StrictSeq (Tx era))
-> Annotator
     (ByteString
      -> ByteString -> ByteString -> ByteString -> AlonzoTxSeq era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Annotator (StrictSeq (Tx era))
txns
        Annotator
  (ByteString
   -> ByteString -> ByteString -> ByteString -> AlonzoTxSeq era)
-> Annotator ByteString
-> Annotator
     (ByteString -> ByteString -> ByteString -> AlonzoTxSeq era)
forall a b. Annotator (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Annotator ByteString
bodiesAnn
        Annotator
  (ByteString -> ByteString -> ByteString -> AlonzoTxSeq era)
-> Annotator ByteString
-> Annotator (ByteString -> ByteString -> AlonzoTxSeq era)
forall a b. Annotator (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Annotator ByteString
witsAnn
        Annotator (ByteString -> ByteString -> AlonzoTxSeq era)
-> Annotator ByteString
-> Annotator (ByteString -> AlonzoTxSeq era)
forall a b. Annotator (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Annotator ByteString
auxDataAnn
        Annotator (ByteString -> AlonzoTxSeq era)
-> Annotator ByteString -> Annotator (AlonzoTxSeq era)
forall a b. Annotator (a -> b) -> Annotator a -> Annotator b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Annotator ByteString
isValAnn

instance
  ( Typeable era
  , Typeable (TxBody era)
  , Typeable (TxWits era)
  , Typeable (TxAuxData era)
  , DecCBOR (Annotator (TxBody era))
  , DecCBOR (Annotator (TxWits era))
  , DecCBOR (Annotator (TxAuxData era))
  ) =>
  DecCBOR (Annotator (AlonzoTx era))
  where
  decCBOR :: forall s. Decoder s (Annotator (AlonzoTx era))
decCBOR =
    Decode ('Closed 'Dense) (Annotator (AlonzoTx era))
-> Decoder s (Annotator (AlonzoTx era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (Annotator (AlonzoTx era))
 -> Decoder s (Annotator (AlonzoTx era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTx era))
-> Decoder s (Annotator (AlonzoTx era))
forall a b. (a -> b) -> a -> b
$
      Decode
  ('Closed 'Dense)
  (TxBody era
   -> TxWits era
   -> IsValid
   -> StrictMaybe (TxAuxData era)
   -> AlonzoTx era)
-> Decode
     ('Closed 'Dense)
     (Annotator
        (TxBody era
         -> TxWits era
         -> IsValid
         -> StrictMaybe (TxAuxData era)
         -> AlonzoTx era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((TxBody era
 -> TxWits era
 -> IsValid
 -> StrictMaybe (TxAuxData era)
 -> AlonzoTx era)
-> Decode
     ('Closed 'Dense)
     (TxBody era
      -> TxWits era
      -> IsValid
      -> StrictMaybe (TxAuxData era)
      -> AlonzoTx era)
forall t. t -> Decode ('Closed 'Dense) t
RecD TxBody era
-> TxWits era
-> IsValid
-> StrictMaybe (TxAuxData era)
-> AlonzoTx era
forall era.
TxBody era
-> TxWits era
-> IsValid
-> StrictMaybe (TxAuxData era)
-> AlonzoTx era
AlonzoTx)
        Decode
  ('Closed 'Dense)
  (Annotator
     (TxBody era
      -> TxWits era
      -> IsValid
      -> StrictMaybe (TxAuxData era)
      -> AlonzoTx era))
-> Decode ('Closed Any) (Annotator (TxBody era))
-> Decode
     ('Closed 'Dense)
     (Annotator
        (TxWits era
         -> IsValid -> StrictMaybe (TxAuxData era) -> AlonzoTx era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Annotator (TxBody era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (Annotator
     (TxWits era
      -> IsValid -> StrictMaybe (TxAuxData era) -> AlonzoTx era))
-> Decode ('Closed Any) (Annotator (TxWits era))
-> Decode
     ('Closed 'Dense)
     (Annotator
        (IsValid -> StrictMaybe (TxAuxData era) -> AlonzoTx era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) (Annotator (TxWits era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (Annotator
     (IsValid -> StrictMaybe (TxAuxData era) -> AlonzoTx era))
-> Decode ('Closed Any) (Annotator IsValid)
-> Decode
     ('Closed 'Dense)
     (Annotator (StrictMaybe (TxAuxData era) -> AlonzoTx era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode ('Closed Any) IsValid
-> Decode ('Closed Any) (Annotator IsValid)
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann Decode ('Closed Any) IsValid
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (Annotator (StrictMaybe (TxAuxData era) -> AlonzoTx era))
-> Decode
     ('Closed 'Dense) (Annotator (StrictMaybe (TxAuxData era)))
-> Decode ('Closed 'Dense) (Annotator (AlonzoTx era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode ('Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! (forall s. Decoder s (Annotator (StrictMaybe (TxAuxData era))))
-> Decode
     ('Closed 'Dense) (Annotator (StrictMaybe (TxAuxData era)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D
          ( StrictMaybe (Annotator (TxAuxData era))
-> Annotator (StrictMaybe (TxAuxData era))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a.
Monad m =>
StrictMaybe (m a) -> m (StrictMaybe a)
sequence (StrictMaybe (Annotator (TxAuxData era))
 -> Annotator (StrictMaybe (TxAuxData era)))
-> (Maybe (Annotator (TxAuxData era))
    -> StrictMaybe (Annotator (TxAuxData era)))
-> Maybe (Annotator (TxAuxData era))
-> Annotator (StrictMaybe (TxAuxData era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Annotator (TxAuxData era))
-> StrictMaybe (Annotator (TxAuxData era))
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe
              (Maybe (Annotator (TxAuxData era))
 -> Annotator (StrictMaybe (TxAuxData era)))
-> Decoder s (Maybe (Annotator (TxAuxData era)))
-> Decoder s (Annotator (StrictMaybe (TxAuxData era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Annotator (TxAuxData era))
-> Decoder s (Maybe (Annotator (TxAuxData era)))
forall s a. Decoder s a -> Decoder s (Maybe a)
decodeNullMaybe Decoder s (Annotator (TxAuxData era))
forall s. Decoder s (Annotator (TxAuxData era))
forall a s. DecCBOR a => Decoder s a
decCBOR
          )
  {-# INLINE decCBOR #-}

-- | Construct an annotated Alonzo style transaction.
alonzoSegwitTx ::
  AlonzoEraTx era =>
  Annotator (TxBody era) ->
  Annotator (TxWits era) ->
  IsValid ->
  Maybe (Annotator (TxAuxData era)) ->
  Annotator (Tx era)
alonzoSegwitTx :: forall era.
AlonzoEraTx era =>
Annotator (TxBody era)
-> Annotator (TxWits era)
-> IsValid
-> Maybe (Annotator (TxAuxData era))
-> Annotator (Tx era)
alonzoSegwitTx Annotator (TxBody era)
txBodyAnn Annotator (TxWits era)
txWitsAnn IsValid
txIsValid Maybe (Annotator (TxAuxData era))
auxDataAnn = (FullByteString -> Tx era) -> Annotator (Tx era)
forall a. (FullByteString -> a) -> Annotator a
Annotator ((FullByteString -> Tx era) -> Annotator (Tx era))
-> (FullByteString -> Tx era) -> Annotator (Tx era)
forall a b. (a -> b) -> a -> b
$ \FullByteString
bytes ->
  let txBody :: TxBody era
txBody = Annotator (TxBody era) -> FullByteString -> TxBody era
forall a. Annotator a -> FullByteString -> a
runAnnotator Annotator (TxBody era)
txBodyAnn FullByteString
bytes
      txWits :: TxWits era
txWits = Annotator (TxWits era) -> FullByteString -> TxWits era
forall a. Annotator a -> FullByteString -> a
runAnnotator Annotator (TxWits era)
txWitsAnn FullByteString
bytes
      txAuxData :: StrictMaybe (TxAuxData era)
txAuxData = Maybe (TxAuxData era) -> StrictMaybe (TxAuxData era)
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe ((Annotator (TxAuxData era) -> FullByteString -> TxAuxData era)
-> FullByteString -> Annotator (TxAuxData era) -> TxAuxData era
forall a b c. (a -> b -> c) -> b -> a -> c
flip Annotator (TxAuxData era) -> FullByteString -> TxAuxData era
forall a. Annotator a -> FullByteString -> a
runAnnotator FullByteString
bytes (Annotator (TxAuxData era) -> TxAuxData era)
-> Maybe (Annotator (TxAuxData era)) -> Maybe (TxAuxData era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Annotator (TxAuxData era))
auxDataAnn)
   in TxBody era -> Tx era
forall era. EraTx era => TxBody era -> Tx era
mkBasicTx TxBody era
txBody
        Tx era -> (Tx era -> Tx era) -> Tx era
forall a b. a -> (a -> b) -> b
& (TxWits era -> Identity (TxWits era))
-> Tx era -> Identity (Tx era)
forall era. EraTx era => Lens' (Tx era) (TxWits era)
Lens' (Tx era) (TxWits era)
witsTxL ((TxWits era -> Identity (TxWits era))
 -> Tx era -> Identity (Tx era))
-> TxWits era -> Tx era -> Tx era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxWits era
txWits
        Tx era -> (Tx era -> Tx era) -> Tx era
forall a b. a -> (a -> b) -> b
& (StrictMaybe (TxAuxData era)
 -> Identity (StrictMaybe (TxAuxData era)))
-> Tx era -> Identity (Tx era)
forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
Lens' (Tx era) (StrictMaybe (TxAuxData era))
auxDataTxL ((StrictMaybe (TxAuxData era)
  -> Identity (StrictMaybe (TxAuxData era)))
 -> Tx era -> Identity (Tx era))
-> StrictMaybe (TxAuxData era) -> Tx era -> Tx era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictMaybe (TxAuxData era)
txAuxData
        Tx era -> (Tx era -> Tx era) -> Tx era
forall a b. a -> (a -> b) -> b
& (IsValid -> Identity IsValid) -> Tx era -> Identity (Tx era)
forall era. AlonzoEraTx era => Lens' (Tx era) IsValid
Lens' (Tx era) IsValid
isValidTxL ((IsValid -> Identity IsValid) -> Tx era -> Identity (Tx era))
-> IsValid -> Tx era -> Tx era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ IsValid
txIsValid