{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Alonzo.TxWits (
  Redeemers (MkRedeemers, Redeemers),
  RedeemersRaw (..),
  unRedeemersL,
  unRedeemers,
  TxDats (MkTxDats, TxDats),
  TxDatsRaw (..),
  AlonzoTxWits (
    MkAlonzoTxWits,
    AlonzoTxWits,
    txwitsVKey,
    txwitsBoot,
    txscripts,
    txdats,
    txrdmrs
  ),
  AlonzoTxWitsRaw (..),
  addrAlonzoTxWitsL,
  bootAddrAlonzoTxWitsL,
  scriptAlonzoTxWitsL,
  datsAlonzoTxWitsL,
  rdmrsAlonzoTxWitsL,
  AlonzoEraTxWits (..),
  hashDataTxWitsL,
  unTxDats,
  unTxDatsL,
  alonzoEqTxWitsRaw,
  emptyTxWitsRaw,
  addScriptsTxWitsRaw,
  decodeAlonzoPlutusScript,
  asHashedScriptPair,
) where

import Cardano.Base.Proxy (asProxy)
import Cardano.Ledger.Alonzo.Era (AlonzoEra)
import Cardano.Ledger.Alonzo.Scripts (
  AlonzoEraScript (..),
  AsIx (..),
  decodePlutusScript,
  fromPlutusScript,
  toPlutusSLanguage,
 )
import Cardano.Ledger.Binary (
  Annotator (..),
  DecCBOR (..),
  DecCBORGroup (..),
  Decoder,
  EncCBOR (..),
  EncCBORGroup (..),
  Encoding,
  ToCBOR (..),
  TokenType (..),
  allowTag,
  decodeList,
  decodeListLenOrIndef,
  decodeListLikeWithCount,
  decodeMapLenOrIndef,
  decodeMapLikeEnforceNoDuplicates,
  decodeNonEmptyList,
  decodeNonEmptySetLikeEnforceNoDuplicatesAnn,
  encodeFoldableEncoder,
  encodeListLen,
  encodeTag,
  ifDecoderVersionAtLeast,
  ifEncodingVersionAtLeast,
  listLenInt,
  natVersion,
  peekTokenType,
  setTag,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Core
import Cardano.Ledger.Keys (BootstrapWitness, WitVKey)
import Cardano.Ledger.MemoBytes (
  EqRaw (..),
  Mem,
  MemoBytes,
  Memoized (..),
  eqRawType,
  getMemoRawType,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Plutus.Data (Data, hashData)
import Cardano.Ledger.Plutus.ExUnits (ExUnits (..))
import Cardano.Ledger.Plutus.Language (
  Language (..),
  Plutus (..),
  PlutusLanguage,
  SLanguage (..),
  plutusBinary,
 )
import Cardano.Ledger.Shelley.TxWits (
  mapTraverseableDecoderA,
  shelleyEqTxWitsRaw,
 )
import Control.DeepSeq (NFData)
import Control.Monad (when, (>=>))
import Control.Monad.Trans.Fail (runFail)
import Data.Coerce (coerce)
import qualified Data.List.NonEmpty as NE
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.MapExtras (fromElems)
import qualified Data.MapExtras as Map (fromElems)
import Data.Maybe (mapMaybe)
import Data.Set (Set)
import qualified Data.Set as Set
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks)

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

newtype RedeemersRaw era = RedeemersRaw
  { forall era.
RedeemersRaw era
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemersRaw :: Map (PlutusPurpose AsIx era) (Data era, ExUnits)
  }
  deriving ((forall x. RedeemersRaw era -> Rep (RedeemersRaw era) x)
-> (forall x. Rep (RedeemersRaw era) x -> RedeemersRaw era)
-> Generic (RedeemersRaw era)
forall x. Rep (RedeemersRaw era) x -> RedeemersRaw era
forall x. RedeemersRaw era -> Rep (RedeemersRaw era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (RedeemersRaw era) x -> RedeemersRaw era
forall era x. RedeemersRaw era -> Rep (RedeemersRaw era) x
$cfrom :: forall era x. RedeemersRaw era -> Rep (RedeemersRaw era) x
from :: forall x. RedeemersRaw era -> Rep (RedeemersRaw era) x
$cto :: forall era x. Rep (RedeemersRaw era) x -> RedeemersRaw era
to :: forall x. Rep (RedeemersRaw era) x -> RedeemersRaw era
Generic)

deriving newtype instance AlonzoEraScript era => Eq (RedeemersRaw era)

deriving newtype instance AlonzoEraScript era => NFData (RedeemersRaw era)

deriving newtype instance AlonzoEraScript era => NoThunks (RedeemersRaw era)

deriving newtype instance AlonzoEraScript era => Show (RedeemersRaw era)

instance AlonzoEraScript era => EncCBOR (RedeemersRaw era) where
  encCBOR :: RedeemersRaw era -> Encoding
encCBOR (RedeemersRaw Map (PlutusPurpose AsIx era) (Data era, ExUnits)
rs) =
    Version -> Encoding -> Encoding -> Encoding
ifEncodingVersionAtLeast
      (forall (v :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR Map (PlutusPurpose AsIx era) (Data era, ExUnits)
rs)
      (((PlutusPurpose AsIx era, (Data era, ExUnits)) -> Encoding)
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Encoding
forall (f :: * -> *) a.
Foldable f =>
(a -> Encoding) -> f a -> Encoding
encodeFoldableEncoder (PlutusPurpose AsIx era, (Data era, ExUnits)) -> Encoding
keyValueEncoder ([(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Encoding)
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Encoding
forall a b. (a -> b) -> a -> b
$ Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map (PlutusPurpose AsIx era) (Data era, ExUnits)
rs)
    where
      keyValueEncoder :: (PlutusPurpose AsIx era, (Data era, ExUnits)) -> Encoding
      keyValueEncoder :: (PlutusPurpose AsIx era, (Data era, ExUnits)) -> Encoding
keyValueEncoder (PlutusPurpose AsIx era
ptr, (Data era
dats, ExUnits
exs)) =
        Word -> Encoding
encodeListLen (Proxy (PlutusPurpose AsIx era) -> Word
forall a. EncCBORGroup a => Proxy a -> Word
listLen (PlutusPurpose AsIx era -> Proxy (PlutusPurpose AsIx era)
forall a. a -> Proxy a
asProxy PlutusPurpose AsIx era
ptr) Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
2)
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> PlutusPurpose AsIx era -> Encoding
forall a. EncCBORGroup a => a -> Encoding
encCBORGroup PlutusPurpose AsIx era
ptr
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Data era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR Data era
dats
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> ExUnits -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ExUnits
exs

instance Memoized (Redeemers era) where
  type RawType (Redeemers era) = RedeemersRaw era

-- | Note that 'Redeemers' are based on 'MemoBytes' since we must preserve
-- the original bytes for the 'Cardano.Ledger.Alonzo.Tx.ScriptIntegrity'.
-- Since the 'Redeemers' exist outside of the transaction body,
-- this is how we ensure that they are not manipulated.
newtype Redeemers era = MkRedeemers (MemoBytes (RedeemersRaw era))
  deriving newtype ((forall x. Redeemers era -> Rep (Redeemers era) x)
-> (forall x. Rep (Redeemers era) x -> Redeemers era)
-> Generic (Redeemers era)
forall x. Rep (Redeemers era) x -> Redeemers era
forall x. Redeemers era -> Rep (Redeemers era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (Redeemers era) x -> Redeemers era
forall era x. Redeemers era -> Rep (Redeemers era) x
$cfrom :: forall era x. Redeemers era -> Rep (Redeemers era) x
from :: forall x. Redeemers era -> Rep (Redeemers era) x
$cto :: forall era x. Rep (Redeemers era) x -> Redeemers era
to :: forall x. Rep (Redeemers era) x -> Redeemers era
Generic, Typeable (Redeemers era)
Typeable (Redeemers era) =>
(Redeemers era -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (Redeemers era) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [Redeemers era] -> Size)
-> ToCBOR (Redeemers era)
Redeemers era -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Redeemers era] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Redeemers era) -> Size
forall era. Typeable era => Typeable (Redeemers era)
forall era. Typeable era => Redeemers era -> Encoding
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Redeemers era] -> Size
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Redeemers era) -> Size
$ctoCBOR :: forall era. Typeable era => Redeemers era -> Encoding
toCBOR :: Redeemers era -> Encoding
$cencodedSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Redeemers era) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (Redeemers era) -> Size
$cencodedListSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Redeemers era] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [Redeemers era] -> Size
ToCBOR, Redeemers era -> Int
Redeemers era -> ByteString
(Redeemers era -> ByteString)
-> (Redeemers era -> Int)
-> (forall i. Proxy i -> Redeemers era -> SafeHash i)
-> SafeToHash (Redeemers era)
forall i. Proxy i -> Redeemers era -> SafeHash i
forall era. Redeemers era -> Int
forall era. Redeemers era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall era i. Proxy i -> Redeemers era -> SafeHash i
$coriginalBytes :: forall era. Redeemers era -> ByteString
originalBytes :: Redeemers era -> ByteString
$coriginalBytesSize :: forall era. Redeemers era -> Int
originalBytesSize :: Redeemers era -> Int
$cmakeHashWithExplicitProxys :: forall era i. Proxy i -> Redeemers era -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> Redeemers era -> SafeHash i
SafeToHash)

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

deriving newtype instance AlonzoEraScript era => Eq (Redeemers era)

deriving newtype instance AlonzoEraScript era => NFData (Redeemers era)

deriving newtype instance AlonzoEraScript era => NoThunks (Redeemers era)

deriving instance AlonzoEraScript era => Show (Redeemers era)

instance AlonzoEraScript era => Semigroup (Redeemers era) where
  Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
x <> :: Redeemers era -> Redeemers era -> Redeemers era
<> Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
y = Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Redeemers era
forall a b. (a -> b) -> a -> b
$ Map (PlutusPurpose AsIx era) (Data era, ExUnits)
x Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall a. Semigroup a => a -> a -> a
<> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
y

instance AlonzoEraScript era => Monoid (Redeemers era) where
  mempty :: Redeemers era
mempty = Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall a. Monoid a => a
mempty

-- =====================================================
-- Pattern for Redeemers

pattern Redeemers ::
  forall era.
  AlonzoEraScript era =>
  Map (PlutusPurpose AsIx era) (Data era, ExUnits) ->
  Redeemers era
pattern $mRedeemers :: forall {r} {era}.
AlonzoEraScript era =>
Redeemers era
-> (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> r)
-> ((# #) -> r)
-> r
$bRedeemers :: forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers rs <-
  (getMemoRawType -> RedeemersRaw rs)
  where
    Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
rs' = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era (RawType (Redeemers era) -> Redeemers era)
-> RawType (Redeemers era) -> Redeemers era
forall a b. (a -> b) -> a -> b
$ 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)
rs'

{-# COMPLETE Redeemers #-}

unRedeemers :: Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemers :: forall era.
Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemers = RedeemersRaw era
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall era.
RedeemersRaw era
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemersRaw (RedeemersRaw era
 -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> (Redeemers era -> RedeemersRaw era)
-> Redeemers era
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Redeemers era -> RawType (Redeemers era)
Redeemers era -> RedeemersRaw era
forall t. Memoized t => t -> RawType t
getMemoRawType

-- Conceptually, this is an Iso' but vanilla microlens doesn't have Iso's
unRedeemersL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (Redeemers era) (Map.Map (PlutusPurpose AsIx era) (Data era, ExUnits))
unRedeemersL :: forall era.
AlonzoEraScript era =>
Lens'
  (Redeemers era) (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
unRedeemersL Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
f = (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era)
-> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> f (Redeemers era)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers (f (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
 -> f (Redeemers era))
-> (Redeemers era
    -> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits)))
-> Redeemers era
-> f (Redeemers era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
f (Map (PlutusPurpose AsIx era) (Data era, ExUnits)
 -> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits)))
-> (Redeemers era
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> Redeemers era
-> f (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall era.
Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemers
{-# INLINE unRedeemersL #-}

emptyTxWitsRaw :: AlonzoEraScript era => AlonzoTxWitsRaw era
emptyTxWitsRaw :: forall era. AlonzoEraScript era => AlonzoTxWitsRaw era
emptyTxWitsRaw = Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
forall era.
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
AlonzoTxWitsRaw Set (WitVKey Witness)
forall a. Monoid a => a
mempty Set BootstrapWitness
forall a. Monoid a => a
mempty Map ScriptHash (Script era)
forall a. Monoid a => a
mempty TxDats era
forall a. Monoid a => a
mempty Redeemers era
forall era. AlonzoEraScript era => Redeemers era
emptyRedeemers

emptyRedeemers :: AlonzoEraScript era => Redeemers era
emptyRedeemers :: forall era. AlonzoEraScript era => Redeemers era
emptyRedeemers = Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall a. Monoid a => a
mempty

-- ====================================================================
-- In the Spec, AlonzoTxWits has 4 logical fields. Here in the implementation
-- we make two physical modifications.
-- 1) The witsVKey field of AlonzoTxWits is specified as a (Map VKey Signature)
--    for efficiency this is stored as a (Set WitVKey) where WitVKey is
--    logically a triple (VKey,Signature,VKeyHash).
-- 2) We add a 5th field _witsBoot to be backwards compatible with
--    earlier Eras: Byron, Mary, Allegra
-- So logically things look like this
--   data AlonzoTxWits = AlonzoTxWits
--      (Set (WitVKey Witness (Crypto era)))
--      (Set (BootstrapWitness (Crypto era)))
--      (Map (ScriptHash (Crypto era)) (Script era))
--      (TxDats era)
--      (Map RdmrPtr (Data era, ExUnits))

-- | Internal 'AlonzoTxWits' type, lacking serialised bytes.
data AlonzoTxWitsRaw era = AlonzoTxWitsRaw
  { forall era. AlonzoTxWitsRaw era -> Set (WitVKey Witness)
atwrAddrTxWits :: !(Set (WitVKey Witness))
  , forall era. AlonzoTxWitsRaw era -> Set BootstrapWitness
atwrBootAddrTxWits :: !(Set BootstrapWitness)
  , forall era. AlonzoTxWitsRaw era -> Map ScriptHash (Script era)
atwrScriptTxWits :: !(Map ScriptHash (Script era))
  , forall era. AlonzoTxWitsRaw era -> TxDats era
atwrDatsTxWits :: !(TxDats era)
  , forall era. AlonzoTxWitsRaw era -> Redeemers era
atwrRdmrsTxWits :: !(Redeemers era)
  }
  deriving ((forall x. AlonzoTxWitsRaw era -> Rep (AlonzoTxWitsRaw era) x)
-> (forall x. Rep (AlonzoTxWitsRaw era) x -> AlonzoTxWitsRaw era)
-> Generic (AlonzoTxWitsRaw era)
forall x. Rep (AlonzoTxWitsRaw era) x -> AlonzoTxWitsRaw era
forall x. AlonzoTxWitsRaw era -> Rep (AlonzoTxWitsRaw era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (AlonzoTxWitsRaw era) x -> AlonzoTxWitsRaw era
forall era x. AlonzoTxWitsRaw era -> Rep (AlonzoTxWitsRaw era) x
$cfrom :: forall era x. AlonzoTxWitsRaw era -> Rep (AlonzoTxWitsRaw era) x
from :: forall x. AlonzoTxWitsRaw era -> Rep (AlonzoTxWitsRaw era) x
$cto :: forall era x. Rep (AlonzoTxWitsRaw era) x -> AlonzoTxWitsRaw era
to :: forall x. Rep (AlonzoTxWitsRaw era) x -> AlonzoTxWitsRaw era
Generic)

instance
  ( Era era
  , NFData (Script era)
  , NFData (TxDats era)
  , NFData (Redeemers era)
  ) =>
  NFData (AlonzoTxWitsRaw era)

newtype AlonzoTxWits era = MkAlonzoTxWits (MemoBytes (AlonzoTxWitsRaw era))
  deriving newtype (AlonzoTxWits era -> Int
AlonzoTxWits era -> ByteString
(AlonzoTxWits era -> ByteString)
-> (AlonzoTxWits era -> Int)
-> (forall i. Proxy i -> AlonzoTxWits era -> SafeHash i)
-> SafeToHash (AlonzoTxWits era)
forall i. Proxy i -> AlonzoTxWits era -> SafeHash i
forall era. AlonzoTxWits era -> Int
forall era. AlonzoTxWits era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall era i. Proxy i -> AlonzoTxWits era -> SafeHash i
$coriginalBytes :: forall era. AlonzoTxWits era -> ByteString
originalBytes :: AlonzoTxWits era -> ByteString
$coriginalBytesSize :: forall era. AlonzoTxWits era -> Int
originalBytesSize :: AlonzoTxWits era -> Int
$cmakeHashWithExplicitProxys :: forall era i. Proxy i -> AlonzoTxWits era -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> AlonzoTxWits era -> SafeHash i
SafeToHash, Typeable (AlonzoTxWits era)
Typeable (AlonzoTxWits era) =>
(AlonzoTxWits era -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (AlonzoTxWits era) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [AlonzoTxWits era] -> Size)
-> ToCBOR (AlonzoTxWits era)
AlonzoTxWits era -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AlonzoTxWits era] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AlonzoTxWits era) -> Size
forall era. Typeable era => Typeable (AlonzoTxWits era)
forall era. Typeable era => AlonzoTxWits era -> Encoding
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AlonzoTxWits era] -> Size
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AlonzoTxWits era) -> Size
$ctoCBOR :: forall era. Typeable era => AlonzoTxWits era -> Encoding
toCBOR :: AlonzoTxWits era -> Encoding
$cencodedSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AlonzoTxWits era) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AlonzoTxWits era) -> Size
$cencodedListSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AlonzoTxWits era] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AlonzoTxWits era] -> Size
ToCBOR)
  deriving ((forall x. AlonzoTxWits era -> Rep (AlonzoTxWits era) x)
-> (forall x. Rep (AlonzoTxWits era) x -> AlonzoTxWits era)
-> Generic (AlonzoTxWits era)
forall x. Rep (AlonzoTxWits era) x -> AlonzoTxWits era
forall x. AlonzoTxWits era -> Rep (AlonzoTxWits era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (AlonzoTxWits era) x -> AlonzoTxWits era
forall era x. AlonzoTxWits era -> Rep (AlonzoTxWits era) x
$cfrom :: forall era x. AlonzoTxWits era -> Rep (AlonzoTxWits era) x
from :: forall x. AlonzoTxWits era -> Rep (AlonzoTxWits era) x
$cto :: forall era x. Rep (AlonzoTxWits era) x -> AlonzoTxWits era
to :: forall x. Rep (AlonzoTxWits era) x -> AlonzoTxWits era
Generic)

instance Memoized (AlonzoTxWits era) where
  type RawType (AlonzoTxWits era) = AlonzoTxWitsRaw era

instance AlonzoEraScript era => Semigroup (AlonzoTxWits era) where
  <> :: AlonzoTxWits era -> AlonzoTxWits era -> AlonzoTxWits era
(<>) AlonzoTxWits era
x AlonzoTxWits era
y | AlonzoTxWits era -> Bool
forall era. AlonzoEraScript era => AlonzoTxWits era -> Bool
isEmptyTxWitness AlonzoTxWits era
x = AlonzoTxWits era
y
  (<>) AlonzoTxWits era
x AlonzoTxWits era
y | AlonzoTxWits era -> Bool
forall era. AlonzoEraScript era => AlonzoTxWits era -> Bool
isEmptyTxWitness AlonzoTxWits era
y = AlonzoTxWits era
x
  (<>)
    (AlonzoTxWits era -> RawType (AlonzoTxWits era)
forall t. Memoized t => t -> RawType t
getMemoRawType -> AlonzoTxWitsRaw Set (WitVKey Witness)
a Set BootstrapWitness
b Map ScriptHash (Script era)
c TxDats era
d (Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
e))
    (AlonzoTxWits era -> RawType (AlonzoTxWits era)
forall t. Memoized t => t -> RawType t
getMemoRawType -> AlonzoTxWitsRaw Set (WitVKey Witness)
u Set BootstrapWitness
v Map ScriptHash (Script era)
w TxDats era
x (Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
y)) =
      Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
forall era.
AlonzoEraScript era =>
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
AlonzoTxWits (Set (WitVKey Witness)
a Set (WitVKey Witness)
-> Set (WitVKey Witness) -> Set (WitVKey Witness)
forall a. Semigroup a => a -> a -> a
<> Set (WitVKey Witness)
u) (Set BootstrapWitness
b Set BootstrapWitness
-> Set BootstrapWitness -> Set BootstrapWitness
forall a. Semigroup a => a -> a -> a
<> Set BootstrapWitness
v) (Map ScriptHash (Script era)
c Map ScriptHash (Script era)
-> Map ScriptHash (Script era) -> Map ScriptHash (Script era)
forall a. Semigroup a => a -> a -> a
<> Map ScriptHash (Script era)
w) (TxDats era
d TxDats era -> TxDats era -> TxDats era
forall a. Semigroup a => a -> a -> a
<> TxDats era
x) (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers (Map (PlutusPurpose AsIx era) (Data era, ExUnits)
e Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall a. Semigroup a => a -> a -> a
<> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
y))

instance AlonzoEraScript era => Monoid (AlonzoTxWits era) where
  mempty :: AlonzoTxWits era
mempty = Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
forall era.
AlonzoEraScript era =>
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
AlonzoTxWits Set (WitVKey Witness)
forall a. Monoid a => a
mempty Set BootstrapWitness
forall a. Monoid a => a
mempty Map ScriptHash (Script era)
forall a. Monoid a => a
mempty TxDats era
forall a. Monoid a => a
mempty (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall a. Monoid a => a
mempty)

deriving instance
  ( Era era
  , NFData (Script era)
  , NFData (TxDats era)
  , NFData (Redeemers era)
  ) =>
  NFData (AlonzoTxWits era)

isEmptyTxWitness :: AlonzoEraScript era => AlonzoTxWits era -> Bool
isEmptyTxWitness :: forall era. AlonzoEraScript era => AlonzoTxWits era -> Bool
isEmptyTxWitness (AlonzoTxWits era -> RawType (AlonzoTxWits era)
forall t. Memoized t => t -> RawType t
getMemoRawType -> AlonzoTxWitsRaw Set (WitVKey Witness)
a Set BootstrapWitness
b Map ScriptHash (Script era)
c TxDats era
d (Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
e)) =
  Set (WitVKey Witness) -> Bool
forall a. Set a -> Bool
Set.null Set (WitVKey Witness)
a Bool -> Bool -> Bool
&& Set BootstrapWitness -> Bool
forall a. Set a -> Bool
Set.null Set BootstrapWitness
b Bool -> Bool -> Bool
&& Map ScriptHash (Script era) -> Bool
forall k a. Map k a -> Bool
Map.null Map ScriptHash (Script era)
c Bool -> Bool -> Bool
&& Map DataHash (Data era) -> Bool
forall k a. Map k a -> Bool
Map.null (TxDats era
d TxDats era
-> Getting
     (Map DataHash (Data era)) (TxDats era) (Map DataHash (Data era))
-> Map DataHash (Data era)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map DataHash (Data era)) (TxDats era) (Map DataHash (Data era))
forall era. Era era => Lens' (TxDats era) (Map DataHash (Data era))
Lens' (TxDats era) (Map DataHash (Data era))
unTxDatsL) Bool -> Bool -> Bool
&& Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Bool
forall k a. Map k a -> Bool
Map.null Map (PlutusPurpose AsIx era) (Data era, ExUnits)
e

-- =====================================================
newtype TxDatsRaw era = TxDatsRaw {forall era. TxDatsRaw era -> Map DataHash (Data era)
unTxDatsRaw :: Map DataHash (Data era)}
  deriving ((forall x. TxDatsRaw era -> Rep (TxDatsRaw era) x)
-> (forall x. Rep (TxDatsRaw era) x -> TxDatsRaw era)
-> Generic (TxDatsRaw era)
forall x. Rep (TxDatsRaw era) x -> TxDatsRaw era
forall x. TxDatsRaw era -> Rep (TxDatsRaw era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (TxDatsRaw era) x -> TxDatsRaw era
forall era x. TxDatsRaw era -> Rep (TxDatsRaw era) x
$cfrom :: forall era x. TxDatsRaw era -> Rep (TxDatsRaw era) x
from :: forall x. TxDatsRaw era -> Rep (TxDatsRaw era) x
$cto :: forall era x. Rep (TxDatsRaw era) x -> TxDatsRaw era
to :: forall x. Rep (TxDatsRaw era) x -> TxDatsRaw era
Generic, TxDatsRaw era -> TxDatsRaw era -> Bool
(TxDatsRaw era -> TxDatsRaw era -> Bool)
-> (TxDatsRaw era -> TxDatsRaw era -> Bool) -> Eq (TxDatsRaw era)
forall era. TxDatsRaw era -> TxDatsRaw era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. TxDatsRaw era -> TxDatsRaw era -> Bool
== :: TxDatsRaw era -> TxDatsRaw era -> Bool
$c/= :: forall era. TxDatsRaw era -> TxDatsRaw era -> Bool
/= :: TxDatsRaw era -> TxDatsRaw era -> Bool
Eq)
  deriving newtype (Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
Proxy (TxDatsRaw era) -> String
(Context -> TxDatsRaw era -> IO (Maybe ThunkInfo))
-> (Context -> TxDatsRaw era -> IO (Maybe ThunkInfo))
-> (Proxy (TxDatsRaw era) -> String)
-> NoThunks (TxDatsRaw era)
forall era.
Typeable era =>
Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
forall era. Typeable era => Proxy (TxDatsRaw era) -> String
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: forall era.
Typeable era =>
Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall era.
Typeable era =>
Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxDatsRaw era -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall era. Typeable era => Proxy (TxDatsRaw era) -> String
showTypeOf :: Proxy (TxDatsRaw era) -> String
NoThunks, TxDatsRaw era -> ()
(TxDatsRaw era -> ()) -> NFData (TxDatsRaw era)
forall era. TxDatsRaw era -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall era. TxDatsRaw era -> ()
rnf :: TxDatsRaw era -> ()
NFData)

deriving instance Show (TxDatsRaw era)

instance EncCBOR (Data era) => EncCBOR (TxDatsRaw era) where
  encCBOR :: TxDatsRaw era -> Encoding
encCBOR = [Data era] -> Encoding
forall a. EncCBOR a => a -> Encoding
encodeWithSetTag ([Data era] -> Encoding)
-> (TxDatsRaw era -> [Data era]) -> TxDatsRaw era -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map DataHash (Data era) -> [Data era]
forall k a. Map k a -> [a]
Map.elems (Map DataHash (Data era) -> [Data era])
-> (TxDatsRaw era -> Map DataHash (Data era))
-> TxDatsRaw era
-> [Data era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxDatsRaw era -> Map DataHash (Data era)
forall era. TxDatsRaw era -> Map DataHash (Data era)
unTxDatsRaw

pattern TxDats :: forall era. Era era => Map DataHash (Data era) -> TxDats era
pattern $mTxDats :: forall {r} {era}.
Era era =>
TxDats era -> (Map DataHash (Data era) -> r) -> ((# #) -> r) -> r
$bTxDats :: forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats m <- (getMemoRawType -> TxDatsRaw m)
  where
    TxDats Map DataHash (Data era)
m = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era (Map DataHash (Data era) -> TxDatsRaw era
forall era. Map DataHash (Data era) -> TxDatsRaw era
TxDatsRaw Map DataHash (Data era)
m)

{-# COMPLETE TxDats #-}

unTxDats :: TxDats era -> Map DataHash (Data era)
unTxDats :: forall era. TxDats era -> Map DataHash (Data era)
unTxDats (TxDats era -> RawType (TxDats era)
forall t. Memoized t => t -> RawType t
getMemoRawType -> TxDatsRaw Map DataHash (Data era)
m) = Map DataHash (Data era)
m

-- Conceptually, this is an Iso' but vanilla microlens doesn't have Iso's
unTxDatsL :: forall era. Era era => Lens' (TxDats era) (Map DataHash (Data era))
unTxDatsL :: forall era. Era era => Lens' (TxDats era) (Map DataHash (Data era))
unTxDatsL Map DataHash (Data era) -> f (Map DataHash (Data era))
f = (Map DataHash (Data era) -> TxDats era)
-> f (Map DataHash (Data era)) -> f (TxDats era)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map DataHash (Data era) -> TxDats era
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats (f (Map DataHash (Data era)) -> f (TxDats era))
-> (TxDats era -> f (Map DataHash (Data era)))
-> TxDats era
-> f (TxDats era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map DataHash (Data era) -> f (Map DataHash (Data era))
f (Map DataHash (Data era) -> f (Map DataHash (Data era)))
-> (TxDats era -> Map DataHash (Data era))
-> TxDats era
-> f (Map DataHash (Data era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxDats era -> Map DataHash (Data era)
forall era. TxDats era -> Map DataHash (Data era)
unTxDats
{-# INLINE unTxDatsL #-}

-- | Decodes a set of `a`'s and maps a function over it to get key-value pairs.
-- If the key-value pairs create a non-empty Map without duplicates, then that map is returned,
-- otherwise fail
noDuplicateNonEmptySetAsMapDecoderAnn ::
  (Ord k, DecCBOR (Annotator a)) =>
  (a -> (k, v)) ->
  Decoder s (Annotator (Map k v))
noDuplicateNonEmptySetAsMapDecoderAnn :: forall k a v s.
(Ord k, DecCBOR (Annotator a)) =>
(a -> (k, v)) -> Decoder s (Annotator (Map k v))
noDuplicateNonEmptySetAsMapDecoderAnn a -> (k, v)
toKV =
  (a -> Map k v -> Map k v)
-> (Map k v -> (Int, Map k v)) -> Decoder s (Annotator (Map k v))
forall s a b c.
(Monoid b, DecCBOR (Annotator a)) =>
(a -> b -> b) -> (b -> (Int, c)) -> Decoder s (Annotator c)
decodeNonEmptySetLikeEnforceNoDuplicatesAnn
    (\a
x Map k v
m -> let (k
k, v
v) = a -> (k, v)
toKV a
x in k -> v -> Map k v -> Map k v
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
k v
v Map k v
m)
    (\Map k v
m -> (Map k v -> Int
forall k a. Map k a -> Int
Map.size Map k v
m, Map k v
m))
{-# INLINE noDuplicateNonEmptySetAsMapDecoderAnn #-}

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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      ( 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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @12)
          Decoder s (Annotator (TxDatsRaw era))
forall s. Decoder s (Annotator (TxDatsRaw era))
noDuplicatesDatsDecoder
          ( 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))
    where
      noDuplicatesDatsDecoder :: Decoder s (Annotator (TxDatsRaw era))
      noDuplicatesDatsDecoder :: forall s. Decoder s (Annotator (TxDatsRaw era))
noDuplicatesDatsDecoder =
        Decoder s (Annotator (Map DataHash (Data era)))
-> Decoder s (Annotator (TxDatsRaw era))
forall a b. Coercible a b => a -> b
coerce (Decoder s (Annotator (Map DataHash (Data era)))
 -> Decoder s (Annotator (TxDatsRaw era)))
-> ((Data era -> (DataHash, Data era))
    -> Decoder s (Annotator (Map DataHash (Data era))))
-> (Data era -> (DataHash, Data era))
-> Decoder s (Annotator (TxDatsRaw era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Data era -> (DataHash, Data era))
-> Decoder s (Annotator (Map DataHash (Data era)))
forall k a v s.
(Ord k, DecCBOR (Annotator a)) =>
(a -> (k, v)) -> Decoder s (Annotator (Map k v))
noDuplicateNonEmptySetAsMapDecoderAnn ((Data era -> (DataHash, Data era))
 -> Decoder s (Annotator (TxDatsRaw era)))
-> (Data era -> (DataHash, Data era))
-> Decoder s (Annotator (TxDatsRaw era))
forall a b. (a -> b) -> a -> b
$ \Data era
dat -> (Data era -> DataHash
forall era. Data era -> DataHash
hashData Data era
dat, Data era
dat)
      {-# INLINE noDuplicatesDatsDecoder #-}
  {-# INLINE decCBOR #-}

-- | Note that 'TxDats' are based on 'MemoBytes' since we must preserve
-- the original bytes for the 'Cardano.Ledger.Alonzo.Tx.ScriptIntegrity'.
-- Since the 'TxDats' exist outside of the transaction body,
-- this is how we ensure that they are not manipulated.
newtype TxDats era = MkTxDats (MemoBytes (TxDatsRaw era))
  deriving newtype (TxDats era -> Int
TxDats era -> ByteString
(TxDats era -> ByteString)
-> (TxDats era -> Int)
-> (forall i. Proxy i -> TxDats era -> SafeHash i)
-> SafeToHash (TxDats era)
forall i. Proxy i -> TxDats era -> SafeHash i
forall era. TxDats era -> Int
forall era. TxDats era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall era i. Proxy i -> TxDats era -> SafeHash i
$coriginalBytes :: forall era. TxDats era -> ByteString
originalBytes :: TxDats era -> ByteString
$coriginalBytesSize :: forall era. TxDats era -> Int
originalBytesSize :: TxDats era -> Int
$cmakeHashWithExplicitProxys :: forall era i. Proxy i -> TxDats era -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> TxDats era -> SafeHash i
SafeToHash, Typeable (TxDats era)
Typeable (TxDats era) =>
(TxDats era -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (TxDats era) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [TxDats era] -> Size)
-> ToCBOR (TxDats era)
TxDats era -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxDats era] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxDats era) -> Size
forall era. Typeable era => Typeable (TxDats era)
forall era. Typeable era => TxDats era -> Encoding
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxDats era] -> Size
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxDats era) -> Size
$ctoCBOR :: forall era. Typeable era => TxDats era -> Encoding
toCBOR :: TxDats era -> Encoding
$cencodedSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxDats era) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (TxDats era) -> Size
$cencodedListSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxDats era] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [TxDats era] -> Size
ToCBOR, TxDats era -> TxDats era -> Bool
(TxDats era -> TxDats era -> Bool)
-> (TxDats era -> TxDats era -> Bool) -> Eq (TxDats era)
forall era. TxDats era -> TxDats era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. TxDats era -> TxDats era -> Bool
== :: TxDats era -> TxDats era -> Bool
$c/= :: forall era. TxDats era -> TxDats era -> Bool
/= :: TxDats era -> TxDats era -> Bool
Eq, Context -> TxDats era -> IO (Maybe ThunkInfo)
Proxy (TxDats era) -> String
(Context -> TxDats era -> IO (Maybe ThunkInfo))
-> (Context -> TxDats era -> IO (Maybe ThunkInfo))
-> (Proxy (TxDats era) -> String)
-> NoThunks (TxDats era)
forall era.
Typeable era =>
Context -> TxDats era -> IO (Maybe ThunkInfo)
forall era. Typeable era => Proxy (TxDats era) -> String
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: forall era.
Typeable era =>
Context -> TxDats era -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxDats era -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall era.
Typeable era =>
Context -> TxDats era -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxDats era -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall era. Typeable era => Proxy (TxDats era) -> String
showTypeOf :: Proxy (TxDats era) -> String
NoThunks, TxDats era -> ()
(TxDats era -> ()) -> NFData (TxDats era)
forall era. TxDats era -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall era. TxDats era -> ()
rnf :: TxDats era -> ()
NFData)
  deriving ((forall x. TxDats era -> Rep (TxDats era) x)
-> (forall x. Rep (TxDats era) x -> TxDats era)
-> Generic (TxDats era)
forall x. Rep (TxDats era) x -> TxDats era
forall x. TxDats era -> Rep (TxDats era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (TxDats era) x -> TxDats era
forall era x. TxDats era -> Rep (TxDats era) x
$cfrom :: forall era x. TxDats era -> Rep (TxDats era) x
from :: forall x. TxDats era -> Rep (TxDats era) x
$cto :: forall era x. Rep (TxDats era) x -> TxDats era
to :: forall x. Rep (TxDats era) x -> TxDats era
Generic)

instance Memoized (TxDats era) where
  type RawType (TxDats era) = TxDatsRaw era

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

deriving instance Show (TxDats era)

instance Era era => Semigroup (TxDats era) where
  (TxDats Map DataHash (Data era)
m) <> :: TxDats era -> TxDats era -> TxDats era
<> (TxDats Map DataHash (Data era)
m') = Map DataHash (Data era) -> TxDats era
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats (Map DataHash (Data era)
m Map DataHash (Data era)
-> Map DataHash (Data era) -> Map DataHash (Data era)
forall a. Semigroup a => a -> a -> a
<> Map DataHash (Data era)
m')

instance Era era => Monoid (TxDats era) where
  mempty :: TxDats era
mempty = Map DataHash (Data era) -> TxDats era
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats Map DataHash (Data era)
forall a. Monoid a => a
mempty

-- | Encodes memoized bytes created upon construction.
instance Era era => EncCBOR (TxDats era)

-- =====================================================
-- AlonzoTxWits instances

deriving stock instance AlonzoEraScript era => Eq (AlonzoTxWitsRaw era)

deriving stock instance AlonzoEraScript era => Show (AlonzoTxWitsRaw era)

instance AlonzoEraScript era => NoThunks (AlonzoTxWitsRaw era)

deriving newtype instance AlonzoEraScript era => Eq (AlonzoTxWits era)

deriving newtype instance AlonzoEraScript era => Show (AlonzoTxWits era)

deriving newtype instance AlonzoEraScript era => NoThunks (AlonzoTxWits era)

-- =====================================================
-- Pattern for AlonzoTxWits

pattern AlonzoTxWits ::
  forall era.
  AlonzoEraScript era =>
  Set (WitVKey Witness) ->
  Set BootstrapWitness ->
  Map ScriptHash (Script era) ->
  TxDats era ->
  Redeemers era ->
  AlonzoTxWits era
pattern $mAlonzoTxWits :: forall {r} {era}.
AlonzoEraScript era =>
AlonzoTxWits era
-> (Set (WitVKey Witness)
    -> Set BootstrapWitness
    -> Map ScriptHash (Script era)
    -> TxDats era
    -> Redeemers era
    -> r)
-> ((# #) -> r)
-> r
$bAlonzoTxWits :: forall era.
AlonzoEraScript era =>
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
AlonzoTxWits {forall era.
AlonzoEraScript era =>
AlonzoTxWits era -> Set (WitVKey Witness)
txwitsVKey, forall era.
AlonzoEraScript era =>
AlonzoTxWits era -> Set BootstrapWitness
txwitsBoot, forall era.
AlonzoEraScript era =>
AlonzoTxWits era -> Map ScriptHash (Script era)
txscripts, forall era. AlonzoEraScript era => AlonzoTxWits era -> TxDats era
txdats, forall era.
AlonzoEraScript era =>
AlonzoTxWits era -> Redeemers era
txrdmrs} <-
  (getMemoRawType -> AlonzoTxWitsRaw txwitsVKey txwitsBoot txscripts txdats txrdmrs)
  where
    AlonzoTxWits Set (WitVKey Witness)
witsVKey' Set BootstrapWitness
witsBoot' Map ScriptHash (Script era)
witsScript' TxDats era
witsDat' Redeemers era
witsRdmr' =
      forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era (RawType (AlonzoTxWits era) -> AlonzoTxWits era)
-> RawType (AlonzoTxWits era) -> AlonzoTxWits era
forall a b. (a -> b) -> a -> b
$ Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
forall era.
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
AlonzoTxWitsRaw Set (WitVKey Witness)
witsVKey' Set BootstrapWitness
witsBoot' Map ScriptHash (Script era)
witsScript' TxDats era
witsDat' Redeemers era
witsRdmr'

{-# COMPLETE AlonzoTxWits #-}

-- =======================================================
-- Accessors
-- =======================================================

addrAlonzoTxWitsL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (AlonzoTxWits era) (Set (WitVKey Witness))
addrAlonzoTxWitsL :: forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Set (WitVKey Witness))
addrAlonzoTxWitsL =
  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 @era RawType (AlonzoTxWits era) -> Set (WitVKey Witness)
AlonzoTxWitsRaw era -> Set (WitVKey Witness)
forall era. AlonzoTxWitsRaw era -> Set (WitVKey Witness)
atwrAddrTxWits ((RawType (AlonzoTxWits era)
  -> Set (WitVKey Witness) -> RawType (AlonzoTxWits era))
 -> Lens
      (AlonzoTxWits era)
      (AlonzoTxWits era)
      (Set (WitVKey Witness))
      (Set (WitVKey Witness)))
-> (RawType (AlonzoTxWits era)
    -> Set (WitVKey Witness) -> RawType (AlonzoTxWits era))
-> Lens
     (AlonzoTxWits era)
     (AlonzoTxWits era)
     (Set (WitVKey Witness))
     (Set (WitVKey Witness))
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw Set (WitVKey Witness)
addrWits -> RawType (AlonzoTxWits era)
witsRaw {atwrAddrTxWits = addrWits}
{-# INLINEABLE addrAlonzoTxWitsL #-}

bootAddrAlonzoTxWitsL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (AlonzoTxWits era) (Set BootstrapWitness)
bootAddrAlonzoTxWitsL :: forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Set BootstrapWitness)
bootAddrAlonzoTxWitsL =
  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 @era RawType (AlonzoTxWits era) -> Set BootstrapWitness
AlonzoTxWitsRaw era -> Set BootstrapWitness
forall era. AlonzoTxWitsRaw era -> Set BootstrapWitness
atwrBootAddrTxWits ((RawType (AlonzoTxWits era)
  -> Set BootstrapWitness -> RawType (AlonzoTxWits era))
 -> Lens
      (AlonzoTxWits era)
      (AlonzoTxWits era)
      (Set BootstrapWitness)
      (Set BootstrapWitness))
-> (RawType (AlonzoTxWits era)
    -> Set BootstrapWitness -> RawType (AlonzoTxWits era))
-> Lens
     (AlonzoTxWits era)
     (AlonzoTxWits era)
     (Set BootstrapWitness)
     (Set BootstrapWitness)
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw Set BootstrapWitness
bootAddrWits -> RawType (AlonzoTxWits era)
witsRaw {atwrBootAddrTxWits = bootAddrWits}
{-# INLINEABLE bootAddrAlonzoTxWitsL #-}

scriptAlonzoTxWitsL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (AlonzoTxWits era) (Map ScriptHash (Script era))
scriptAlonzoTxWitsL :: forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Map ScriptHash (Script era))
scriptAlonzoTxWitsL =
  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 @era RawType (AlonzoTxWits era) -> Map ScriptHash (Script era)
AlonzoTxWitsRaw era -> Map ScriptHash (Script era)
forall era. AlonzoTxWitsRaw era -> Map ScriptHash (Script era)
atwrScriptTxWits ((RawType (AlonzoTxWits era)
  -> Map ScriptHash (Script era) -> RawType (AlonzoTxWits era))
 -> Lens
      (AlonzoTxWits era)
      (AlonzoTxWits era)
      (Map ScriptHash (Script era))
      (Map ScriptHash (Script era)))
-> (RawType (AlonzoTxWits era)
    -> Map ScriptHash (Script era) -> RawType (AlonzoTxWits era))
-> Lens
     (AlonzoTxWits era)
     (AlonzoTxWits era)
     (Map ScriptHash (Script era))
     (Map ScriptHash (Script era))
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw Map ScriptHash (Script era)
scriptWits -> RawType (AlonzoTxWits era)
witsRaw {atwrScriptTxWits = scriptWits}
{-# INLINEABLE scriptAlonzoTxWitsL #-}

datsAlonzoTxWitsL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (AlonzoTxWits era) (TxDats era)
datsAlonzoTxWitsL :: forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (TxDats era)
datsAlonzoTxWitsL =
  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 @era RawType (AlonzoTxWits era) -> TxDats era
AlonzoTxWitsRaw era -> TxDats era
forall era. AlonzoTxWitsRaw era -> TxDats era
atwrDatsTxWits ((RawType (AlonzoTxWits era)
  -> TxDats era -> RawType (AlonzoTxWits era))
 -> Lens
      (AlonzoTxWits era) (AlonzoTxWits era) (TxDats era) (TxDats era))
-> (RawType (AlonzoTxWits era)
    -> TxDats era -> RawType (AlonzoTxWits era))
-> Lens
     (AlonzoTxWits era) (AlonzoTxWits era) (TxDats era) (TxDats era)
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw TxDats era
datsWits -> RawType (AlonzoTxWits era)
witsRaw {atwrDatsTxWits = datsWits}
{-# INLINEABLE datsAlonzoTxWitsL #-}

rdmrsAlonzoTxWitsL ::
  forall era.
  AlonzoEraScript era =>
  Lens' (AlonzoTxWits era) (Redeemers era)
rdmrsAlonzoTxWitsL :: forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Redeemers era)
rdmrsAlonzoTxWitsL =
  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 @era RawType (AlonzoTxWits era) -> Redeemers era
AlonzoTxWitsRaw era -> Redeemers era
forall era. AlonzoTxWitsRaw era -> Redeemers era
atwrRdmrsTxWits ((RawType (AlonzoTxWits era)
  -> Redeemers era -> RawType (AlonzoTxWits era))
 -> Lens
      (AlonzoTxWits era)
      (AlonzoTxWits era)
      (Redeemers era)
      (Redeemers era))
-> (RawType (AlonzoTxWits era)
    -> Redeemers era -> RawType (AlonzoTxWits era))
-> Lens
     (AlonzoTxWits era)
     (AlonzoTxWits era)
     (Redeemers era)
     (Redeemers era)
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw Redeemers era
rdmrsWits -> RawType (AlonzoTxWits era)
witsRaw {atwrRdmrsTxWits = rdmrsWits}
{-# INLINEABLE rdmrsAlonzoTxWitsL #-}

instance EraTxWits AlonzoEra where
  type TxWits AlonzoEra = AlonzoTxWits AlonzoEra

  mkBasicTxWits :: TxWits AlonzoEra
mkBasicTxWits = TxWits AlonzoEra
AlonzoTxWits AlonzoEra
forall a. Monoid a => a
mempty

  addrTxWitsL :: Lens' (TxWits AlonzoEra) (Set (WitVKey Witness))
addrTxWitsL = (Set (WitVKey Witness) -> f (Set (WitVKey Witness)))
-> TxWits AlonzoEra -> f (TxWits AlonzoEra)
(Set (WitVKey Witness) -> f (Set (WitVKey Witness)))
-> AlonzoTxWits AlonzoEra -> f (AlonzoTxWits AlonzoEra)
forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Set (WitVKey Witness))
Lens' (AlonzoTxWits AlonzoEra) (Set (WitVKey Witness))
addrAlonzoTxWitsL
  {-# INLINE addrTxWitsL #-}

  bootAddrTxWitsL :: Lens' (TxWits AlonzoEra) (Set BootstrapWitness)
bootAddrTxWitsL = (Set BootstrapWitness -> f (Set BootstrapWitness))
-> TxWits AlonzoEra -> f (TxWits AlonzoEra)
(Set BootstrapWitness -> f (Set BootstrapWitness))
-> AlonzoTxWits AlonzoEra -> f (AlonzoTxWits AlonzoEra)
forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Set BootstrapWitness)
Lens' (AlonzoTxWits AlonzoEra) (Set BootstrapWitness)
bootAddrAlonzoTxWitsL
  {-# INLINE bootAddrTxWitsL #-}

  scriptTxWitsL :: Lens' (TxWits AlonzoEra) (Map ScriptHash (Script AlonzoEra))
scriptTxWitsL = (Map ScriptHash (Script AlonzoEra)
 -> f (Map ScriptHash (Script AlonzoEra)))
-> TxWits AlonzoEra -> f (TxWits AlonzoEra)
(Map ScriptHash (Script AlonzoEra)
 -> f (Map ScriptHash (Script AlonzoEra)))
-> AlonzoTxWits AlonzoEra -> f (AlonzoTxWits AlonzoEra)
forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Map ScriptHash (Script era))
Lens' (AlonzoTxWits AlonzoEra) (Map ScriptHash (Script AlonzoEra))
scriptAlonzoTxWitsL
  {-# INLINE scriptTxWitsL #-}

class (EraTxWits era, AlonzoEraScript era) => AlonzoEraTxWits era where
  datsTxWitsL :: Lens' (TxWits era) (TxDats era)

  rdmrsTxWitsL :: Lens' (TxWits era) (Redeemers era)

instance AlonzoEraTxWits AlonzoEra where
  datsTxWitsL :: Lens' (TxWits AlonzoEra) (TxDats AlonzoEra)
datsTxWitsL = (TxDats AlonzoEra -> f (TxDats AlonzoEra))
-> TxWits AlonzoEra -> f (TxWits AlonzoEra)
(TxDats AlonzoEra -> f (TxDats AlonzoEra))
-> AlonzoTxWits AlonzoEra -> f (AlonzoTxWits AlonzoEra)
forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (TxDats era)
Lens' (AlonzoTxWits AlonzoEra) (TxDats AlonzoEra)
datsAlonzoTxWitsL
  {-# INLINE datsTxWitsL #-}

  rdmrsTxWitsL :: Lens' (TxWits AlonzoEra) (Redeemers AlonzoEra)
rdmrsTxWitsL = (Redeemers AlonzoEra -> f (Redeemers AlonzoEra))
-> TxWits AlonzoEra -> f (TxWits AlonzoEra)
(Redeemers AlonzoEra -> f (Redeemers AlonzoEra))
-> AlonzoTxWits AlonzoEra -> f (AlonzoTxWits AlonzoEra)
forall era.
AlonzoEraScript era =>
Lens' (AlonzoTxWits era) (Redeemers era)
Lens' (AlonzoTxWits AlonzoEra) (Redeemers AlonzoEra)
rdmrsAlonzoTxWitsL
  {-# INLINE rdmrsTxWitsL #-}

instance (TxWits era ~ AlonzoTxWits era, AlonzoEraTxWits era) => EqRaw (AlonzoTxWits era) where
  eqRaw :: AlonzoTxWits era -> AlonzoTxWits era -> Bool
eqRaw = TxWits era -> TxWits era -> Bool
AlonzoTxWits era -> AlonzoTxWits era -> Bool
forall era. AlonzoEraTxWits era => TxWits era -> TxWits era -> Bool
alonzoEqTxWitsRaw

-- | This is a convenience Lens that will hash the `Data` when it is being added to the
-- `TxWits`. See `datsTxWitsL` for a version that aloows setting `TxDats` instead.
hashDataTxWitsL :: AlonzoEraTxWits era => Lens (TxWits era) (TxWits era) (TxDats era) [Data era]
hashDataTxWitsL :: forall era.
AlonzoEraTxWits era =>
Lens (TxWits era) (TxWits era) (TxDats era) [Data era]
hashDataTxWitsL =
  (TxWits era -> TxDats era)
-> (TxWits era -> [Data era] -> TxWits era)
-> Lens (TxWits era) (TxWits era) (TxDats era) [Data era]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\TxWits era
wits -> TxWits era
wits TxWits era
-> Getting (TxDats era) (TxWits era) (TxDats era) -> TxDats era
forall s a. s -> Getting a s a -> a
^. Getting (TxDats era) (TxWits era) (TxDats era)
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens' (TxWits era) (TxDats era)
datsTxWitsL)
    (\TxWits era
wits [Data era]
ds -> TxWits era
wits TxWits era -> (TxWits era -> TxWits era) -> TxWits era
forall a b. a -> (a -> b) -> b
& (TxDats era -> Identity (TxDats era))
-> TxWits era -> Identity (TxWits era)
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens' (TxWits era) (TxDats era)
datsTxWitsL ((TxDats era -> Identity (TxDats era))
 -> TxWits era -> Identity (TxWits era))
-> TxDats era -> TxWits era -> TxWits era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map DataHash (Data era) -> TxDats era
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats ((Data era -> DataHash) -> [Data era] -> Map DataHash (Data era)
forall (f :: * -> *) k v.
(Foldable f, Ord k) =>
(v -> k) -> f v -> Map k v
fromElems Data era -> DataHash
forall era. Data era -> DataHash
hashData [Data era]
ds))
{-# INLINEABLE hashDataTxWitsL #-}

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

-- | Encodes memoized bytes created upon construction.
instance Era era => EncCBOR (AlonzoTxWits era)

instance AlonzoEraScript era => EncCBOR (AlonzoTxWitsRaw era) where
  encCBOR :: AlonzoTxWitsRaw era -> Encoding
encCBOR (AlonzoTxWitsRaw Set (WitVKey Witness)
vkeys Set BootstrapWitness
boots Map ScriptHash (Script era)
scripts TxDats era
dats Redeemers era
rdmrs) =
    Encode (Closed Sparse) (AlonzoTxWitsRaw era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode (Closed Sparse) (AlonzoTxWitsRaw era) -> Encoding)
-> Encode (Closed Sparse) (AlonzoTxWitsRaw era) -> Encoding
forall a b. (a -> b) -> a -> b
$
      (Set (WitVKey Witness)
 -> Set BootstrapWitness
 -> Map ScriptHash (Script era)
 -> Map ScriptHash (Plutus 'PlutusV1)
 -> Map ScriptHash (Plutus 'PlutusV2)
 -> Map ScriptHash (Plutus 'PlutusV3)
 -> TxDats era
 -> Redeemers era
 -> AlonzoTxWitsRaw era)
-> Encode
     (Closed Sparse)
     (Set (WitVKey Witness)
      -> Set BootstrapWitness
      -> Map ScriptHash (Script era)
      -> Map ScriptHash (Plutus 'PlutusV1)
      -> Map ScriptHash (Plutus 'PlutusV2)
      -> Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era
      -> Redeemers era
      -> AlonzoTxWitsRaw era)
forall t. t -> Encode (Closed Sparse) t
Keyed
        ( \Set (WitVKey Witness)
a Set BootstrapWitness
b Map ScriptHash (Script era)
c Map ScriptHash (Plutus 'PlutusV1)
d Map ScriptHash (Plutus 'PlutusV2)
e Map ScriptHash (Plutus 'PlutusV3)
f TxDats era
g Redeemers era
h ->
            let ps :: Map ScriptHash (Script era)
ps = forall (l :: Language) h.
PlutusLanguage l =>
Map h (Plutus l) -> Map h (Script era)
toScript @'PlutusV1 Map ScriptHash (Plutus 'PlutusV1)
d Map ScriptHash (Script era)
-> Map ScriptHash (Script era) -> Map ScriptHash (Script era)
forall a. Semigroup a => a -> a -> a
<> forall (l :: Language) h.
PlutusLanguage l =>
Map h (Plutus l) -> Map h (Script era)
toScript @'PlutusV2 Map ScriptHash (Plutus 'PlutusV2)
e Map ScriptHash (Script era)
-> Map ScriptHash (Script era) -> Map ScriptHash (Script era)
forall a. Semigroup a => a -> a -> a
<> forall (l :: Language) h.
PlutusLanguage l =>
Map h (Plutus l) -> Map h (Script era)
toScript @'PlutusV3 Map ScriptHash (Plutus 'PlutusV3)
f
             in Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
forall era.
Set (WitVKey Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWitsRaw era
AlonzoTxWitsRaw Set (WitVKey Witness)
a Set BootstrapWitness
b (Map ScriptHash (Script era)
c Map ScriptHash (Script era)
-> Map ScriptHash (Script era) -> Map ScriptHash (Script era)
forall a. Semigroup a => a -> a -> a
<> Map ScriptHash (Script era)
ps) TxDats era
g Redeemers era
h
        )
        Encode
  (Closed Sparse)
  (Set (WitVKey Witness)
   -> Set BootstrapWitness
   -> Map ScriptHash (Script era)
   -> Map ScriptHash (Plutus 'PlutusV1)
   -> Map ScriptHash (Plutus 'PlutusV2)
   -> Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era
   -> Redeemers era
   -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Set (WitVKey Witness))
-> Encode
     (Closed Sparse)
     (Set BootstrapWitness
      -> Map ScriptHash (Script era)
      -> Map ScriptHash (Plutus 'PlutusV1)
      -> Map ScriptHash (Plutus 'PlutusV2)
      -> Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era
      -> Redeemers era
      -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Set (WitVKey Witness) -> Bool)
-> Encode (Closed Sparse) (Set (WitVKey Witness))
-> Encode (Closed Sparse) (Set (WitVKey Witness))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Set (WitVKey Witness) -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Set (WitVKey Witness))
-> Encode (Closed Sparse) (Set (WitVKey Witness))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
0 (Encode (Closed Dense) (Set (WitVKey Witness))
 -> Encode (Closed Sparse) (Set (WitVKey Witness)))
-> Encode (Closed Dense) (Set (WitVKey Witness))
-> Encode (Closed Sparse) (Set (WitVKey Witness))
forall a b. (a -> b) -> a -> b
$ Set (WitVKey Witness)
-> Encode (Closed Dense) (Set (WitVKey Witness))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set (WitVKey Witness)
vkeys)
        Encode
  (Closed Sparse)
  (Set BootstrapWitness
   -> Map ScriptHash (Script era)
   -> Map ScriptHash (Plutus 'PlutusV1)
   -> Map ScriptHash (Plutus 'PlutusV2)
   -> Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era
   -> Redeemers era
   -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Set BootstrapWitness)
-> Encode
     (Closed Sparse)
     (Map ScriptHash (Script era)
      -> Map ScriptHash (Plutus 'PlutusV1)
      -> Map ScriptHash (Plutus 'PlutusV2)
      -> Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era
      -> Redeemers era
      -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Set BootstrapWitness -> Bool)
-> Encode (Closed Sparse) (Set BootstrapWitness)
-> Encode (Closed Sparse) (Set BootstrapWitness)
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Set BootstrapWitness -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Set BootstrapWitness)
-> Encode (Closed Sparse) (Set BootstrapWitness)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
2 (Encode (Closed Dense) (Set BootstrapWitness)
 -> Encode (Closed Sparse) (Set BootstrapWitness))
-> Encode (Closed Dense) (Set BootstrapWitness)
-> Encode (Closed Sparse) (Set BootstrapWitness)
forall a b. (a -> b) -> a -> b
$ Set BootstrapWitness
-> Encode (Closed Dense) (Set BootstrapWitness)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Set BootstrapWitness
boots)
        Encode
  (Closed Sparse)
  (Map ScriptHash (Script era)
   -> Map ScriptHash (Plutus 'PlutusV1)
   -> Map ScriptHash (Plutus 'PlutusV2)
   -> Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era
   -> Redeemers era
   -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Map ScriptHash (Script era))
-> Encode
     (Closed Sparse)
     (Map ScriptHash (Plutus 'PlutusV1)
      -> Map ScriptHash (Plutus 'PlutusV2)
      -> Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era
      -> Redeemers era
      -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Map ScriptHash (Script era) -> Bool)
-> Encode (Closed Sparse) (Map ScriptHash (Script era))
-> Encode (Closed Sparse) (Map ScriptHash (Script era))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit
          Map ScriptHash (Script era) -> Bool
forall a. Map ScriptHash a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null
          ( Word
-> Encode (Closed Dense) (Map ScriptHash (Script era))
-> Encode (Closed Sparse) (Map ScriptHash (Script era))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
1 (Encode (Closed Dense) (Map ScriptHash (Script era))
 -> Encode (Closed Sparse) (Map ScriptHash (Script era)))
-> Encode (Closed Dense) (Map ScriptHash (Script era))
-> Encode (Closed Sparse) (Map ScriptHash (Script era))
forall a b. (a -> b) -> a -> b
$
              (Map ScriptHash (Script era) -> Encoding)
-> Map ScriptHash (Script era)
-> Encode (Closed Dense) (Map ScriptHash (Script era))
forall t. (t -> Encoding) -> t -> Encode (Closed Dense) t
E
                ([NativeScript era] -> Encoding
forall a. EncCBOR a => a -> Encoding
encodeWithSetTag ([NativeScript era] -> Encoding)
-> (Map ScriptHash (Script era) -> [NativeScript era])
-> Map ScriptHash (Script era)
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Script era -> Maybe (NativeScript era))
-> [Script era] -> [NativeScript era]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Script era -> Maybe (NativeScript era)
forall era. EraScript era => Script era -> Maybe (NativeScript era)
getNativeScript ([Script era] -> [NativeScript era])
-> (Map ScriptHash (Script era) -> [Script era])
-> Map ScriptHash (Script era)
-> [NativeScript era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map ScriptHash (Script era) -> [Script era]
forall k a. Map k a -> [a]
Map.elems)
                ((Script era -> Bool)
-> Map ScriptHash (Script era) -> Map ScriptHash (Script era)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Script era -> Bool
forall era. EraScript era => Script era -> Bool
isNativeScript Map ScriptHash (Script era)
scripts)
          )
        Encode
  (Closed Sparse)
  (Map ScriptHash (Plutus 'PlutusV1)
   -> Map ScriptHash (Plutus 'PlutusV2)
   -> Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era
   -> Redeemers era
   -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1))
-> Encode
     (Closed Sparse)
     (Map ScriptHash (Plutus 'PlutusV2)
      -> Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era
      -> Redeemers era
      -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Map ScriptHash (Plutus 'PlutusV1) -> Bool)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Map ScriptHash (Plutus 'PlutusV1) -> Bool
forall a. Map ScriptHash a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV1))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
3 (Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV1))
 -> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1)))
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV1))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV1))
forall a b. (a -> b) -> a -> b
$ SLanguage 'PlutusV1
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV1))
forall (l :: Language).
PlutusLanguage l =>
SLanguage l -> Encode (Closed Dense) (Map ScriptHash (Plutus l))
encodePlutus SLanguage 'PlutusV1
SPlutusV1)
        Encode
  (Closed Sparse)
  (Map ScriptHash (Plutus 'PlutusV2)
   -> Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era
   -> Redeemers era
   -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2))
-> Encode
     (Closed Sparse)
     (Map ScriptHash (Plutus 'PlutusV3)
      -> TxDats era -> Redeemers era -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Map ScriptHash (Plutus 'PlutusV2) -> Bool)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Map ScriptHash (Plutus 'PlutusV2) -> Bool
forall a. Map ScriptHash a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV2))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
6 (Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV2))
 -> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2)))
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV2))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV2))
forall a b. (a -> b) -> a -> b
$ SLanguage 'PlutusV2
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV2))
forall (l :: Language).
PlutusLanguage l =>
SLanguage l -> Encode (Closed Dense) (Map ScriptHash (Plutus l))
encodePlutus SLanguage 'PlutusV2
SPlutusV2)
        Encode
  (Closed Sparse)
  (Map ScriptHash (Plutus 'PlutusV3)
   -> TxDats era -> Redeemers era -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3))
-> Encode
     (Closed Sparse)
     (TxDats era -> Redeemers era -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Map ScriptHash (Plutus 'PlutusV3) -> Bool)
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3))
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit Map ScriptHash (Plutus 'PlutusV3) -> Bool
forall a. Map ScriptHash a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Word
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV3))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3))
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
7 (Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV3))
 -> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3)))
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV3))
-> Encode (Closed Sparse) (Map ScriptHash (Plutus 'PlutusV3))
forall a b. (a -> b) -> a -> b
$ SLanguage 'PlutusV3
-> Encode (Closed Dense) (Map ScriptHash (Plutus 'PlutusV3))
forall (l :: Language).
PlutusLanguage l =>
SLanguage l -> Encode (Closed Dense) (Map ScriptHash (Plutus l))
encodePlutus SLanguage 'PlutusV3
SPlutusV3)
        Encode
  (Closed Sparse)
  (TxDats era -> Redeemers era -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (TxDats era)
-> Encode (Closed Sparse) (Redeemers era -> AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (TxDats era -> Bool)
-> Encode (Closed Sparse) (TxDats era)
-> Encode (Closed Sparse) (TxDats era)
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit (Map DataHash (Data era) -> Bool
forall a. Map DataHash a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Map DataHash (Data era) -> Bool)
-> (TxDats era -> Map DataHash (Data era)) -> TxDats era -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxDats era -> Map DataHash (Data era)
forall era. TxDats era -> Map DataHash (Data era)
unTxDats) (Word
-> Encode (Closed Dense) (TxDats era)
-> Encode (Closed Sparse) (TxDats era)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
4 (Encode (Closed Dense) (TxDats era)
 -> Encode (Closed Sparse) (TxDats era))
-> Encode (Closed Dense) (TxDats era)
-> Encode (Closed Sparse) (TxDats era)
forall a b. (a -> b) -> a -> b
$ TxDats era -> Encode (Closed Dense) (TxDats era)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To TxDats era
dats)
        Encode (Closed Sparse) (Redeemers era -> AlonzoTxWitsRaw era)
-> Encode (Closed Sparse) (Redeemers era)
-> Encode (Closed Sparse) (AlonzoTxWitsRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> (Redeemers era -> Bool)
-> Encode (Closed Sparse) (Redeemers era)
-> Encode (Closed Sparse) (Redeemers era)
forall t.
(t -> Bool) -> Encode (Closed Sparse) t -> Encode (Closed Sparse) t
Omit (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Bool
forall a. Map (PlutusPurpose AsIx era) a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Bool)
-> (Redeemers era
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> Redeemers era
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall era.
Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemers) (Word
-> Encode (Closed Dense) (Redeemers era)
-> Encode (Closed Sparse) (Redeemers era)
forall t.
Word -> Encode (Closed Dense) t -> Encode (Closed Sparse) t
Key Word
5 (Encode (Closed Dense) (Redeemers era)
 -> Encode (Closed Sparse) (Redeemers era))
-> Encode (Closed Dense) (Redeemers era)
-> Encode (Closed Sparse) (Redeemers era)
forall a b. (a -> b) -> a -> b
$ Redeemers era -> Encode (Closed Dense) (Redeemers era)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Redeemers era
rdmrs)
    where
      encodePlutus ::
        PlutusLanguage l =>
        SLanguage l ->
        Encode (Closed Dense) (Map.Map ScriptHash (Plutus l))
      encodePlutus :: forall (l :: Language).
PlutusLanguage l =>
SLanguage l -> Encode (Closed Dense) (Map ScriptHash (Plutus l))
encodePlutus SLanguage l
slang =
        (Map ScriptHash (Plutus l) -> Encoding)
-> Map ScriptHash (Plutus l)
-> Encode (Closed Dense) (Map ScriptHash (Plutus l))
forall t. (t -> Encoding) -> t -> Encode (Closed Dense) t
E
          (Encoding -> Encoding
forall a. EncCBOR a => a -> Encoding
encodeWithSetTag (Encoding -> Encoding)
-> (Map ScriptHash (Plutus l) -> Encoding)
-> Map ScriptHash (Plutus l)
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PlutusBinary] -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ([PlutusBinary] -> Encoding)
-> (Map ScriptHash (Plutus l) -> [PlutusBinary])
-> Map ScriptHash (Plutus l)
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Plutus l -> PlutusBinary) -> [Plutus l] -> [PlutusBinary]
forall a b. (a -> b) -> [a] -> [b]
map Plutus l -> PlutusBinary
forall (l :: Language). Plutus l -> PlutusBinary
plutusBinary ([Plutus l] -> [PlutusBinary])
-> (Map ScriptHash (Plutus l) -> [Plutus l])
-> Map ScriptHash (Plutus l)
-> [PlutusBinary]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map ScriptHash (Plutus l) -> [Plutus l]
forall k a. Map k a -> [a]
Map.elems)
          ((Script era -> Maybe (Plutus l))
-> Map ScriptHash (Script era) -> Map ScriptHash (Plutus l)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe (Script era -> Maybe (PlutusScript era)
forall era.
AlonzoEraScript era =>
Script era -> Maybe (PlutusScript era)
toPlutusScript (Script era -> Maybe (PlutusScript era))
-> (PlutusScript era -> Maybe (Plutus l))
-> Script era
-> Maybe (Plutus l)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> SLanguage l -> PlutusScript era -> Maybe (Plutus l)
forall (l :: Language) era.
(PlutusLanguage l, AlonzoEraScript era) =>
SLanguage l -> PlutusScript era -> Maybe (Plutus l)
toPlutusSLanguage SLanguage l
slang) Map ScriptHash (Script era)
scripts)
      toScript ::
        forall l h. PlutusLanguage l => Map.Map h (Plutus l) -> Map.Map h (Script era)
      toScript :: forall (l :: Language) h.
PlutusLanguage l =>
Map h (Plutus l) -> Map h (Script era)
toScript Map h (Plutus l)
ps =
        case Fail String (Map h (Script era))
-> Either String (Map h (Script era))
forall e a. (IsString e, Semigroup e) => Fail e a -> Either e a
runFail (Fail String (Map h (Script era))
 -> Either String (Map h (Script era)))
-> Fail String (Map h (Script era))
-> Either String (Map h (Script era))
forall a b. (a -> b) -> a -> b
$ (Plutus l -> FailT String Identity (Script era))
-> Map h (Plutus l) -> Fail String (Map h (Script era))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Map h a -> f (Map h b)
traverse ((PlutusScript era -> Script era)
-> FailT String Identity (PlutusScript era)
-> FailT String Identity (Script era)
forall a b.
(a -> b) -> FailT String Identity a -> FailT String Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
fromPlutusScript (FailT String Identity (PlutusScript era)
 -> FailT String Identity (Script era))
-> (Plutus l -> FailT String Identity (PlutusScript era))
-> Plutus l
-> FailT String Identity (Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Plutus l -> FailT String Identity (PlutusScript era)
forall era (l :: Language) (m :: * -> *).
(AlonzoEraScript era, PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
forall (l :: Language) (m :: * -> *).
(PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
mkPlutusScript) Map h (Plutus l)
ps of
          Left String
e -> String -> Map h (Script era)
forall a. HasCallStack => String -> a
error (String -> Map h (Script era)) -> String -> Map h (Script era)
forall a b. (a -> b) -> a -> b
$ String
"Impossible: Re-constructing unsupported language: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
e
          Right Map h (Script era)
plutusScripts -> Map h (Script era)
plutusScripts

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 :: Natural).
(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
_ ->
            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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @12)
              (String -> Decoder s (Annotator (RedeemersRaw era))
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"List encoding of redeemers not supported starting with PV 12")
              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
        (_, 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
          ptr <- Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          (annData, exUnits) <- decCBOR
          pure $ (\Data era
d -> (PlutusPurpose AsIx era
ptr, (Data era
d, ExUnits
exUnits))) <$> annData
        case NE.nonEmpty 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
        (rdmrPtr, dat, 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
x a
y b
z = (a
x, (a
y, b
z))
        pure $ f rdmrPtr <$> dat <*> pure 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
        let redeemerLen :: (a, b, c) -> Int
redeemerLen (a
redeemerPtr, b
_, c
_) = Maybe a -> Int
forall (proxy :: * -> *) a. EncCBORGroup a => proxy a -> Int
listLenInt (a -> Maybe a
forall a. a -> Maybe a
Just a
redeemerPtr) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2
        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, Annotator (Data era), ExUnits) -> Int
forall {a} {b} {c}. EncCBORGroup a => (a, b, c) -> Int
redeemerLen do
          !redeemerPtr <- Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBORGroup a => Decoder s a
decCBORGroup
          !redeemerData <- decCBOR
          !redeemerExUnits <- decCBOR
          pure (redeemerPtr, redeemerData, redeemerExUnits)
      {-# INLINE decodeElement #-}
  {-# INLINE decCBOR #-}

-- | Encodes memoized bytes created upon construction.
instance AlonzoEraScript era => EncCBOR (Redeemers 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
      addrWitsSetDecoder ::
        (Ord a, DecCBOR (Annotator a), DecCBOR a) => Decoder s (Annotator (Set a))
      addrWitsSetDecoder :: forall a s.
(Ord a, DecCBOR (Annotator a), DecCBOR a) =>
Decoder s (Annotator (Set a))
addrWitsSetDecoder = do
        let
          nonEmptyDecoder :: Decoder s (Annotator (Set a))
nonEmptyDecoder = do
            Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
            s <- [a] -> Set a
forall a. Ord a => [a] -> Set a
Set.fromList ([a] -> Set a) -> (NonEmpty a -> [a]) -> NonEmpty a -> Set a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty a -> Set a)
-> Decoder s (NonEmpty a) -> Decoder s (Set a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s a -> Decoder s (NonEmpty a)
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s a
forall s. Decoder s a
forall a s. DecCBOR a => Decoder s a
decCBOR
            pure $ pure s

          nonEmptyNoDuplicatesDecoder :: Decoder s (Annotator (Set a))
nonEmptyNoDuplicatesDecoder =
            (a -> Set a -> Set a)
-> (Set a -> (Int, Set a)) -> Decoder s (Annotator (Set a))
forall s a b c.
(Monoid b, DecCBOR (Annotator a)) =>
(a -> b -> b) -> (b -> (Int, c)) -> Decoder s (Annotator c)
decodeNonEmptySetLikeEnforceNoDuplicatesAnn
              a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert
              (\Set a
s -> (Set a -> Int
forall a. Set a -> Int
Set.size Set a
s, Set a
s))

        Version
-> Decoder s (Annotator (Set a))
-> Decoder s (Annotator (Set a))
-> Decoder s (Annotator (Set a))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast (forall (v :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @12) Decoder s (Annotator (Set a))
forall {s}. Decoder s (Annotator (Set a))
nonEmptyNoDuplicatesDecoder Decoder s (Annotator (Set a))
forall {s}. Decoder s (Annotator (Set a))
nonEmptyDecoder
      {-# INLINE addrWitsSetDecoder #-}

      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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
                Decoder s (Annotator (Set (WitVKey Witness)))
forall a s.
(Ord a, DecCBOR (Annotator a), DecCBOR a) =>
Decoder s (Annotator (Set a))
addrWitsSetDecoder
                (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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
                Decoder s (Annotator (Set BootstrapWitness))
forall a s.
(Ord a, DecCBOR (Annotator a), DecCBOR a) =>
Decoder s (Annotator (Set a))
addrWitsSetDecoder
                (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 (ZonkAny MinVersion)) (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 (ZonkAny MinVersion)) (Annotator (TxDats era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      txWitnessField Word
5 = (Redeemers era -> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era)
-> Decode (Closed (ZonkAny 1)) (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 (ZonkAny 1)) (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 #-}

      hashedNativeSciptDecoder :: Decoder s (Annotator (ScriptHash, Script era))
      hashedNativeSciptDecoder :: forall s. Decoder s (Annotator (ScriptHash, Script era))
hashedNativeSciptDecoder = (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 (forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair @era (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 hashedNativeSciptDecoder #-}

      noDuplicateNativeScriptsDecoder :: Decoder s (Annotator (Map ScriptHash (Script era)))
      noDuplicateNativeScriptsDecoder :: forall s. Decoder s (Annotator (Map ScriptHash (Script era)))
noDuplicateNativeScriptsDecoder = (NativeScript era -> (ScriptHash, Script era))
-> Decoder s (Annotator (Map ScriptHash (Script era)))
forall k a v s.
(Ord k, DecCBOR (Annotator a)) =>
(a -> (k, v)) -> Decoder s (Annotator (Map k v))
noDuplicateNonEmptySetAsMapDecoderAnn (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)
      {-# INLINE noDuplicateNativeScriptsDecoder #-}

      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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
          ( 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 :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @12)
              Decoder s (Annotator (Map ScriptHash (Script era)))
forall s. Decoder s (Annotator (Map ScriptHash (Script era)))
noDuplicateNativeScriptsDecoder
              ( do
                  Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
                  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))
hashedNativeSciptDecoder) ([(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 nativeScriptsDecoder #-}
  {-# INLINE decCBOR #-}

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

addScriptsTxWitsRaw ::
  Map ScriptHash (Script era) ->
  AlonzoTxWitsRaw era ->
  AlonzoTxWitsRaw era
addScriptsTxWitsRaw :: forall era.
Map ScriptHash (Script era)
-> AlonzoTxWitsRaw era -> AlonzoTxWitsRaw era
addScriptsTxWitsRaw Map ScriptHash (Script era)
scriptWitnesses AlonzoTxWitsRaw era
txWits =
  AlonzoTxWitsRaw era
txWits
    { atwrScriptTxWits = scriptWitnesses <> atwrScriptTxWits txWits
    }
{-# INLINE addScriptsTxWitsRaw #-}

decodeAlonzoPlutusScript ::
  (AlonzoEraScript era, PlutusLanguage l) =>
  SLanguage l ->
  Decode (Closed Dense) (Map ScriptHash (Script era))
decodeAlonzoPlutusScript :: forall era (l :: Language).
(AlonzoEraScript era, PlutusLanguage l) =>
SLanguage l -> Decode (Closed Dense) (Map ScriptHash (Script era))
decodeAlonzoPlutusScript SLanguage l
slang =
  (forall s. Decoder s (Map ScriptHash (Script era)))
-> Decode (Closed Dense) (Map ScriptHash (Script era))
forall t. (forall s. Decoder s t) -> Decode (Closed Dense) t
D ((forall s. Decoder s (Map ScriptHash (Script era)))
 -> Decode (Closed Dense) (Map ScriptHash (Script era)))
-> (forall s. Decoder s (Map ScriptHash (Script era)))
-> Decode (Closed Dense) (Map ScriptHash (Script era))
forall a b. (a -> b) -> a -> b
$
    Version
-> Decoder s (Map ScriptHash (Script era))
-> Decoder s (Map ScriptHash (Script era))
-> Decoder s (Map ScriptHash (Script era))
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
      (forall (v :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      (Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
forall era s.
EraScript era =>
Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
scriptDecoderV9 (PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
fromPlutusScript (PlutusScript era -> Script era)
-> Decoder s (PlutusScript era) -> Decoder s (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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))
      (Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
forall era s.
EraScript era =>
Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
scriptDecoder (PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
fromPlutusScript (PlutusScript era -> Script era)
-> Decoder s (PlutusScript era) -> Decoder s (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 decodeAlonzoPlutusScript #-}

scriptDecoderV9 ::
  EraScript era =>
  Decoder s (Script era) ->
  Decoder s (Map ScriptHash (Script era))
scriptDecoderV9 :: forall era s.
EraScript era =>
Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
scriptDecoderV9 Decoder s (Script era)
decodeScript = do
  Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
  scriptMap <- Decoder s (Maybe Int)
-> Decoder s (ScriptHash, Script era)
-> Decoder s (Map ScriptHash (Script era))
forall k s v.
Ord k =>
Decoder s (Maybe Int) -> Decoder s (k, v) -> Decoder s (Map k v)
decodeMapLikeEnforceNoDuplicates Decoder s (Maybe Int)
forall s. Decoder s (Maybe Int)
decodeListLenOrIndef (Decoder s (ScriptHash, Script era)
 -> Decoder s (Map ScriptHash (Script era)))
-> Decoder s (ScriptHash, Script era)
-> Decoder s (Map ScriptHash (Script era))
forall a b. (a -> b) -> a -> b
$ do
    Script era -> (ScriptHash, Script era)
forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair (Script era -> (ScriptHash, Script era))
-> Decoder s (Script era) -> Decoder s (ScriptHash, Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Script era)
decodeScript
  when (Map.null scriptMap) $ fail "Empty list of scripts is not allowed"
  pure scriptMap
{-# INLINE scriptDecoderV9 #-}

scriptDecoder ::
  EraScript era =>
  Decoder s (Script era) ->
  Decoder s (Map ScriptHash (Script era))
scriptDecoder :: forall era s.
EraScript era =>
Decoder s (Script era) -> Decoder s (Map ScriptHash (Script era))
scriptDecoder Decoder s (Script era)
decodeScript =
  ([(ScriptHash, Script era)] -> Map ScriptHash (Script era))
-> Decoder s [(ScriptHash, Script era)]
-> Decoder s (Map ScriptHash (Script era))
forall a b. (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(ScriptHash, Script era)] -> Map ScriptHash (Script era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (Decoder s [(ScriptHash, Script era)]
 -> Decoder s (Map ScriptHash (Script era)))
-> Decoder s [(ScriptHash, Script era)]
-> Decoder s (Map ScriptHash (Script era))
forall a b. (a -> b) -> a -> b
$
    Decoder s (ScriptHash, Script era)
-> Decoder s [(ScriptHash, Script era)]
forall s a. Decoder s a -> Decoder s [a]
decodeList (Decoder s (ScriptHash, Script era)
 -> Decoder s [(ScriptHash, Script era)])
-> Decoder s (ScriptHash, Script era)
-> Decoder s [(ScriptHash, Script era)]
forall a b. (a -> b) -> a -> b
$
      Script era -> (ScriptHash, Script era)
forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair (Script era -> (ScriptHash, Script era))
-> Decoder s (Script era) -> Decoder s (ScriptHash, Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Script era)
decodeScript
{-# INLINE scriptDecoder #-}

asHashedScriptPair :: forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair :: forall era. EraScript era => Script era -> (ScriptHash, Script era)
asHashedScriptPair Script era
script =
  let !scriptHash :: ScriptHash
scriptHash = forall era. EraScript era => Script era -> ScriptHash
hashScript @era Script era
script
   in (ScriptHash
scriptHash, Script era
script)
{-# INLINE asHashedScriptPair #-}

alonzoEqTxWitsRaw :: AlonzoEraTxWits era => TxWits era -> TxWits era -> Bool
alonzoEqTxWitsRaw :: forall era. AlonzoEraTxWits era => TxWits era -> TxWits era -> Bool
alonzoEqTxWitsRaw TxWits era
txWits1 TxWits era
txWits2 =
  TxWits era -> TxWits era -> Bool
forall era. EraTxWits era => TxWits era -> TxWits era -> Bool
shelleyEqTxWitsRaw TxWits era
txWits1 TxWits era
txWits2
    Bool -> Bool -> Bool
&& TxDats era -> TxDats era -> Bool
forall t. (Memoized t, Eq (RawType t)) => t -> t -> Bool
eqRawType (TxWits era
txWits1 TxWits era
-> Getting (TxDats era) (TxWits era) (TxDats era) -> TxDats era
forall s a. s -> Getting a s a -> a
^. Getting (TxDats era) (TxWits era) (TxDats era)
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens' (TxWits era) (TxDats era)
datsTxWitsL) (TxWits era
txWits2 TxWits era
-> Getting (TxDats era) (TxWits era) (TxDats era) -> TxDats era
forall s a. s -> Getting a s a -> a
^. Getting (TxDats era) (TxWits era) (TxDats era)
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens' (TxWits era) (TxDats era)
datsTxWitsL)
    Bool -> Bool -> Bool
&& Redeemers era -> Redeemers era -> Bool
forall t. (Memoized t, Eq (RawType t)) => t -> t -> Bool
eqRawType (TxWits era
txWits1 TxWits era
-> Getting (Redeemers era) (TxWits era) (Redeemers era)
-> Redeemers era
forall s a. s -> Getting a s a -> a
^. Getting (Redeemers era) (TxWits era) (Redeemers era)
forall era.
AlonzoEraTxWits era =>
Lens' (TxWits era) (Redeemers era)
Lens' (TxWits era) (Redeemers era)
rdmrsTxWitsL) (TxWits era
txWits2 TxWits era
-> Getting (Redeemers era) (TxWits era) (Redeemers era)
-> Redeemers era
forall s a. s -> Getting a s a -> a
^. Getting (Redeemers era) (TxWits era) (Redeemers era)
forall era.
AlonzoEraTxWits era =>
Lens' (TxWits era) (Redeemers era)
Lens' (TxWits era) (Redeemers era)
rdmrsTxWitsL)

encodeWithSetTag :: EncCBOR a => a -> Encoding
encodeWithSetTag :: forall a. EncCBOR a => a -> Encoding
encodeWithSetTag a
xs =
  Version -> Encoding -> Encoding -> Encoding
ifEncodingVersionAtLeast
    (forall (v :: Natural).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
    (Word -> Encoding
encodeTag Word
setTag Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
xs)
    (a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
xs)