{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# 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,
  nullRedeemers,
  lookupRedeemer,
  upgradeRedeemers,
  TxDats (MkTxDats, TxDats, TxDats'),
  TxDatsRaw (..),
  upgradeTxDats,
  AlonzoTxWits (
    MkAlonzoTxWits,
    AlonzoTxWits,
    txwitsVKey,
    txwitsBoot,
    txscripts,
    txdats,
    txrdmrs,
    AlonzoTxWits',
    txwitsVKey',
    txwitsBoot',
    txscripts',
    txdats',
    txrdmrs'
  ),
  AlonzoTxWitsRaw (..),
  addrAlonzoTxWitsL,
  bootAddrAlonzoTxWitsL,
  scriptAlonzoTxWitsL,
  datsAlonzoTxWitsL,
  rdmrsAlonzoTxWitsL,
  AlonzoEraTxWits (..),
  hashDataTxWitsL,
  unTxDats,
  unTxDatsL,
  nullDats,
  alonzoEqTxWitsRaw,
  emptyTxWitsRaw,
  addScriptsTxWitsRaw,
  decodeAlonzoPlutusScript,
  asHashedScriptPair,
) where

import Cardano.Ledger.Alonzo.Era (AlonzoEra)
import Cardano.Ledger.Alonzo.Scripts (
  AlonzoEraScript (..),
  AsIx (..),
  decodePlutusScript,
  fromPlutusScript,
  toPlutusSLanguage,
 )
import Cardano.Ledger.Binary (
  DecCBOR (..),
  DecCBORGroup (..),
  Decoder,
  EncCBOR (..),
  EncCBORGroup (..),
  Encoding,
  ToCBOR (..),
  TokenType (..),
  allowTag,
  decodeList,
  decodeListLenOrIndef,
  decodeListLikeWithCount,
  decodeMapLenOrIndef,
  decodeMapLikeEnforceNoDuplicates,
  decodeNonEmptyList,
  encodeFoldableEncoder,
  encodeListLen,
  encodeTag,
  ifDecoderVersionAtLeast,
  ifEncodingVersionAtLeast,
  natVersion,
  peekTokenType,
  setTag,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Core
import Cardano.Ledger.Keys (BootstrapWitness, WitVKey)
import Cardano.Ledger.MemoBytes (
  EqRaw (..),
  MemoBytes,
  Memoized (..),
  eqRawType,
  getMemoRawType,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Plutus.Data (Data, hashData, upgradeData)
import Cardano.Ledger.Plutus.ExUnits (ExUnits (..))
import Cardano.Ledger.Plutus.Language (
  Language (..),
  Plutus (..),
  PlutusLanguage,
  SLanguage (..),
  plutusBinary,
  plutusLanguage,
 )
import Cardano.Ledger.Shelley.TxWits (
  ShelleyTxWits (..),
  shelleyEqTxWitsRaw,
 )
import Control.DeepSeq (NFData)
import Control.Monad (when, (>=>))
import Data.Bifunctor (Bifunctor (first))
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.Proxy (Proxy (..))
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Typeable (Typeable)
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 :: Nat).
(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
forall {a} {a} {a}.
(EncCBORGroup a, EncCBOR a, EncCBOR a) =>
(a, (a, a)) -> 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 :: (a, (a, a)) -> Encoding
keyValueEncoder (a
ptr, (a
dats, a
exs)) =
        Word -> Encoding
encodeListLen (a -> Word
forall a. EncCBORGroup a => a -> Word
listLen a
ptr Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
2)
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBORGroup a => a -> Encoding
encCBORGroup a
ptr
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
dats
          Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> a -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR a
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, Typeable (Redeemers era)
Typeable (Redeemers era) =>
(forall s. Decoder s (Redeemers era))
-> (forall s. Proxy (Redeemers era) -> Decoder s ())
-> (Proxy (Redeemers era) -> Text)
-> DecCBOR (Redeemers era)
Proxy (Redeemers era) -> Text
forall s. Decoder s (Redeemers era)
forall a.
Typeable a =>
(forall s. Decoder s a)
-> (forall s. Proxy a -> Decoder s ())
-> (Proxy a -> Text)
-> DecCBOR a
forall s. Proxy (Redeemers era) -> Decoder s ()
forall era. AlonzoEraScript era => Typeable (Redeemers era)
forall era. AlonzoEraScript era => Proxy (Redeemers era) -> Text
forall era s. AlonzoEraScript era => Decoder s (Redeemers era)
forall era s.
AlonzoEraScript era =>
Proxy (Redeemers era) -> Decoder s ()
$cdecCBOR :: forall era s. AlonzoEraScript era => Decoder s (Redeemers era)
decCBOR :: forall s. Decoder s (Redeemers era)
$cdropCBOR :: forall era s.
AlonzoEraScript era =>
Proxy (Redeemers era) -> Decoder s ()
dropCBOR :: forall s. Proxy (Redeemers era) -> Decoder s ()
$clabel :: forall era. AlonzoEraScript era => Proxy (Redeemers era) -> Text
label :: Proxy (Redeemers era) -> Text
DecCBOR)

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 #-}

nullRedeemers :: Redeemers era -> Bool
nullRedeemers :: forall era. Redeemers era -> Bool
nullRedeemers = Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Bool
forall k a. Map k a -> Bool
Map.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
{-# DEPRECATED nullRedeemers "In favor of `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

lookupRedeemer ::
  Ord (PlutusPurpose AsIx era) =>
  PlutusPurpose AsIx era ->
  Redeemers era ->
  Maybe (Data era, ExUnits)
lookupRedeemer :: forall era.
Ord (PlutusPurpose AsIx era) =>
PlutusPurpose AsIx era
-> Redeemers era -> Maybe (Data era, ExUnits)
lookupRedeemer PlutusPurpose AsIx era
key = PlutusPurpose AsIx era
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
-> Maybe (Data era, ExUnits)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup PlutusPurpose AsIx era
key (Map (PlutusPurpose AsIx era) (Data era, ExUnits)
 -> Maybe (Data era, ExUnits))
-> (Redeemers era
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> Redeemers era
-> Maybe (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
{-# DEPRECATED lookupRedeemer "In favor of `unRedeemersL`" #-}

-- | Upgrade redeemers from one era to another. The underlying data structure
-- will remain identical, but the memoised serialisation may change to reflect
-- the versioned serialisation of the new era.
upgradeRedeemers ::
  forall era.
  (AlonzoEraScript (PreviousEra era), AlonzoEraScript era) =>
  Redeemers (PreviousEra era) ->
  Redeemers era
upgradeRedeemers :: forall era.
(AlonzoEraScript (PreviousEra era), AlonzoEraScript era) =>
Redeemers (PreviousEra era) -> Redeemers era
upgradeRedeemers =
  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)
-> (Redeemers (PreviousEra era)
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> Redeemers (PreviousEra era)
-> Redeemers era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PlutusPurpose AsIx (PreviousEra era) -> PlutusPurpose AsIx era)
-> Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys PlutusPurpose AsIx (PreviousEra era) -> PlutusPurpose AsIx era
forall era.
(AlonzoEraScript era, AlonzoEraScript (PreviousEra era)) =>
PlutusPurpose AsIx (PreviousEra era) -> PlutusPurpose AsIx era
upgradePlutusPurposeAsIx
    (Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits)
 -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> (Redeemers (PreviousEra era)
    -> Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits))
-> Redeemers (PreviousEra era)
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Data (PreviousEra era), ExUnits) -> (Data era, ExUnits))
-> Map
     (PlutusPurpose AsIx (PreviousEra era))
     (Data (PreviousEra era), ExUnits)
-> Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map ((Data (PreviousEra era) -> Data era)
-> (Data (PreviousEra era), ExUnits) -> (Data era, ExUnits)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Data (PreviousEra era) -> Data era
forall era1 era2. (Era era1, Era era2) => Data era1 -> Data era2
upgradeData)
    (Map
   (PlutusPurpose AsIx (PreviousEra era))
   (Data (PreviousEra era), ExUnits)
 -> Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits))
-> (Redeemers (PreviousEra era)
    -> Map
         (PlutusPurpose AsIx (PreviousEra era))
         (Data (PreviousEra era), ExUnits))
-> Redeemers (PreviousEra era)
-> Map (PlutusPurpose AsIx (PreviousEra era)) (Data era, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Redeemers (PreviousEra era)
-> Map
     (PlutusPurpose AsIx (PreviousEra era))
     (Data (PreviousEra era), ExUnits)
forall era.
Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
unRedeemers

-- ====================================================================
-- 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 (Typeable era, 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' :: Map DataHash (Data era) -> TxDats era
pattern $mTxDats' :: forall {r} {era}.
TxDats era -> (Map DataHash (Data era) -> r) -> ((# #) -> r) -> r
TxDats' m <- (getMemoRawType -> TxDatsRaw m)

{-# COMPLETE TxDats' #-}

{-# DEPRECATED TxDats' "In favor of `TxDats`" #-}

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 #-}

nullDats :: TxDats era -> Bool
nullDats :: forall era. TxDats era -> Bool
nullDats (TxDats era -> RawType (TxDats era)
forall t. Memoized t => t -> RawType t
getMemoRawType -> TxDatsRaw Map DataHash (Data era)
m) = Map DataHash (Data era) -> Bool
forall k a. Map k a -> Bool
Map.null Map DataHash (Data era)
m
{-# DEPRECATED nullDats "In favor of `unTxDatsL`" #-}

instance Era era => DecCBOR (TxDatsRaw era) where
  decCBOR :: forall s. Decoder s (TxDatsRaw era)
decCBOR =
    Version
-> Decoder s (TxDatsRaw era)
-> Decoder s (TxDatsRaw era)
-> Decoder s (TxDatsRaw era)
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
      (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
          Decoder s ()
-> Decoder s (TxDatsRaw era) -> Decoder s (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
>> 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 (NonEmpty (Data era) -> TxDatsRaw era)
-> Decoder s (NonEmpty (Data era)) -> Decoder s (TxDatsRaw era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Data era) -> Decoder s (NonEmpty (Data era))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (Data era)
forall s. Decoder s (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 ([Data era] -> TxDatsRaw era)
-> Decoder s [Data era] -> Decoder s (TxDatsRaw era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Data era) -> Decoder s [Data era]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (Data era)
forall s. Decoder s (Data era)
forall a s. DecCBOR a => Decoder s a
decCBOR)
  {-# 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, Typeable (TxDats era)
Typeable (TxDats era) =>
(forall s. Decoder s (TxDats era))
-> (forall s. Proxy (TxDats era) -> Decoder s ())
-> (Proxy (TxDats era) -> Text)
-> DecCBOR (TxDats era)
Proxy (TxDats era) -> Text
forall s. Decoder s (TxDats era)
forall a.
Typeable a =>
(forall s. Decoder s a)
-> (forall s. Proxy a -> Decoder s ())
-> (Proxy a -> Text)
-> DecCBOR a
forall s. Proxy (TxDats era) -> Decoder s ()
forall era. Era era => Typeable (TxDats era)
forall era. Era era => Proxy (TxDats era) -> Text
forall era s. Era era => Decoder s (TxDats era)
forall era s. Era era => Proxy (TxDats era) -> Decoder s ()
$cdecCBOR :: forall era s. Era era => Decoder s (TxDats era)
decCBOR :: forall s. Decoder s (TxDats era)
$cdropCBOR :: forall era s. Era era => Proxy (TxDats era) -> Decoder s ()
dropCBOR :: forall s. Proxy (TxDats era) -> Decoder s ()
$clabel :: forall era. Era era => Proxy (TxDats era) -> Text
label :: Proxy (TxDats era) -> Text
DecCBOR)
  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 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)

-- | Upgrade 'TxDats' from one era to another. The underlying data structure
-- will remain identical, but the memoised serialisation may change to reflect
-- the versioned serialisation of the new era.
upgradeTxDats ::
  (Era era1, Era era2) =>
  TxDats era1 ->
  TxDats era2
upgradeTxDats :: forall era1 era2.
(Era era1, Era era2) =>
TxDats era1 -> TxDats era2
upgradeTxDats (TxDats Map DataHash (Data era1)
datMap) = Map DataHash (Data era2) -> TxDats era2
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats (Map DataHash (Data era2) -> TxDats era2)
-> Map DataHash (Data era2) -> TxDats era2
forall a b. (a -> b) -> a -> b
$ (Data era1 -> Data era2)
-> Map DataHash (Data era1) -> Map DataHash (Data era2)
forall a b. (a -> b) -> Map DataHash a -> Map DataHash b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Data era1 -> Data era2
forall era1 era2. (Era era1, Era era2) => Data era1 -> Data era2
upgradeData Map DataHash (Data era1)
datMap

-- =====================================================
-- 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' ::
  Era era =>
  Set (WitVKey 'Witness) ->
  Set BootstrapWitness ->
  Map ScriptHash (Script era) ->
  TxDats era ->
  Redeemers era ->
  AlonzoTxWits era
pattern $mAlonzoTxWits' :: forall {r} {era}.
Era era =>
AlonzoTxWits era
-> (Set (WitVKey 'Witness)
    -> Set BootstrapWitness
    -> Map ScriptHash (Script era)
    -> TxDats era
    -> Redeemers era
    -> r)
-> ((# #) -> r)
-> r
AlonzoTxWits' {forall era. Era era => AlonzoTxWits era -> Set (WitVKey 'Witness)
txwitsVKey', forall era. Era era => AlonzoTxWits era -> Set BootstrapWitness
txwitsBoot', forall era.
Era era =>
AlonzoTxWits era -> Map ScriptHash (Script era)
txscripts', forall era. Era era => AlonzoTxWits era -> TxDats era
txdats', forall era. Era era => AlonzoTxWits era -> Redeemers era
txrdmrs'} <-
  (getMemoRawType -> AlonzoTxWitsRaw txwitsVKey' txwitsBoot' txscripts' txdats' txrdmrs')

{-# COMPLETE AlonzoTxWits' #-}

{-# DEPRECATED AlonzoTxWits' "In favor of `AlonzoTxWits`" #-}

{-# DEPRECATED txwitsVKey' "In favor of `txwitsVKey`" #-}

{-# DEPRECATED txwitsBoot' "In favor of `txwitsBoot`" #-}

{-# DEPRECATED txscripts' "In favor of `txscripts`" #-}

{-# DEPRECATED txdats' "In favor of `txdats`" #-}

{-# DEPRECATED txrdmrs' "In favor of `txrdmrs`" #-}

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))
 -> forall {f :: * -> *}.
    Functor f =>
    (Set (WitVKey 'Witness) -> f (Set (WitVKey 'Witness)))
    -> AlonzoTxWits era -> f (AlonzoTxWits era))
-> (RawType (AlonzoTxWits era)
    -> Set (WitVKey 'Witness) -> RawType (AlonzoTxWits era))
-> forall {f :: * -> *}.
   Functor f =>
   (Set (WitVKey 'Witness) -> f (Set (WitVKey 'Witness)))
   -> AlonzoTxWits era -> f (AlonzoTxWits era)
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))
 -> forall {f :: * -> *}.
    Functor f =>
    (Set BootstrapWitness -> f (Set BootstrapWitness))
    -> AlonzoTxWits era -> f (AlonzoTxWits era))
-> (RawType (AlonzoTxWits era)
    -> Set BootstrapWitness -> RawType (AlonzoTxWits era))
-> forall {f :: * -> *}.
   Functor f =>
   (Set BootstrapWitness -> f (Set BootstrapWitness))
   -> AlonzoTxWits era -> f (AlonzoTxWits era)
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))
 -> forall {f :: * -> *}.
    Functor f =>
    (Map ScriptHash (Script era) -> f (Map ScriptHash (Script era)))
    -> AlonzoTxWits era -> f (AlonzoTxWits era))
-> (RawType (AlonzoTxWits era)
    -> Map ScriptHash (Script era) -> RawType (AlonzoTxWits era))
-> forall {f :: * -> *}.
   Functor f =>
   (Map ScriptHash (Script era) -> f (Map ScriptHash (Script era)))
   -> AlonzoTxWits era -> f (AlonzoTxWits 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))
 -> forall {f :: * -> *}.
    Functor f =>
    (TxDats era -> f (TxDats era))
    -> AlonzoTxWits era -> f (AlonzoTxWits era))
-> (RawType (AlonzoTxWits era)
    -> TxDats era -> RawType (AlonzoTxWits era))
-> forall {f :: * -> *}.
   Functor f =>
   (TxDats era -> f (TxDats era))
   -> AlonzoTxWits era -> f (AlonzoTxWits 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))
 -> forall {f :: * -> *}.
    Functor f =>
    (Redeemers era -> f (Redeemers era))
    -> AlonzoTxWits era -> f (AlonzoTxWits era))
-> (RawType (AlonzoTxWits era)
    -> Redeemers era -> RawType (AlonzoTxWits era))
-> forall {f :: * -> *}.
   Functor f =>
   (Redeemers era -> f (Redeemers era))
   -> AlonzoTxWits era -> f (AlonzoTxWits era)
forall a b. (a -> b) -> a -> b
$
    \RawType (AlonzoTxWits era)
witsRaw Redeemers era
rdmrsWits -> RawType (AlonzoTxWits era)
witsRaw {atwrRdmrsTxWits = rdmrsWits}
{-# INLINEABLE rdmrsAlonzoTxWitsL #-}

instance EraScript AlonzoEra => 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 #-}

  upgradeTxWits :: EraTxWits (PreviousEra AlonzoEra) =>
TxWits (PreviousEra AlonzoEra) -> TxWits AlonzoEra
upgradeTxWits (ShelleyTxWits {Set (WitVKey 'Witness)
addrWits :: Set (WitVKey 'Witness)
addrWits :: forall era.
EraScript era =>
ShelleyTxWits era -> Set (WitVKey 'Witness)
addrWits, Map ScriptHash (Script MaryEra)
scriptWits :: Map ScriptHash (Script MaryEra)
scriptWits :: forall era.
EraScript era =>
ShelleyTxWits era -> Map ScriptHash (Script era)
scriptWits, Set BootstrapWitness
bootWits :: Set BootstrapWitness
bootWits :: forall era.
EraScript era =>
ShelleyTxWits era -> Set BootstrapWitness
bootWits}) =
    Set (WitVKey 'Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script AlonzoEra)
-> TxDats AlonzoEra
-> Redeemers AlonzoEra
-> AlonzoTxWits AlonzoEra
forall era.
AlonzoEraScript era =>
Set (WitVKey 'Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
AlonzoTxWits Set (WitVKey 'Witness)
addrWits Set BootstrapWitness
bootWits (Script (PreviousEra AlonzoEra) -> Script AlonzoEra
Script (PreviousEra AlonzoEra) -> AlonzoScript AlonzoEra
forall era.
(EraScript era, EraScript (PreviousEra era)) =>
Script (PreviousEra era) -> Script era
upgradeScript (Script (PreviousEra AlonzoEra) -> AlonzoScript AlonzoEra)
-> Map ScriptHash (Script (PreviousEra AlonzoEra))
-> Map ScriptHash (AlonzoScript AlonzoEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map ScriptHash (Script (PreviousEra AlonzoEra))
Map ScriptHash (Script MaryEra)
scriptWits) TxDats AlonzoEra
forall a. Monoid a => a
mempty Redeemers AlonzoEra
forall era. AlonzoEraScript era => Redeemers era
emptyRedeemers

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

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

instance EraScript AlonzoEra => 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 (Plutus l -> Maybe (Script era))
-> Map h (Plutus l) -> Maybe (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)
-> Maybe (PlutusScript era) -> Maybe (Script era)
forall a b. (a -> b) -> Maybe a -> Maybe 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 (Maybe (PlutusScript era) -> Maybe (Script era))
-> (Plutus l -> Maybe (PlutusScript era))
-> Plutus l
-> Maybe (Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Plutus l -> Maybe (PlutusScript era)
forall era (l :: Language).
(AlonzoEraScript era, PlutusLanguage l) =>
Plutus l -> Maybe (PlutusScript era)
forall (l :: Language).
PlutusLanguage l =>
Plutus l -> Maybe (PlutusScript era)
mkPlutusScript) Map h (Plutus l)
ps of
          Maybe (Map h (Script era))
Nothing ->
            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. [a] -> [a] -> [a]
++ Language -> String
forall a. Show a => a -> String
show (Proxy l -> Language
forall (l :: Language) (proxy :: Language -> *).
PlutusLanguage l =>
proxy l -> Language
plutusLanguage (forall {k} (t :: k). Proxy t
forall (t :: Language). Proxy t
Proxy @l))
          Just Map h (Script era)
plutusScripts -> Map h (Script era)
plutusScripts

instance AlonzoEraScript era => DecCBOR (RedeemersRaw era) where
  decCBOR :: forall s. Decoder s (RedeemersRaw era)
decCBOR =
    Version
-> Decoder s (RedeemersRaw era)
-> Decoder s (RedeemersRaw era)
-> Decoder s (RedeemersRaw era)
forall s a. Version -> Decoder s a -> Decoder s a -> Decoder s a
ifDecoderVersionAtLeast
      (forall (v :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
      ( Decoder s TokenType
forall s. Decoder s TokenType
peekTokenType Decoder s TokenType
-> (TokenType -> Decoder s (RedeemersRaw era))
-> Decoder s (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 (RedeemersRaw era)
forall s. Decoder s (RedeemersRaw era)
decodeMapRedeemers
          TokenType
TypeMapLen -> Decoder s (RedeemersRaw era)
forall s. Decoder s (RedeemersRaw era)
decodeMapRedeemers
          TokenType
_ -> Decoder s (RedeemersRaw era)
forall s. Decoder s (RedeemersRaw era)
decodeListRedeemers
      )
      (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 ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
 -> RedeemersRaw era)
-> Decoder s [(PlutusPurpose AsIx era, (Data era, ExUnits))]
-> Decoder s (RedeemersRaw era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder s [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall s a. Decoder s a -> Decoder s [a]
decodeList Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall s. Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
decodeElement)
    where
      decodeMapRedeemers :: Decoder s (RedeemersRaw era)
      decodeMapRedeemers :: forall s. Decoder s (RedeemersRaw era)
decodeMapRedeemers =
        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)
-> (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> NonEmpty (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 ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
 -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
    -> [(PlutusPurpose AsIx era, (Data era, ExUnits))])
-> NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> RedeemersRaw era)
-> Decoder
     s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder s (RedeemersRaw era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> do
          (Int
_, [(PlutusPurpose AsIx era, (Data era, ExUnits))]
xs) <- Decoder s (Maybe Int)
-> ((PlutusPurpose AsIx era, (Data era, ExUnits))
    -> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> [(PlutusPurpose AsIx era, (Data era, ExUnits))])
-> ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder s (Int, [(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 (:) (([(PlutusPurpose AsIx era, (Data era, ExUnits))]
  -> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits)))
 -> Decoder
      s (Int, [(PlutusPurpose AsIx era, (Data era, ExUnits))]))
-> ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
    -> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder s (Int, [(PlutusPurpose AsIx era, (Data era, ExUnits))])
forall a b. (a -> b) -> a -> b
$ \[(PlutusPurpose AsIx era, (Data era, ExUnits))]
_ -> do
            PlutusPurpose AsIx era
ptr <- Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBOR a => Decoder s a
decCBOR
            (Data era
annData, ExUnits
exUnits) <- Decoder s (Data era, ExUnits)
forall s. Decoder s (Data era, ExUnits)
forall a s. DecCBOR a => Decoder s a
decCBOR
            (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PlutusPurpose AsIx era
ptr, (Data era
annData, ExUnits
exUnits))
          case [(PlutusPurpose AsIx era, (Data era, ExUnits))]
-> Maybe (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a. [a] -> Maybe (NonEmpty a)
NE.nonEmpty [(PlutusPurpose AsIx era, (Data era, ExUnits))]
xs of
            Maybe (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
Nothing -> String
-> Decoder
     s (NonEmpty (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 (PlutusPurpose AsIx era, (Data era, ExUnits))
neList -> NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> Decoder
      s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))))
-> NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall a b. (a -> b) -> a -> b
$ NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a. NonEmpty a -> NonEmpty a
NE.reverse NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
neList
      {-# INLINE decodeMapRedeemers #-}
      decodeListRedeemers :: Decoder s (RedeemersRaw era)
      decodeListRedeemers :: forall s. Decoder s (RedeemersRaw era)
decodeListRedeemers =
        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)
-> (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
    -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> NonEmpty (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 ([(PlutusPurpose AsIx era, (Data era, ExUnits))]
 -> Map (PlutusPurpose AsIx era) (Data era, ExUnits))
-> (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
    -> [(PlutusPurpose AsIx era, (Data era, ExUnits))])
-> NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall a. NonEmpty a -> [a]
NE.toList
          (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> RedeemersRaw era)
-> Decoder
     s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder s (RedeemersRaw era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder
     s (NonEmpty (PlutusPurpose AsIx era, (Data era, ExUnits)))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall s. Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
decodeElement
      {-# INLINE decodeListRedeemers #-}
      decodeElement :: Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
      decodeElement :: forall s. Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
decodeElement = do
        Text
-> ((PlutusPurpose AsIx era, (Data era, ExUnits)) -> Int)
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed Text
"Redeemer" (\(PlutusPurpose AsIx era
redeemerPtr, (Data era, ExUnits)
_) -> Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (PlutusPurpose AsIx era -> Word
forall a. EncCBORGroup a => a -> Word
listLen PlutusPurpose AsIx era
redeemerPtr) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) (Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
 -> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a b. (a -> b) -> a -> b
$ do
          !PlutusPurpose AsIx era
redeemerPtr <- Decoder s (PlutusPurpose AsIx era)
forall s. Decoder s (PlutusPurpose AsIx era)
forall a s. DecCBORGroup a => Decoder s a
decCBORGroup
          !Data era
redeemerData <- Decoder s (Data era)
forall s. Decoder s (Data era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          !ExUnits
redeemerExUnits <- Decoder s ExUnits
forall s. Decoder s ExUnits
forall a s. DecCBOR a => Decoder s a
decCBOR
          (PlutusPurpose AsIx era, (Data era, ExUnits))
-> Decoder s (PlutusPurpose AsIx era, (Data era, ExUnits))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PlutusPurpose AsIx era
redeemerPtr, (Data era
redeemerData, ExUnits
redeemerExUnits))
      {-# INLINE decodeElement #-}
  {-# INLINE decCBOR #-}

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

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

      nativeScriptsDecoder :: Decoder s (Map ScriptHash (Script era))
      nativeScriptsDecoder :: forall s. Decoder s (Map ScriptHash (Script era))
nativeScriptsDecoder =
        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 :: Nat).
(KnownNat v, MinVersion <= v, v <= MaxVersion) =>
Version
natVersion @9)
          ( Word -> Decoder s ()
forall s. Word -> Decoder s ()
allowTag Word
setTag
              Decoder s ()
-> Decoder s (Map ScriptHash (Script era))
-> Decoder s (Map ScriptHash (Script era))
forall a b. Decoder s a -> Decoder s b -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [(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 (NonEmpty (ScriptHash, Script era) -> Map ScriptHash (Script era))
-> Decoder s (NonEmpty (ScriptHash, Script era))
-> Decoder s (Map ScriptHash (Script era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (ScriptHash, Script era)
-> Decoder s (NonEmpty (ScriptHash, Script era))
forall s a. Decoder s a -> Decoder s (NonEmpty a)
decodeNonEmptyList Decoder s (ScriptHash, Script era)
forall s. Decoder s (ScriptHash, Script era)
pairDecoder
          )
          ([(ScriptHash, Script era)] -> Map ScriptHash (Script era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ScriptHash, Script era)] -> Map ScriptHash (Script era))
-> Decoder s [(ScriptHash, Script era)]
-> Decoder s (Map ScriptHash (Script era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f 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)
forall s. Decoder s (ScriptHash, Script era)
pairDecoder)
        where
          pairDecoder :: Decoder s (ScriptHash, Script era)
          pairDecoder :: forall s. Decoder s (ScriptHash, Script era)
pairDecoder = 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 (NativeScript era -> (ScriptHash, Script era))
-> Decoder s (NativeScript era)
-> Decoder s (ScriptHash, Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (NativeScript era)
forall s. Decoder s (NativeScript era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          {-# INLINE pairDecoder #-}
      {-# INLINE nativeScriptsDecoder #-}

deriving newtype instance AlonzoEraScript era => DecCBOR (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 :: Nat).
(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
  Map ScriptHash (Script era)
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
  Bool -> Decoder s () -> Decoder s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Map ScriptHash (Script era) -> Bool
forall k a. Map k a -> Bool
Map.null Map ScriptHash (Script era)
scriptMap) (Decoder s () -> Decoder s ()) -> Decoder s () -> Decoder s ()
forall a b. (a -> b) -> a -> b
$ String -> Decoder s ()
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Empty list of scripts is not allowed"
  Map ScriptHash (Script era)
-> Decoder s (Map ScriptHash (Script era))
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map ScriptHash (Script era)
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 :: Nat).
(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)