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

module Cardano.Ledger.Babbage.TxOut (
  BabbageTxOut (
    BabbageTxOut,
    TxOutCompact,
    TxOutCompactDH,
    TxOutCompactDatum,
    TxOutCompactRefScript
  ),
  BabbageEraTxOut (..),
  TxOut,
  addrEitherBabbageTxOutL,
  valueEitherBabbageTxOutL,
  dataHashBabbageTxOutL,
  dataBabbageTxOutL,
  datumBabbageTxOutL,
  referenceScriptBabbageTxOutL,
  getDatumBabbageTxOut,
  babbageMinUTxOValue,
  getEitherAddrBabbageTxOut,
  txOutData,
  txOutDataHash,
  txOutScript,
  internBabbageTxOut,
) where

import Cardano.Ledger.Address (
  Addr (..),
  CompactAddr,
  compactAddr,
  decompactAddr,
  fromCborBothAddr,
 )
import Cardano.Ledger.Alonzo.Core
import Cardano.Ledger.Alonzo.TxBody (
  Addr28Extra,
  AlonzoTxOut (AlonzoTxOut),
  DataHash32,
  decodeAddress28,
  decodeDataHash32,
  encodeAddress28,
  encodeDataHash32,
  getAdaOnly,
 )
import qualified Cardano.Ledger.Alonzo.TxBody as Alonzo
import Cardano.Ledger.Babbage.Era (BabbageEra)
import Cardano.Ledger.Babbage.PParams (
  BabbageEraPParams (..),
  CoinPerByte (..),
  ppCoinsPerUTxOByteL,
 )
import Cardano.Ledger.Babbage.Scripts ()
import Cardano.Ledger.BaseTypes (
  StrictMaybe (..),
  strictMaybeToMaybe,
 )
import Cardano.Ledger.Binary (
  DecCBOR (..),
  DecShareCBOR (..),
  Decoder,
  DecoderError (..),
  EncCBOR (..),
  Encoding,
  FromCBOR (..),
  Interns,
  Sized (..),
  ToCBOR (..),
  TokenType (..),
  cborError,
  decodeBreakOr,
  decodeFull',
  decodeListLenOrIndef,
  decodeMemPack,
  decodeNestedCborBytes,
  encodeListLen,
  encodeNestedCbor,
  getDecoderVersion,
  interns,
  peekTokenType,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Compactible
import Cardano.Ledger.Credential (Credential (..), StakeReference (..))
import Cardano.Ledger.Plutus.Data (
  BinaryData,
  Data,
  Datum (..),
  binaryDataToData,
  dataToBinaryData,
 )
import Cardano.Ledger.Val (Val (..))
import Control.DeepSeq (NFData (rnf), rwhnf)
import Data.Aeson (KeyValue, ToJSON (..), object, pairs, (.=))
import Data.Maybe (fromMaybe)
import Data.MemPack
import qualified Data.Text as T
import Data.Typeable (Proxy (..))
import GHC.Generics (Generic)
import GHC.Stack (HasCallStack)
import Lens.Micro (Lens', lens, to, (^.))
import NoThunks.Class (NoThunks)

class (AlonzoEraTxOut era, AlonzoEraScript era) => BabbageEraTxOut era where
  referenceScriptTxOutL :: Lens' (TxOut era) (StrictMaybe (Script era))

  dataTxOutL :: Lens' (TxOut era) (StrictMaybe (Data era))

  datumTxOutL :: Lens' (TxOut era) (Datum era)

data BabbageTxOut era
  = TxOutCompact'
      {-# UNPACK #-} !CompactAddr
      !(CompactForm (Value era))
  | TxOutCompactDH'
      {-# UNPACK #-} !CompactAddr
      !(CompactForm (Value era))
      !DataHash
  | TxOutCompactDatum
      {-# UNPACK #-} !CompactAddr
      !(CompactForm (Value era))
      {-# UNPACK #-} !(BinaryData era) -- Inline data
  | TxOutCompactRefScript
      {-# UNPACK #-} !CompactAddr
      !(CompactForm (Value era))
      !(Datum era)
      !(Script era)
  | TxOut_AddrHash28_AdaOnly
      !(Credential 'Staking)
      {-# UNPACK #-} !Addr28Extra
      {-# UNPACK #-} !(CompactForm Coin) -- Ada value
  | TxOut_AddrHash28_AdaOnly_DataHash32
      !(Credential 'Staking)
      {-# UNPACK #-} !Addr28Extra
      {-# UNPACK #-} !(CompactForm Coin) -- Ada value
      {-# UNPACK #-} !DataHash32
  deriving ((forall x. BabbageTxOut era -> Rep (BabbageTxOut era) x)
-> (forall x. Rep (BabbageTxOut era) x -> BabbageTxOut era)
-> Generic (BabbageTxOut era)
forall x. Rep (BabbageTxOut era) x -> BabbageTxOut era
forall x. BabbageTxOut era -> Rep (BabbageTxOut era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (BabbageTxOut era) x -> BabbageTxOut era
forall era x. BabbageTxOut era -> Rep (BabbageTxOut era) x
$cfrom :: forall era x. BabbageTxOut era -> Rep (BabbageTxOut era) x
from :: forall x. BabbageTxOut era -> Rep (BabbageTxOut era) x
$cto :: forall era x. Rep (BabbageTxOut era) x -> BabbageTxOut era
to :: forall x. Rep (BabbageTxOut era) x -> BabbageTxOut era
Generic)

-- | This instance is backwards compatible in binary representation with TxOut instances for all
-- previous era
instance
  ( Era era
  , MemPack (Script era)
  , MemPack (CompactForm (Value era))
  ) =>
  MemPack (BabbageTxOut era)
  where
  packedByteCount :: BabbageTxOut era -> Int
packedByteCount = \case
    TxOutCompact' CompactAddr
cAddr CompactForm (Value era)
cValue ->
      Int
packedTagByteCount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactAddr -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactAddr
cAddr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm (Value era) -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm (Value era)
cValue
    TxOutCompactDH' CompactAddr
cAddr CompactForm (Value era)
cValue DataHash
dataHash ->
      Int
packedTagByteCount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactAddr -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactAddr
cAddr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm (Value era) -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm (Value era)
cValue Int -> Int -> Int
forall a. Num a => a -> a -> a
+ DataHash -> Int
forall a. MemPack a => a -> Int
packedByteCount DataHash
dataHash
    TxOut_AddrHash28_AdaOnly Credential 'Staking
cred Addr28Extra
addr28 CompactForm Coin
cCoin ->
      Int
packedTagByteCount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Credential 'Staking -> Int
forall a. MemPack a => a -> Int
packedByteCount Credential 'Staking
cred Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Addr28Extra -> Int
forall a. MemPack a => a -> Int
packedByteCount Addr28Extra
addr28 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm Coin -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm Coin
cCoin
    TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
cred Addr28Extra
addr28 CompactForm Coin
cCoin DataHash32
dataHash32 ->
      Int
packedTagByteCount
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Credential 'Staking -> Int
forall a. MemPack a => a -> Int
packedByteCount Credential 'Staking
cred
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Addr28Extra -> Int
forall a. MemPack a => a -> Int
packedByteCount Addr28Extra
addr28
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm Coin -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm Coin
cCoin
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ DataHash32 -> Int
forall a. MemPack a => a -> Int
packedByteCount DataHash32
dataHash32
    TxOutCompactDatum CompactAddr
cAddr CompactForm (Value era)
cValue BinaryData era
datum ->
      Int
packedTagByteCount Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactAddr -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactAddr
cAddr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm (Value era) -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm (Value era)
cValue Int -> Int -> Int
forall a. Num a => a -> a -> a
+ BinaryData era -> Int
forall a. MemPack a => a -> Int
packedByteCount BinaryData era
datum
    TxOutCompactRefScript CompactAddr
cAddr CompactForm (Value era)
cValue Datum era
datum Script era
script ->
      Int
packedTagByteCount
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactAddr -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactAddr
cAddr
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CompactForm (Value era) -> Int
forall a. MemPack a => a -> Int
packedByteCount CompactForm (Value era)
cValue
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Datum era -> Int
forall a. MemPack a => a -> Int
packedByteCount Datum era
datum
        Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Script era -> Int
forall a. MemPack a => a -> Int
packedByteCount Script era
script
  {-# INLINE packedByteCount #-}
  packM :: forall s. BabbageTxOut era -> Pack s ()
packM = \case
    TxOutCompact' CompactAddr
cAddr CompactForm (Value era)
cValue ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
0 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactAddr -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactAddr -> Pack s ()
packM CompactAddr
cAddr Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm (Value era) -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm (Value era) -> Pack s ()
packM CompactForm (Value era)
cValue
    TxOutCompactDH' CompactAddr
cAddr CompactForm (Value era)
cValue DataHash
dataHash ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
1 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactAddr -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactAddr -> Pack s ()
packM CompactAddr
cAddr Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm (Value era) -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm (Value era) -> Pack s ()
packM CompactForm (Value era)
cValue Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DataHash -> Pack s ()
forall s. DataHash -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM DataHash
dataHash
    TxOut_AddrHash28_AdaOnly Credential 'Staking
cred Addr28Extra
addr28 CompactForm Coin
cCoin ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
2 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Credential 'Staking -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. Credential 'Staking -> Pack s ()
packM Credential 'Staking
cred Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Addr28Extra -> Pack s ()
forall s. Addr28Extra -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM Addr28Extra
addr28 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm Coin -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm Coin -> Pack s ()
packM CompactForm Coin
cCoin
    TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
cred Addr28Extra
addr28 CompactForm Coin
cCoin DataHash32
dataHash32 ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
3 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Credential 'Staking -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. Credential 'Staking -> Pack s ()
packM Credential 'Staking
cred Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Addr28Extra -> Pack s ()
forall s. Addr28Extra -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM Addr28Extra
addr28 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm Coin -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm Coin -> Pack s ()
packM CompactForm Coin
cCoin Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DataHash32 -> Pack s ()
forall s. DataHash32 -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM DataHash32
dataHash32
    TxOutCompactDatum CompactAddr
cAddr CompactForm (Value era)
cValue BinaryData era
datum ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
4 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactAddr -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactAddr -> Pack s ()
packM CompactAddr
cAddr Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm (Value era) -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm (Value era) -> Pack s ()
packM CompactForm (Value era)
cValue Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BinaryData era -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. BinaryData era -> Pack s ()
packM BinaryData era
datum
    TxOutCompactRefScript CompactAddr
cAddr CompactForm (Value era)
cValue Datum era
datum Script era
script ->
      Tag -> Pack s ()
forall s. Tag -> Pack s ()
packTagM Tag
5 Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactAddr -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactAddr -> Pack s ()
packM CompactAddr
cAddr Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CompactForm (Value era) -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. CompactForm (Value era) -> Pack s ()
packM CompactForm (Value era)
cValue Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Datum era -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
forall s. Datum era -> Pack s ()
packM Datum era
datum Pack s () -> Pack s () -> Pack s ()
forall a b. Pack s a -> Pack s b -> Pack s b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Script era -> Pack s ()
forall s. Script era -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM Script era
script
  {-# INLINE packM #-}
  unpackM :: forall b. Buffer b => Unpack b (BabbageTxOut era)
unpackM =
    Unpack b Tag
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b Tag
unpackM Unpack b Tag
-> (Tag -> Unpack b (BabbageTxOut era))
-> Unpack b (BabbageTxOut era)
forall a b. Unpack b a -> (a -> Unpack b b) -> Unpack b b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Tag
0 -> CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
forall era.
CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
TxOutCompact' (CompactAddr -> CompactForm (Value era) -> BabbageTxOut era)
-> Unpack b CompactAddr
-> Unpack b (CompactForm (Value era) -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b CompactAddr
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b CompactAddr
unpackM Unpack b (CompactForm (Value era) -> BabbageTxOut era)
-> Unpack b (CompactForm (Value era))
-> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm (Value era))
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm (Value era))
unpackM
      Tag
1 -> CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
TxOutCompactDH' (CompactAddr
 -> CompactForm (Value era) -> DataHash -> BabbageTxOut era)
-> Unpack b CompactAddr
-> Unpack
     b (CompactForm (Value era) -> DataHash -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b CompactAddr
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b CompactAddr
unpackM Unpack b (CompactForm (Value era) -> DataHash -> BabbageTxOut era)
-> Unpack b (CompactForm (Value era))
-> Unpack b (DataHash -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm (Value era))
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm (Value era))
unpackM Unpack b (DataHash -> BabbageTxOut era)
-> Unpack b DataHash -> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b DataHash
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b DataHash
unpackM
      Tag
2 -> Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
TxOut_AddrHash28_AdaOnly (Credential 'Staking
 -> Addr28Extra -> CompactForm Coin -> BabbageTxOut era)
-> Unpack b (Credential 'Staking)
-> Unpack b (Addr28Extra -> CompactForm Coin -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b (Credential 'Staking)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (Credential 'Staking)
unpackM Unpack b (Addr28Extra -> CompactForm Coin -> BabbageTxOut era)
-> Unpack b Addr28Extra
-> Unpack b (CompactForm Coin -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b Addr28Extra
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b Addr28Extra
unpackM Unpack b (CompactForm Coin -> BabbageTxOut era)
-> Unpack b (CompactForm Coin) -> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm Coin)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm Coin)
unpackM
      Tag
3 -> Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
TxOut_AddrHash28_AdaOnly_DataHash32 (Credential 'Staking
 -> Addr28Extra
 -> CompactForm Coin
 -> DataHash32
 -> BabbageTxOut era)
-> Unpack b (Credential 'Staking)
-> Unpack
     b
     (Addr28Extra -> CompactForm Coin -> DataHash32 -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b (Credential 'Staking)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (Credential 'Staking)
unpackM Unpack
  b
  (Addr28Extra -> CompactForm Coin -> DataHash32 -> BabbageTxOut era)
-> Unpack b Addr28Extra
-> Unpack b (CompactForm Coin -> DataHash32 -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b Addr28Extra
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b Addr28Extra
unpackM Unpack b (CompactForm Coin -> DataHash32 -> BabbageTxOut era)
-> Unpack b (CompactForm Coin)
-> Unpack b (DataHash32 -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm Coin)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm Coin)
unpackM Unpack b (DataHash32 -> BabbageTxOut era)
-> Unpack b DataHash32 -> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b DataHash32
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b DataHash32
unpackM
      Tag
4 -> CompactAddr
-> CompactForm (Value era) -> BinaryData era -> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era) -> BinaryData era -> BabbageTxOut era
TxOutCompactDatum (CompactAddr
 -> CompactForm (Value era) -> BinaryData era -> BabbageTxOut era)
-> Unpack b CompactAddr
-> Unpack
     b (CompactForm (Value era) -> BinaryData era -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b CompactAddr
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b CompactAddr
unpackM Unpack
  b (CompactForm (Value era) -> BinaryData era -> BabbageTxOut era)
-> Unpack b (CompactForm (Value era))
-> Unpack b (BinaryData era -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm (Value era))
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm (Value era))
unpackM Unpack b (BinaryData era -> BabbageTxOut era)
-> Unpack b (BinaryData era) -> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (BinaryData era)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (BinaryData era)
unpackM
      Tag
5 -> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> Script era
-> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era)
-> Datum era
-> Script era
-> BabbageTxOut era
TxOutCompactRefScript (CompactAddr
 -> CompactForm (Value era)
 -> Datum era
 -> Script era
 -> BabbageTxOut era)
-> Unpack b CompactAddr
-> Unpack
     b
     (CompactForm (Value era)
      -> Datum era -> Script era -> BabbageTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack b CompactAddr
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b CompactAddr
unpackM Unpack
  b
  (CompactForm (Value era)
   -> Datum era -> Script era -> BabbageTxOut era)
-> Unpack b (CompactForm (Value era))
-> Unpack b (Datum era -> Script era -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (CompactForm (Value era))
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (CompactForm (Value era))
unpackM Unpack b (Datum era -> Script era -> BabbageTxOut era)
-> Unpack b (Datum era)
-> Unpack b (Script era -> BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (Datum era)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (Datum era)
unpackM Unpack b (Script era -> BabbageTxOut era)
-> Unpack b (Script era) -> Unpack b (BabbageTxOut era)
forall a b. Unpack b (a -> b) -> Unpack b a -> Unpack b b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Unpack b (Script era)
forall a b. (MemPack a, Buffer b) => Unpack b a
forall b. Buffer b => Unpack b (Script era)
unpackM
      Tag
n -> forall a (m :: * -> *) b. (MemPack a, MonadFail m) => Tag -> m b
unknownTagM @(BabbageTxOut era) Tag
n
  {-# INLINE unpackM #-}

instance EraTxOut BabbageEra where
  type TxOut BabbageEra = BabbageTxOut BabbageEra

  mkBasicTxOut :: HasCallStack => Addr -> Value BabbageEra -> TxOut BabbageEra
mkBasicTxOut Addr
addr Value BabbageEra
vl = Addr
-> Value BabbageEra
-> Datum BabbageEra
-> StrictMaybe (Script BabbageEra)
-> BabbageTxOut BabbageEra
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value BabbageEra
vl Datum BabbageEra
forall era. Datum era
NoDatum StrictMaybe (Script BabbageEra)
StrictMaybe (AlonzoScript BabbageEra)
forall a. StrictMaybe a
SNothing

  upgradeTxOut :: EraTxOut (PreviousEra BabbageEra) =>
TxOut (PreviousEra BabbageEra) -> TxOut BabbageEra
upgradeTxOut (AlonzoTxOut Addr
addr Value AlonzoEra
value StrictMaybe DataHash
mDatumHash) = Addr
-> Value BabbageEra
-> Datum BabbageEra
-> StrictMaybe (Script BabbageEra)
-> BabbageTxOut BabbageEra
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value AlonzoEra
Value BabbageEra
value Datum BabbageEra
datum StrictMaybe (Script BabbageEra)
StrictMaybe (AlonzoScript BabbageEra)
forall a. StrictMaybe a
SNothing
    where
      datum :: Datum BabbageEra
datum = case StrictMaybe DataHash
mDatumHash of
        StrictMaybe DataHash
SNothing -> Datum BabbageEra
forall era. Datum era
NoDatum
        SJust DataHash
datumHash -> DataHash -> Datum BabbageEra
forall era. DataHash -> Datum era
DatumHash DataHash
datumHash

  addrEitherTxOutL :: Lens' (TxOut BabbageEra) (Either Addr CompactAddr)
addrEitherTxOutL = (Either Addr CompactAddr -> f (Either Addr CompactAddr))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(Either Addr CompactAddr -> f (Either Addr CompactAddr))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (Either Addr CompactAddr)
Lens' (BabbageTxOut BabbageEra) (Either Addr CompactAddr)
addrEitherBabbageTxOutL
  {-# INLINE addrEitherTxOutL #-}

  valueEitherTxOutL :: Lens'
  (TxOut BabbageEra)
  (Either (Value BabbageEra) (CompactForm (Value BabbageEra)))
valueEitherTxOutL = (Either (Value BabbageEra) (CompactForm (Value BabbageEra))
 -> f (Either (Value BabbageEra) (CompactForm (Value BabbageEra))))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(Either (Value BabbageEra) (CompactForm (Value BabbageEra))
 -> f (Either (Value BabbageEra) (CompactForm (Value BabbageEra))))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era.
EraTxOut era =>
Lens'
  (BabbageTxOut era) (Either (Value era) (CompactForm (Value era)))
Lens'
  (BabbageTxOut BabbageEra)
  (Either (Value BabbageEra) (CompactForm (Value BabbageEra)))
valueEitherBabbageTxOutL
  {-# INLINE valueEitherTxOutL #-}

  getMinCoinSizedTxOut :: PParams BabbageEra -> Sized (TxOut BabbageEra) -> Coin
getMinCoinSizedTxOut = PParams BabbageEra -> Sized (TxOut BabbageEra) -> Coin
PParams BabbageEra -> Sized (BabbageTxOut BabbageEra) -> Coin
forall era a.
BabbageEraPParams era =>
PParams era -> Sized a -> Coin
babbageMinUTxOValue

dataHashBabbageTxOutL ::
  EraTxOut era => Lens' (BabbageTxOut era) (StrictMaybe DataHash)
dataHashBabbageTxOutL :: forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe DataHash)
dataHashBabbageTxOutL =
  (BabbageTxOut era -> StrictMaybe DataHash)
-> (BabbageTxOut era -> StrictMaybe DataHash -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era)
     (BabbageTxOut era)
     (StrictMaybe DataHash)
     (StrictMaybe DataHash)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    BabbageTxOut era -> StrictMaybe DataHash
forall era. BabbageTxOut era -> StrictMaybe DataHash
getDataHashBabbageTxOut
    ( \(BabbageTxOut Addr
addr Value era
cv Datum era
_ StrictMaybe (Script era)
s) -> \case
        StrictMaybe DataHash
SNothing -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
s
        SJust DataHash
dh -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv (DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh) StrictMaybe (Script era)
s
    )
{-# INLINEABLE dataHashBabbageTxOutL #-}

instance AlonzoEraTxOut BabbageEra where
  dataHashTxOutL :: Lens' (TxOut BabbageEra) (StrictMaybe DataHash)
dataHashTxOutL = (StrictMaybe DataHash -> f (StrictMaybe DataHash))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(StrictMaybe DataHash -> f (StrictMaybe DataHash))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe DataHash)
Lens' (BabbageTxOut BabbageEra) (StrictMaybe DataHash)
dataHashBabbageTxOutL
  {-# INLINEABLE dataHashTxOutL #-}

  datumTxOutF :: SimpleGetter (TxOut BabbageEra) (Datum BabbageEra)
datumTxOutF = (BabbageTxOut BabbageEra -> Datum BabbageEra)
-> SimpleGetter (BabbageTxOut BabbageEra) (Datum BabbageEra)
forall s a. (s -> a) -> SimpleGetter s a
to BabbageTxOut BabbageEra -> Datum BabbageEra
forall era. BabbageTxOut era -> Datum era
getDatumBabbageTxOut
  {-# INLINEABLE datumTxOutF #-}

dataBabbageTxOutL :: EraTxOut era => Lens' (BabbageTxOut era) (StrictMaybe (Data era))
dataBabbageTxOutL :: forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe (Data era))
dataBabbageTxOutL =
  (BabbageTxOut era -> StrictMaybe (Data era))
-> (BabbageTxOut era -> StrictMaybe (Data era) -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era)
     (BabbageTxOut era)
     (StrictMaybe (Data era))
     (StrictMaybe (Data era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    BabbageTxOut era -> StrictMaybe (Data era)
forall era. Era era => BabbageTxOut era -> StrictMaybe (Data era)
getDataBabbageTxOut
    ( \(BabbageTxOut Addr
addr Value era
cv Datum era
_ StrictMaybe (Script era)
s) ->
        \case
          StrictMaybe (Data era)
SNothing -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
s
          SJust Data era
d -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv (BinaryData era -> Datum era
forall era. BinaryData era -> Datum era
Datum (Data era -> BinaryData era
forall era. Data era -> BinaryData era
dataToBinaryData Data era
d)) StrictMaybe (Script era)
s
    )
{-# INLINEABLE dataBabbageTxOutL #-}

datumBabbageTxOutL :: EraTxOut era => Lens' (BabbageTxOut era) (Datum era)
datumBabbageTxOutL :: forall era. EraTxOut era => Lens' (BabbageTxOut era) (Datum era)
datumBabbageTxOutL =
  (BabbageTxOut era -> Datum era)
-> (BabbageTxOut era -> Datum era -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era) (BabbageTxOut era) (Datum era) (Datum era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BabbageTxOut era -> Datum era
forall era. BabbageTxOut era -> Datum era
getDatumBabbageTxOut (\(BabbageTxOut Addr
addr Value era
cv Datum era
_ StrictMaybe (Script era)
s) Datum era
d -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv Datum era
d StrictMaybe (Script era)
s)
{-# INLINEABLE datumBabbageTxOutL #-}

referenceScriptBabbageTxOutL :: EraTxOut era => Lens' (BabbageTxOut era) (StrictMaybe (Script era))
referenceScriptBabbageTxOutL :: forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe (Script era))
referenceScriptBabbageTxOutL =
  (BabbageTxOut era -> StrictMaybe (Script era))
-> (BabbageTxOut era
    -> StrictMaybe (Script era) -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era)
     (BabbageTxOut era)
     (StrictMaybe (Script era))
     (StrictMaybe (Script era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BabbageTxOut era -> StrictMaybe (Script era)
forall era. BabbageTxOut era -> StrictMaybe (Script era)
getScriptBabbageTxOut (\(BabbageTxOut Addr
addr Value era
cv Datum era
d StrictMaybe (Script era)
_) StrictMaybe (Script era)
s -> Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut Addr
addr Value era
cv Datum era
d StrictMaybe (Script era)
s)
{-# INLINEABLE referenceScriptBabbageTxOutL #-}

instance BabbageEraTxOut BabbageEra where
  dataTxOutL :: Lens' (TxOut BabbageEra) (StrictMaybe (Data BabbageEra))
dataTxOutL = (StrictMaybe (Data BabbageEra)
 -> f (StrictMaybe (Data BabbageEra)))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(StrictMaybe (Data BabbageEra)
 -> f (StrictMaybe (Data BabbageEra)))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe (Data era))
Lens' (BabbageTxOut BabbageEra) (StrictMaybe (Data BabbageEra))
dataBabbageTxOutL
  {-# INLINEABLE dataTxOutL #-}

  datumTxOutL :: Lens' (TxOut BabbageEra) (Datum BabbageEra)
datumTxOutL = (Datum BabbageEra -> f (Datum BabbageEra))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(Datum BabbageEra -> f (Datum BabbageEra))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era. EraTxOut era => Lens' (BabbageTxOut era) (Datum era)
Lens' (BabbageTxOut BabbageEra) (Datum BabbageEra)
datumBabbageTxOutL
  {-# INLINEABLE datumTxOutL #-}

  referenceScriptTxOutL :: Lens' (TxOut BabbageEra) (StrictMaybe (Script BabbageEra))
referenceScriptTxOutL = (StrictMaybe (Script BabbageEra)
 -> f (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra -> f (TxOut BabbageEra)
(StrictMaybe (Script BabbageEra)
 -> f (StrictMaybe (Script BabbageEra)))
-> BabbageTxOut BabbageEra -> f (BabbageTxOut BabbageEra)
forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (StrictMaybe (Script era))
Lens' (BabbageTxOut BabbageEra) (StrictMaybe (Script BabbageEra))
referenceScriptBabbageTxOutL
  {-# INLINEABLE referenceScriptTxOutL #-}

addrEitherBabbageTxOutL ::
  EraTxOut era =>
  Lens' (BabbageTxOut era) (Either Addr CompactAddr)
addrEitherBabbageTxOutL :: forall era.
EraTxOut era =>
Lens' (BabbageTxOut era) (Either Addr CompactAddr)
addrEitherBabbageTxOutL =
  (BabbageTxOut era -> Either Addr CompactAddr)
-> (BabbageTxOut era
    -> Either Addr CompactAddr -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era)
     (BabbageTxOut era)
     (Either Addr CompactAddr)
     (Either Addr CompactAddr)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    BabbageTxOut era -> Either Addr CompactAddr
forall era. BabbageTxOut era -> Either Addr CompactAddr
getEitherAddrBabbageTxOut
    ( \BabbageTxOut era
txOut Either Addr CompactAddr
eAddr ->
        let cVal :: CompactForm (Value era)
cVal = BabbageTxOut era -> CompactForm (Value era)
forall era.
EraTxOut era =>
BabbageTxOut era -> CompactForm (Value era)
getCompactValueBabbageTxOut BabbageTxOut era
txOut
            (Addr
_, Value era
_, Datum era
datum, StrictMaybe (Script era)
mScript) = BabbageTxOut era
-> (Addr, Value era, Datum era, StrictMaybe (Script era))
forall era.
Val (Value era) =>
BabbageTxOut era
-> (Addr, Value era, Datum era, StrictMaybe (Script era))
viewTxOut BabbageTxOut era
txOut
         in case Either Addr CompactAddr
eAddr of
              Left Addr
addr -> Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
Val (Value era) =>
Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOutCompact Addr
addr (Addr -> CompactAddr
compactAddr Addr
addr) CompactForm (Value era)
cVal Datum era
datum StrictMaybe (Script era)
mScript
              Right CompactAddr
cAddr -> Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
Val (Value era) =>
Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOutCompact (HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
cAddr) CompactAddr
cAddr CompactForm (Value era)
cVal Datum era
datum StrictMaybe (Script era)
mScript
    )
{-# INLINEABLE addrEitherBabbageTxOutL #-}

valueEitherBabbageTxOutL ::
  forall era.
  EraTxOut era =>
  Lens' (BabbageTxOut era) (Either (Value era) (CompactForm (Value era)))
valueEitherBabbageTxOutL :: forall era.
EraTxOut era =>
Lens'
  (BabbageTxOut era) (Either (Value era) (CompactForm (Value era)))
valueEitherBabbageTxOutL =
  (BabbageTxOut era -> Either (Value era) (CompactForm (Value era)))
-> (BabbageTxOut era
    -> Either (Value era) (CompactForm (Value era))
    -> BabbageTxOut era)
-> Lens
     (BabbageTxOut era)
     (BabbageTxOut era)
     (Either (Value era) (CompactForm (Value era)))
     (Either (Value era) (CompactForm (Value era)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (CompactForm (Value era)
-> Either (Value era) (CompactForm (Value era))
forall a b. b -> Either a b
Right (CompactForm (Value era)
 -> Either (Value era) (CompactForm (Value era)))
-> (BabbageTxOut era -> CompactForm (Value era))
-> BabbageTxOut era
-> Either (Value era) (CompactForm (Value era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> CompactForm (Value era)
forall era.
EraTxOut era =>
BabbageTxOut era -> CompactForm (Value era)
getCompactValueBabbageTxOut)
    ( \BabbageTxOut era
txOut Either (Value era) (CompactForm (Value era))
eVal ->
        let (CompactAddr
cAddr, CompactForm (Value era)
_, Datum era
datum, StrictMaybe (Script era)
mScript) = BabbageTxOut era
-> (CompactAddr, CompactForm (Value era), Datum era,
    StrictMaybe (Script era))
forall era.
Val (Value era) =>
BabbageTxOut era
-> (CompactAddr, CompactForm (Value era), Datum era,
    StrictMaybe (Script era))
viewCompactTxOut BabbageTxOut era
txOut
         in case Either (Value era) (CompactForm (Value era))
eVal of
              Left Value era
val -> Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut (HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
cAddr) CompactAddr
cAddr Value era
val Datum era
datum StrictMaybe (Script era)
mScript
              Right CompactForm (Value era)
cVal -> Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
Val (Value era) =>
Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOutCompact (HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
cAddr) CompactAddr
cAddr CompactForm (Value era)
cVal Datum era
datum StrictMaybe (Script era)
mScript
    )
{-# INLINEABLE valueEitherBabbageTxOutL #-}

deriving stock instance
  (Era era, Eq (Script era), Eq (CompactForm (Value era))) =>
  Eq (BabbageTxOut era)

-- | Already in NF
instance NFData (BabbageTxOut era) where
  rnf :: BabbageTxOut era -> ()
rnf = BabbageTxOut era -> ()
forall a. a -> ()
rwhnf

instance
  (Era era, ToJSON (Datum era), ToJSON (Script era), Val (Value era)) =>
  ToJSON (BabbageTxOut era)
  where
  toJSON :: BabbageTxOut era -> Value
toJSON = [Pair] -> Value
object ([Pair] -> Value)
-> (BabbageTxOut era -> [Pair]) -> BabbageTxOut era -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> [Pair]
forall era e a.
(Era era, KeyValue e a, Val (Value era), ToJSON (Script era)) =>
BabbageTxOut era -> [a]
toBabbageTxOutPairs
  toEncoding :: BabbageTxOut era -> Encoding
toEncoding = Series -> Encoding
pairs (Series -> Encoding)
-> (BabbageTxOut era -> Series) -> BabbageTxOut era -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Series] -> Series
forall a. Monoid a => [a] -> a
mconcat ([Series] -> Series)
-> (BabbageTxOut era -> [Series]) -> BabbageTxOut era -> Series
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> [Series]
forall era e a.
(Era era, KeyValue e a, Val (Value era), ToJSON (Script era)) =>
BabbageTxOut era -> [a]
toBabbageTxOutPairs

toBabbageTxOutPairs ::
  ( Era era
  , KeyValue e a
  , Val (Value era)
  , ToJSON (Script era)
  ) =>
  BabbageTxOut era ->
  [a]
toBabbageTxOutPairs :: forall era e a.
(Era era, KeyValue e a, Val (Value era), ToJSON (Script era)) =>
BabbageTxOut era -> [a]
toBabbageTxOutPairs (BabbageTxOut !Addr
addr !Value era
val !Datum era
dat !StrictMaybe (Script era)
mRefScript) =
  [ Key
"address" Key -> Addr -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Addr
addr
  , Key
"value" Key -> Value era -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value era
val
  , Key
"datum" Key -> Datum era -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Datum era
dat
  , Key
"referenceScript" Key -> StrictMaybe (Script era) -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StrictMaybe (Script era)
mRefScript
  ]

viewCompactTxOut ::
  forall era.
  Val (Value era) =>
  BabbageTxOut era ->
  (CompactAddr, CompactForm (Value era), Datum era, StrictMaybe (Script era))
viewCompactTxOut :: forall era.
Val (Value era) =>
BabbageTxOut era
-> (CompactAddr, CompactForm (Value era), Datum era,
    StrictMaybe (Script era))
viewCompactTxOut BabbageTxOut era
txOut = case BabbageTxOut era
txOut of
  TxOutCompact' CompactAddr
addr CompactForm (Value era)
val -> (CompactAddr
addr, CompactForm (Value era)
val, Datum era
forall era. Datum era
NoDatum, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  TxOutCompactDH' CompactAddr
addr CompactForm (Value era)
val DataHash
dh -> (CompactAddr
addr, CompactForm (Value era)
val, DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  TxOutCompactDatum CompactAddr
addr CompactForm (Value era)
val BinaryData era
datum -> (CompactAddr
addr, CompactForm (Value era)
val, BinaryData era -> Datum era
forall era. BinaryData era -> Datum era
Datum BinaryData era
datum, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  TxOutCompactRefScript CompactAddr
addr CompactForm (Value era)
val Datum era
datum Script era
rs -> (CompactAddr
addr, CompactForm (Value era)
val, Datum era
datum, Script era -> StrictMaybe (Script era)
forall a. a -> StrictMaybe a
SJust Script era
rs)
  TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal ->
    let (CompactAddr
a, CompactForm (Value era)
b, StrictMaybe DataHash
c) =
          forall era.
Val (Value era) =>
AlonzoTxOut era
-> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash)
Alonzo.viewCompactTxOut @era (AlonzoTxOut era
 -> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash))
-> AlonzoTxOut era
-> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash)
forall a b. (a -> b) -> a -> b
$ Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> AlonzoTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> AlonzoTxOut era
Alonzo.TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal
     in (CompactAddr
a, CompactForm (Value era)
b, StrictMaybe DataHash -> Datum era
forall {era}. StrictMaybe DataHash -> Datum era
toDatum StrictMaybe DataHash
c, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal DataHash32
dataHash32 ->
    let (CompactAddr
a, CompactForm (Value era)
b, StrictMaybe DataHash
c) =
          forall era.
Val (Value era) =>
AlonzoTxOut era
-> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash)
Alonzo.viewCompactTxOut @era (AlonzoTxOut era
 -> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash))
-> AlonzoTxOut era
-> (CompactAddr, CompactForm (Value era), StrictMaybe DataHash)
forall a b. (a -> b) -> a -> b
$
            Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> DataHash32 -> AlonzoTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> DataHash32 -> AlonzoTxOut era
Alonzo.TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal DataHash32
dataHash32
     in (CompactAddr
a, CompactForm (Value era)
b, StrictMaybe DataHash -> Datum era
forall {era}. StrictMaybe DataHash -> Datum era
toDatum StrictMaybe DataHash
c, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    toDatum :: StrictMaybe DataHash -> Datum era
toDatum = \case
      StrictMaybe DataHash
SNothing -> Datum era
forall era. Datum era
NoDatum
      SJust DataHash
dh -> DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh
{-# INLINEABLE viewCompactTxOut #-}

viewTxOut ::
  forall era.
  Val (Value era) =>
  BabbageTxOut era ->
  (Addr, Value era, Datum era, StrictMaybe (Script era))
viewTxOut :: forall era.
Val (Value era) =>
BabbageTxOut era
-> (Addr, Value era, Datum era, StrictMaybe (Script era))
viewTxOut (TxOutCompact' CompactAddr
bs CompactForm (Value era)
c) = (Addr
addr, Value era
val, Datum era
forall era. Datum era
NoDatum, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    addr :: Addr
addr = HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
bs
    val :: Value era
val = CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
c
viewTxOut (TxOutCompactDH' CompactAddr
bs CompactForm (Value era)
c DataHash
dh) = (Addr
addr, Value era
val, DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    addr :: Addr
addr = HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
bs
    val :: Value era
val = CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
c
viewTxOut (TxOutCompactDatum CompactAddr
bs CompactForm (Value era)
c BinaryData era
d) = (Addr
addr, Value era
val, BinaryData era -> Datum era
forall era. BinaryData era -> Datum era
Datum BinaryData era
d, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    addr :: Addr
addr = HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
bs
    val :: Value era
val = CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
c
viewTxOut (TxOutCompactRefScript CompactAddr
bs CompactForm (Value era)
c Datum era
d Script era
rs) = (Addr
addr, Value era
val, Datum era
d, Script era -> StrictMaybe (Script era)
forall a. a -> StrictMaybe a
SJust Script era
rs)
  where
    addr :: Addr
addr = HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
bs
    val :: Value era
val = CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
c
viewTxOut (TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal) = (Addr
addr, Value era
val, Datum era
forall era. Datum era
NoDatum, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    (Addr
addr, Value era
val, StrictMaybe DataHash
_) =
      forall era.
Val (Value era) =>
AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash)
Alonzo.viewTxOut @era (AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash))
-> AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash)
forall a b. (a -> b) -> a -> b
$ Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> AlonzoTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> AlonzoTxOut era
Alonzo.TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal
viewTxOut (TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal DataHash32
dataHash32) =
  case StrictMaybe DataHash
mDataHash of
    StrictMaybe DataHash
SNothing -> (Addr
addr, Value era
val, Datum era
forall era. Datum era
NoDatum, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
    SJust DataHash
dh -> (Addr
addr, Value era
val, DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh, StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing)
  where
    (Addr
addr, Value era
val, StrictMaybe DataHash
mDataHash) =
      forall era.
Val (Value era) =>
AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash)
Alonzo.viewTxOut @era (AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash))
-> AlonzoTxOut era -> (Addr, Value era, StrictMaybe DataHash)
forall a b. (a -> b) -> a -> b
$
        Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> DataHash32 -> AlonzoTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> DataHash32 -> AlonzoTxOut era
Alonzo.TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
adaVal DataHash32
dataHash32
{-# INLINEABLE viewTxOut #-}

instance
  (Era era, Show (Script era), Val (Value era)) =>
  Show (BabbageTxOut era)
  where
  show :: BabbageTxOut era -> String
show = (Addr, Value era, Datum era, StrictMaybe (Script era)) -> String
forall a. Show a => a -> String
show ((Addr, Value era, Datum era, StrictMaybe (Script era)) -> String)
-> (BabbageTxOut era
    -> (Addr, Value era, Datum era, StrictMaybe (Script era)))
-> BabbageTxOut era
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era
-> (Addr, Value era, Datum era, StrictMaybe (Script era))
forall era.
Val (Value era) =>
BabbageTxOut era
-> (Addr, Value era, Datum era, StrictMaybe (Script era))
viewTxOut

instance (Era era, NoThunks (Script era), Val (Value era)) => NoThunks (BabbageTxOut era)

pattern BabbageTxOut ::
  (Era era, Val (Value era), HasCallStack) =>
  Addr ->
  Value era ->
  Datum era ->
  StrictMaybe (Script era) ->
  BabbageTxOut era
pattern $mBabbageTxOut :: forall {r} {era}.
(Era era, Val (Value era), HasCallStack) =>
BabbageTxOut era
-> (Addr
    -> Value era -> Datum era -> StrictMaybe (Script era) -> r)
-> ((# #) -> r)
-> r
$bBabbageTxOut :: forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut addr vl datum refScript <-
  (viewTxOut -> (addr, vl, datum, refScript))
  where
    BabbageTxOut Addr
addr Value era
vl Datum era
datum StrictMaybe (Script era)
refScript = Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
addr (Addr -> CompactAddr
compactAddr Addr
addr) Value era
vl Datum era
datum StrictMaybe (Script era)
refScript

{-# COMPLETE BabbageTxOut #-}

-- | Helper function for constructing a BabbageTxOut. Both compacted and uncompacted
-- address should be the exact same address in different forms.
mkTxOut ::
  forall era.
  (Val (Value era), HasCallStack) =>
  Addr ->
  CompactAddr ->
  Value era ->
  Datum era ->
  StrictMaybe (Script era) ->
  BabbageTxOut era
mkTxOut :: forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
addr CompactAddr
_cAddr Value era
vl Datum era
NoDatum StrictMaybe (Script era)
SNothing
  | Just CompactForm Coin
adaCompact <- Proxy era -> Value era -> Maybe (CompactForm Coin)
forall era.
Val (Value era) =>
Proxy era -> Value era -> Maybe (CompactForm Coin)
getAdaOnly (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @era) Value era
vl
  , Addr Network
network PaymentCredential
paymentCred StakeReference
stakeRef <- Addr
addr
  , StakeRefBase Credential 'Staking
stakeCred <- StakeReference
stakeRef =
      let
        addr28Extra :: Addr28Extra
addr28Extra = Network -> PaymentCredential -> Addr28Extra
encodeAddress28 Network
network PaymentCredential
paymentCred
       in
        Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeCred Addr28Extra
addr28Extra CompactForm Coin
adaCompact
mkTxOut Addr
addr CompactAddr
_cAddr Value era
vl (DatumHash DataHash
dh) StrictMaybe (Script era)
SNothing
  | Just CompactForm Coin
adaCompact <- Proxy era -> Value era -> Maybe (CompactForm Coin)
forall era.
Val (Value era) =>
Proxy era -> Value era -> Maybe (CompactForm Coin)
getAdaOnly (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @era) Value era
vl
  , Addr Network
network PaymentCredential
paymentCred StakeReference
stakeRef <- Addr
addr
  , StakeRefBase Credential 'Staking
stakeCred <- StakeReference
stakeRef =
      let
        addr28Extra :: Addr28Extra
addr28Extra = Network -> PaymentCredential -> Addr28Extra
encodeAddress28 Network
network PaymentCredential
paymentCred
        dataHash32 :: DataHash32
dataHash32 = DataHash -> DataHash32
encodeDataHash32 DataHash
dh
       in
        Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeCred Addr28Extra
addr28Extra CompactForm Coin
adaCompact DataHash32
dataHash32
mkTxOut Addr
_addr CompactAddr
cAddr Value era
vl Datum era
d StrictMaybe (Script era)
rs =
  let cVal :: CompactForm (Value era)
cVal = CompactForm (Value era)
-> Maybe (CompactForm (Value era)) -> CompactForm (Value era)
forall a. a -> Maybe a -> a
fromMaybe (String -> CompactForm (Value era)
forall a. HasCallStack => String -> a
error (String
"Illegal Value in TxOut: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Value era -> String
forall a. Show a => a -> String
show Value era
vl)) (Maybe (CompactForm (Value era)) -> CompactForm (Value era))
-> Maybe (CompactForm (Value era)) -> CompactForm (Value era)
forall a b. (a -> b) -> a -> b
$ Value era -> Maybe (CompactForm (Value era))
forall a. Compactible a => a -> Maybe (CompactForm a)
toCompact Value era
vl
   in case StrictMaybe (Script era)
rs of
        StrictMaybe (Script era)
SNothing -> case Datum era
d of
          Datum era
NoDatum -> CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
forall era.
CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
TxOutCompact' CompactAddr
cAddr CompactForm (Value era)
cVal
          DatumHash DataHash
dh -> CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
TxOutCompactDH' CompactAddr
cAddr CompactForm (Value era)
cVal DataHash
dh
          Datum BinaryData era
binaryData -> CompactAddr
-> CompactForm (Value era) -> BinaryData era -> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era) -> BinaryData era -> BabbageTxOut era
TxOutCompactDatum CompactAddr
cAddr CompactForm (Value era)
cVal BinaryData era
binaryData
        SJust Script era
rs' -> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> Script era
-> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era)
-> Datum era
-> Script era
-> BabbageTxOut era
TxOutCompactRefScript CompactAddr
cAddr CompactForm (Value era)
cVal Datum era
d Script era
rs'
{-# INLINEABLE mkTxOut #-}

-- TODO: Implement mkTxOut in terms of mkTxOutCompact, it will avoid unnecessary
-- MultiAsset serilization/deserialization
mkTxOutCompact ::
  Val (Value era) =>
  Addr ->
  CompactAddr ->
  CompactForm (Value era) ->
  Datum era ->
  StrictMaybe (Script era) ->
  BabbageTxOut era
mkTxOutCompact :: forall era.
Val (Value era) =>
Addr
-> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOutCompact Addr
addr CompactAddr
cAddr CompactForm (Value era)
cVal = Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
addr CompactAddr
cAddr (CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
cVal)
{-# INLINE mkTxOutCompact #-}

pattern TxOutCompact ::
  (Era era, Val (Value era), Compactible (Value era), HasCallStack) =>
  CompactAddr ->
  CompactForm (Value era) ->
  BabbageTxOut era
pattern $mTxOutCompact :: forall {r} {era}.
(Era era, Val (Value era), Compactible (Value era),
 HasCallStack) =>
BabbageTxOut era
-> (CompactAddr -> CompactForm (Value era) -> r)
-> ((# #) -> r)
-> r
$bTxOutCompact :: forall era.
(Era era, Val (Value era), Compactible (Value era),
 HasCallStack) =>
CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
TxOutCompact addr vl <-
  (viewCompactTxOut -> (addr, vl, NoDatum, SNothing))
  where
    TxOutCompact CompactAddr
cAddr CompactForm (Value era)
cVal
      | CompactForm (Value era) -> Bool
forall t. Val t => CompactForm t -> Bool
isAdaOnlyCompact CompactForm (Value era)
cVal =
          Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut (HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
cAddr) CompactAddr
cAddr (CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
cVal) Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
      | Bool
otherwise = CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
forall era.
CompactAddr -> CompactForm (Value era) -> BabbageTxOut era
TxOutCompact' CompactAddr
cAddr CompactForm (Value era)
cVal

pattern TxOutCompactDH ::
  (Era era, Val (Value era), Compactible (Value era), HasCallStack) =>
  CompactAddr ->
  CompactForm (Value era) ->
  DataHash ->
  BabbageTxOut era
pattern $mTxOutCompactDH :: forall {r} {era}.
(Era era, Val (Value era), Compactible (Value era),
 HasCallStack) =>
BabbageTxOut era
-> (CompactAddr -> CompactForm (Value era) -> DataHash -> r)
-> ((# #) -> r)
-> r
$bTxOutCompactDH :: forall era.
(Era era, Val (Value era), Compactible (Value era),
 HasCallStack) =>
CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
TxOutCompactDH addr vl dh <-
  (viewCompactTxOut -> (addr, vl, DatumHash dh, SNothing))
  where
    TxOutCompactDH CompactAddr
cAddr CompactForm (Value era)
cVal DataHash
dh
      | CompactForm (Value era) -> Bool
forall t. Val t => CompactForm t -> Bool
isAdaOnlyCompact CompactForm (Value era)
cVal =
          Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut (HasCallStack => CompactAddr -> Addr
CompactAddr -> Addr
decompactAddr CompactAddr
cAddr) CompactAddr
cAddr (CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
cVal) (DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh) StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
      | Bool
otherwise = CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
forall era.
CompactAddr
-> CompactForm (Value era) -> DataHash -> BabbageTxOut era
TxOutCompactDH' CompactAddr
cAddr CompactForm (Value era)
cVal DataHash
dh

{-# COMPLETE TxOutCompact, TxOutCompactDH #-}

instance (EraScript era, Val (Value era)) => ToCBOR (BabbageTxOut era) where
  toCBOR :: BabbageTxOut era -> Encoding
toCBOR = forall era t. (Era era, EncCBOR t) => t -> Encoding
toEraCBOR @era
  {-# INLINE toCBOR #-}

instance (EraScript era, Val (Value era)) => FromCBOR (BabbageTxOut era) where
  fromCBOR :: forall s. Decoder s (BabbageTxOut era)
fromCBOR = forall era t s. (Era era, DecCBOR t) => Decoder s t
fromEraCBOR @era
  {-# INLINE fromCBOR #-}

instance (EraScript era, Val (Value era)) => EncCBOR (BabbageTxOut era) where
  encCBOR :: BabbageTxOut era -> Encoding
encCBOR = \case
    TxOutCompactRefScript CompactAddr
addr CompactForm (Value era)
cv Datum era
d Script era
rs -> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> Encoding
forall era.
(EraScript era, Val (Value era)) =>
CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> Encoding
encodeTxOut CompactAddr
addr CompactForm (Value era)
cv Datum era
d (Script era -> StrictMaybe (Script era)
forall a. a -> StrictMaybe a
SJust Script era
rs)
    TxOutCompactDatum CompactAddr
addr CompactForm (Value era)
cv BinaryData era
d -> CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> Encoding
forall era.
(EraScript era, Val (Value era)) =>
CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> Encoding
encodeTxOut CompactAddr
addr CompactForm (Value era)
cv (BinaryData era -> Datum era
forall era. BinaryData era -> Datum era
Datum BinaryData era
d) StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
    TxOutCompactDH CompactAddr
addr CompactForm (Value era)
cv DataHash
dh -> Word -> Encoding
encodeListLen Word
3 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CompactAddr -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR CompactAddr
addr Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CompactForm (Value era) -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR CompactForm (Value era)
cv Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> DataHash -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR DataHash
dh
    TxOutCompact CompactAddr
addr CompactForm (Value era)
cv -> Word -> Encoding
encodeListLen Word
2 Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CompactAddr -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR CompactAddr
addr Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> CompactForm (Value era) -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR CompactForm (Value era)
cv

instance (EraScript era, Val (Value era)) => DecCBOR (BabbageTxOut era) where
  decCBOR :: forall s. Decoder s (BabbageTxOut era)
decCBOR = (forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
forall era s.
(EraScript era, Val (Value era)) =>
(forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
decodeBabbageTxOut Decoder s' (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
fromCborBothAddr
  {-# INLINE decCBOR #-}

instance
  ( EraScript era
  , Val (Value era)
  , MemPack (Script era)
  , MemPack (CompactForm (Value era))
  ) =>
  DecShareCBOR (BabbageTxOut era)
  where
  type Share (BabbageTxOut era) = Interns (Credential 'Staking)
  decShareCBOR :: forall s. Share (BabbageTxOut era) -> Decoder s (BabbageTxOut era)
decShareCBOR Share (BabbageTxOut era)
credsInterns = do
    BabbageTxOut era
txOut <-
      Decoder s TokenType
forall s. Decoder s TokenType
peekTokenType Decoder s TokenType
-> (TokenType -> Decoder s (BabbageTxOut era))
-> Decoder s (BabbageTxOut 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
TypeBytes -> Decoder s (BabbageTxOut era)
forall a s. MemPack a => Decoder s a
decodeMemPack
        TokenType
TypeBytesIndef -> Decoder s (BabbageTxOut era)
forall a s. MemPack a => Decoder s a
decodeMemPack
        TokenType
_ -> Decoder s (BabbageTxOut era)
forall s. Decoder s (BabbageTxOut era)
forall a s. DecCBOR a => Decoder s a
decCBOR
    BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$! (Credential 'Staking -> Credential 'Staking)
-> BabbageTxOut era -> BabbageTxOut era
forall era.
(Credential 'Staking -> Credential 'Staking)
-> BabbageTxOut era -> BabbageTxOut era
internBabbageTxOut (Interns (Credential 'Staking)
-> Credential 'Staking -> Credential 'Staking
forall k. Interns k -> k -> k
interns Share (BabbageTxOut era)
Interns (Credential 'Staking)
credsInterns) BabbageTxOut era
txOut
  {-# INLINEABLE decShareCBOR #-}

internBabbageTxOut ::
  (Credential 'Staking -> Credential 'Staking) ->
  BabbageTxOut era ->
  BabbageTxOut era
internBabbageTxOut :: forall era.
(Credential 'Staking -> Credential 'Staking)
-> BabbageTxOut era -> BabbageTxOut era
internBabbageTxOut Credential 'Staking -> Credential 'Staking
internCred = \case
  TxOut_AddrHash28_AdaOnly Credential 'Staking
cred Addr28Extra
addr28Extra CompactForm Coin
ada ->
    Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra -> CompactForm Coin -> BabbageTxOut era
TxOut_AddrHash28_AdaOnly (Credential 'Staking -> Credential 'Staking
internCred Credential 'Staking
cred) Addr28Extra
addr28Extra CompactForm Coin
ada
  TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
cred Addr28Extra
addr28Extra CompactForm Coin
ada DataHash32
dataHash32 ->
    Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
forall era.
Credential 'Staking
-> Addr28Extra
-> CompactForm Coin
-> DataHash32
-> BabbageTxOut era
TxOut_AddrHash28_AdaOnly_DataHash32 (Credential 'Staking -> Credential 'Staking
internCred Credential 'Staking
cred) Addr28Extra
addr28Extra CompactForm Coin
ada DataHash32
dataHash32
  BabbageTxOut era
txOut -> BabbageTxOut era
txOut
{-# INLINE internBabbageTxOut #-}

decodeBabbageTxOut ::
  (EraScript era, Val (Value era)) =>
  -- | We need to use a backwards compatible decoder for any address in a pre-babbage
  -- TxOut format. This is needed in order to get rid of bogus pointers from the ledger
  -- state in Conway
  (forall s'. Decoder s' (Addr, CompactAddr)) ->
  Decoder s (BabbageTxOut era)
decodeBabbageTxOut :: forall era s.
(EraScript era, Val (Value era)) =>
(forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
decodeBabbageTxOut forall s'. Decoder s' (Addr, CompactAddr)
decAddr = do
  Decoder s TokenType
forall s. Decoder s TokenType
peekTokenType Decoder s TokenType
-> (TokenType -> Decoder s (BabbageTxOut era))
-> Decoder s (BabbageTxOut 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 -> (forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
forall s era.
(EraScript era, Val (Value era)) =>
(forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
decodeTxOut Decoder s' (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr
    TokenType
TypeMapLen -> (forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
forall s era.
(EraScript era, Val (Value era)) =>
(forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
decodeTxOut Decoder s' (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr
    TokenType
_ -> Decoder s (BabbageTxOut era)
oldTxOut
  where
    oldTxOut :: Decoder s (BabbageTxOut era)
oldTxOut = do
      Maybe Int
lenOrIndef <- Decoder s (Maybe Int)
forall s. Decoder s (Maybe Int)
decodeListLenOrIndef
      case Maybe Int
lenOrIndef of
        Maybe Int
Nothing -> do
          (Addr
a, CompactAddr
ca) <- Decoder s (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr
          Value era
v <- Decoder s (Value era)
forall s. Decoder s (Value era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          Decoder s Bool
forall s. Decoder s Bool
decodeBreakOr Decoder s Bool
-> (Bool -> Decoder s (BabbageTxOut era))
-> Decoder s (BabbageTxOut 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
            Bool
True -> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
a CompactAddr
ca Value era
v Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
            Bool
False -> do
              DataHash
dh <- Decoder s DataHash
forall s. Decoder s DataHash
forall a s. DecCBOR a => Decoder s a
decCBOR
              Decoder s Bool
forall s. Decoder s Bool
decodeBreakOr Decoder s Bool
-> (Bool -> Decoder s (BabbageTxOut era))
-> Decoder s (BabbageTxOut 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
                Bool
True -> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
a CompactAddr
ca Value era
v (DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh) StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
                Bool
False -> DecoderError -> Decoder s (BabbageTxOut era)
forall (m :: * -> *) e a. (MonadFail m, Buildable e) => e -> m a
cborError (DecoderError -> Decoder s (BabbageTxOut era))
-> DecoderError -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> DecoderError
DecoderErrorCustom Text
"TxOut" Text
"Excess terms in TxOut"
        Just Int
2 -> do
          (Addr
a, CompactAddr
ca) <- Decoder s (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr
          Value era
v <- Decoder s (Value era)
forall s. Decoder s (Value era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
a CompactAddr
ca Value era
v Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
        Just Int
3 -> do
          (Addr
a, CompactAddr
ca) <- Decoder s (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr
          Value era
v <- Decoder s (Value era)
forall s. Decoder s (Value era)
forall a s. DecCBOR a => Decoder s a
decCBOR
          DataHash
dh <- Decoder s DataHash
forall s. Decoder s DataHash
forall a s. DecCBOR a => Decoder s a
decCBOR
          BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
a CompactAddr
ca Value era
v (DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh) StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
        Just Int
_ -> DecoderError -> Decoder s (BabbageTxOut era)
forall (m :: * -> *) e a. (MonadFail m, Buildable e) => e -> m a
cborError (DecoderError -> Decoder s (BabbageTxOut era))
-> DecoderError -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> DecoderError
DecoderErrorCustom Text
"TxOut" Text
"Wrong number of terms in TxOut"
    {-# INLINE oldTxOut #-}
{-# INLINEABLE decodeBabbageTxOut #-}

encodeTxOut ::
  forall era.
  (EraScript era, Val (Value era)) =>
  CompactAddr ->
  CompactForm (Value era) ->
  Datum era ->
  StrictMaybe (Script era) ->
  Encoding
encodeTxOut :: forall era.
(EraScript era, Val (Value era)) =>
CompactAddr
-> CompactForm (Value era)
-> Datum era
-> StrictMaybe (Script era)
-> Encoding
encodeTxOut CompactAddr
cAddr CompactForm (Value era)
cVal Datum era
datum StrictMaybe (Script era)
script =
  Encode
  ('Closed 'Sparse)
  (Any
   -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
       Any))
-> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode
   ('Closed 'Sparse)
   (Any
    -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
        Any))
 -> Encoding)
-> Encode
     ('Closed 'Sparse)
     (Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
-> Encoding
forall a b. (a -> b) -> a -> b
$
    (CompactAddr
 -> Value era
 -> Datum era
 -> StrictMaybe (Script era)
 -> Any
 -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
     Any))
-> Encode
     ('Closed 'Sparse)
     (CompactAddr
      -> Value era
      -> Datum era
      -> StrictMaybe (Script era)
      -> Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
forall t. t -> Encode ('Closed 'Sparse) t
Keyed (,,,,)
      Encode
  ('Closed 'Sparse)
  (CompactAddr
   -> Value era
   -> Datum era
   -> StrictMaybe (Script era)
   -> Any
   -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
       Any))
-> Encode ('Closed 'Sparse) CompactAddr
-> Encode
     ('Closed 'Sparse)
     (Value era
      -> Datum era
      -> StrictMaybe (Script era)
      -> Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> Word
-> Encode ('Closed 'Dense) CompactAddr
-> Encode ('Closed 'Sparse) CompactAddr
forall t.
Word -> Encode ('Closed 'Dense) t -> Encode ('Closed 'Sparse) t
Key Word
0 (CompactAddr -> Encode ('Closed 'Dense) CompactAddr
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To CompactAddr
cAddr)
      Encode
  ('Closed 'Sparse)
  (Value era
   -> Datum era
   -> StrictMaybe (Script era)
   -> Any
   -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
       Any))
-> Encode ('Closed 'Sparse) (Value era)
-> Encode
     ('Closed 'Sparse)
     (Datum era
      -> StrictMaybe (Script era)
      -> Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> Word
-> Encode ('Closed 'Dense) (Value era)
-> Encode ('Closed 'Sparse) (Value era)
forall t.
Word -> Encode ('Closed 'Dense) t -> Encode ('Closed 'Sparse) t
Key Word
1 (Value era -> Encode ('Closed 'Dense) (Value era)
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To (CompactForm (Value era) -> Value era
forall a. Compactible a => CompactForm a -> a
fromCompact CompactForm (Value era)
cVal))
      Encode
  ('Closed 'Sparse)
  (Datum era
   -> StrictMaybe (Script era)
   -> Any
   -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
       Any))
-> Encode ('Closed 'Sparse) (Datum era)
-> Encode
     ('Closed 'Sparse)
     (StrictMaybe (Script era)
      -> Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> (Datum era -> Bool)
-> Encode ('Closed 'Sparse) (Datum era)
-> Encode ('Closed 'Sparse) (Datum era)
forall t.
(t -> Bool)
-> Encode ('Closed 'Sparse) t -> Encode ('Closed 'Sparse) t
Omit (Datum era -> Datum era -> Bool
forall a. Eq a => a -> a -> Bool
== Datum era
forall era. Datum era
NoDatum) (Word
-> Encode ('Closed 'Dense) (Datum era)
-> Encode ('Closed 'Sparse) (Datum era)
forall t.
Word -> Encode ('Closed 'Dense) t -> Encode ('Closed 'Sparse) t
Key Word
2 (Datum era -> Encode ('Closed 'Dense) (Datum era)
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To Datum era
datum))
      Encode
  ('Closed 'Sparse)
  (StrictMaybe (Script era)
   -> Any
   -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
       Any))
-> Encode ('Closed 'Sparse) (StrictMaybe (Script era))
-> Encode
     ('Closed 'Sparse)
     (Any
      -> (CompactAddr, Value era, Datum era, StrictMaybe (Script era),
          Any))
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> Word
-> (Script era -> Encoding)
-> StrictMaybe (Script era)
-> Encode ('Closed 'Sparse) (StrictMaybe (Script era))
forall a.
Word
-> (a -> Encoding)
-> StrictMaybe a
-> Encode ('Closed 'Sparse) (StrictMaybe a)
encodeKeyedStrictMaybeWith Word
3 Script era -> Encoding
forall a. EncCBOR a => a -> Encoding
encodeNestedCbor StrictMaybe (Script era)
script
{-# INLINE encodeTxOut #-}

data DecodingTxOut era = DecodingTxOut
  { forall era. DecodingTxOut era -> StrictMaybe (Addr, CompactAddr)
decodingTxOutAddr :: !(StrictMaybe (Addr, CompactAddr))
  , forall era. DecodingTxOut era -> Value era
decodingTxOutVal :: !(Value era)
  , forall era. DecodingTxOut era -> Datum era
decodingTxOutDatum :: !(Datum era)
  , forall era. DecodingTxOut era -> StrictMaybe (Script era)
decodingTxOutScript :: !(StrictMaybe (Script era))
  }

decodeTxOut ::
  forall s era.
  (EraScript era, Val (Value era)) =>
  (forall s'. Decoder s' (Addr, CompactAddr)) ->
  Decoder s (BabbageTxOut era)
decodeTxOut :: forall s era.
(EraScript era, Val (Value era)) =>
(forall s'. Decoder s' (Addr, CompactAddr))
-> Decoder s (BabbageTxOut era)
decodeTxOut forall s'. Decoder s' (Addr, CompactAddr)
decAddr = do
  DecodingTxOut era
dtxo <- Decode ('Closed 'Dense) (DecodingTxOut era)
-> Decoder s (DecodingTxOut era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (DecodingTxOut era)
 -> Decoder s (DecodingTxOut era))
-> Decode ('Closed 'Dense) (DecodingTxOut era)
-> Decoder s (DecodingTxOut era)
forall a b. (a -> b) -> a -> b
$ String
-> DecodingTxOut era
-> (Word -> Field (DecodingTxOut era))
-> [(Word, String)]
-> Decode ('Closed 'Dense) (DecodingTxOut era)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode ('Closed 'Dense) t
SparseKeyed String
"TxOut" DecodingTxOut era
initial Word -> Field (DecodingTxOut era)
bodyFields [(Word, String)]
requiredFields
  case DecodingTxOut era
dtxo of
    DecodingTxOut StrictMaybe (Addr, CompactAddr)
SNothing Value era
_ Datum era
_ StrictMaybe (Script era)
_ ->
      DecoderError -> Decoder s (BabbageTxOut era)
forall (m :: * -> *) e a. (MonadFail m, Buildable e) => e -> m a
cborError (DecoderError -> Decoder s (BabbageTxOut era))
-> DecoderError -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> DecoderError
DecoderErrorCustom Text
"BabbageTxOut" Text
"Impossible: no Addr"
    DecodingTxOut (SJust (Addr
addr, CompactAddr
cAddr)) Value era
val Datum era
d StrictMaybe (Script era)
script ->
      BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BabbageTxOut era -> Decoder s (BabbageTxOut era))
-> BabbageTxOut era -> Decoder s (BabbageTxOut era)
forall a b. (a -> b) -> a -> b
$ Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
forall era.
(Val (Value era), HasCallStack) =>
Addr
-> CompactAddr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
mkTxOut Addr
addr CompactAddr
cAddr Value era
val Datum era
d StrictMaybe (Script era)
script
  where
    initial :: DecodingTxOut era
    initial :: DecodingTxOut era
initial = StrictMaybe (Addr, CompactAddr)
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> DecodingTxOut era
forall era.
StrictMaybe (Addr, CompactAddr)
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> DecodingTxOut era
DecodingTxOut StrictMaybe (Addr, CompactAddr)
forall a. StrictMaybe a
SNothing Value era
forall a. Monoid a => a
mempty Datum era
forall era. Datum era
NoDatum StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
    bodyFields :: (Word -> Field (DecodingTxOut era))
    bodyFields :: Word -> Field (DecodingTxOut era)
bodyFields Word
0 =
      ((Addr, CompactAddr) -> DecodingTxOut era -> DecodingTxOut era)
-> Decode ('Closed 'Dense) (Addr, CompactAddr)
-> Field (DecodingTxOut era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field
        (\(Addr, CompactAddr)
x DecodingTxOut era
txo -> DecodingTxOut era
txo {decodingTxOutAddr = SJust x})
        ((forall s'. Decoder s' (Addr, CompactAddr))
-> Decode ('Closed 'Dense) (Addr, CompactAddr)
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D Decoder s (Addr, CompactAddr)
forall s'. Decoder s' (Addr, CompactAddr)
decAddr)
    bodyFields Word
1 =
      (Value era -> DecodingTxOut era -> DecodingTxOut era)
-> Decode ('Closed Any) (Value era) -> Field (DecodingTxOut era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field
        (\Value era
x DecodingTxOut era
txo -> DecodingTxOut era
txo {decodingTxOutVal = x})
        Decode ('Closed Any) (Value era)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
    bodyFields Word
2 =
      (Datum era -> DecodingTxOut era -> DecodingTxOut era)
-> Decode ('Closed 'Dense) (Datum era) -> Field (DecodingTxOut era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode ('Closed d) x -> Field t
field
        (\Datum era
x DecodingTxOut era
txo -> DecodingTxOut era
txo {decodingTxOutDatum = x})
        ((forall s. Decoder s (Datum era))
-> Decode ('Closed 'Dense) (Datum era)
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D Decoder s (Datum era)
forall s. Decoder s (Datum era)
forall a s. DecCBOR a => Decoder s a
decCBOR)
    bodyFields Word
3 =
      (StrictMaybe (Script era)
 -> DecodingTxOut era -> DecodingTxOut era)
-> Decode ('Closed 'Dense) (Script era)
-> Field (DecodingTxOut era)
forall x t (d :: Density).
Typeable x =>
(StrictMaybe x -> t -> t) -> Decode ('Closed d) x -> Field t
ofield
        (\StrictMaybe (Script era)
x DecodingTxOut era
txo -> DecodingTxOut era
txo {decodingTxOutScript = x})
        ((forall s. Decoder s (Script era))
-> Decode ('Closed 'Dense) (Script era)
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D ((forall s. Decoder s (Script era))
 -> Decode ('Closed 'Dense) (Script era))
-> (forall s. Decoder s (Script era))
-> Decode ('Closed 'Dense) (Script era)
forall a b. (a -> b) -> a -> b
$ Text -> Decoder s (Script era)
forall b s. DecCBOR b => Text -> Decoder s b
decodeCIC Text
"Script")
    bodyFields Word
n = Word -> Field (DecodingTxOut era)
forall t. Word -> Field t
invalidField Word
n
    {-# INLINE bodyFields #-}
    requiredFields :: [(Word, String)]
requiredFields =
      [ (Word
0, String
"addr")
      , (Word
1, String
"val")
      ]
{-# INLINE decodeTxOut #-}

babbageMinUTxOValue ::
  BabbageEraPParams era =>
  PParams era ->
  Sized a ->
  Coin
babbageMinUTxOValue :: forall era a.
BabbageEraPParams era =>
PParams era -> Sized a -> Coin
babbageMinUTxOValue PParams era
pp Sized a
sizedTxOut =
  Integer -> Coin
Coin (Integer -> Coin) -> Integer -> Coin
forall a b. (a -> b) -> a -> b
$ Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
constantOverhead Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Sized a -> Int64
forall a. Sized a -> Int64
sizedSize Sized a
sizedTxOut) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
cpb
  where
    CoinPerByte (Coin Integer
cpb) = PParams era
pp PParams era
-> Getting CoinPerByte (PParams era) CoinPerByte -> CoinPerByte
forall s a. s -> Getting a s a -> a
^. Getting CoinPerByte (PParams era) CoinPerByte
forall era.
BabbageEraPParams era =>
Lens' (PParams era) CoinPerByte
Lens' (PParams era) CoinPerByte
ppCoinsPerUTxOByteL
    -- This constant is an approximation of the memory overhead that comes
    -- from TxIn and an entry in the Map data structure:
    --
    -- 160 = 20 words * 8bytes
    --
    -- This means that if:
    --
    --  * 'coinsPerUTxOByte' = 4310
    --  * A simple TxOut with staking and payment credentials with ADA only
    --    amount of 978370 lovelace
    --
    -- we get the size of TxOut to be 67 bytes and the minimum value will come
    -- out to be 978597 lovelace. Also the absolute minimum value will be
    -- 857690, because TxOut without staking address can't be less than 39 bytes
    constantOverhead :: Int64
constantOverhead = Int64
160
{-# INLINE babbageMinUTxOValue #-}

getEitherAddrBabbageTxOut ::
  BabbageTxOut era ->
  Either Addr CompactAddr
getEitherAddrBabbageTxOut :: forall era. BabbageTxOut era -> Either Addr CompactAddr
getEitherAddrBabbageTxOut = \case
  TxOutCompact' CompactAddr
cAddr CompactForm (Value era)
_ -> CompactAddr -> Either Addr CompactAddr
forall a b. b -> Either a b
Right CompactAddr
cAddr
  TxOutCompactDH' CompactAddr
cAddr CompactForm (Value era)
_ DataHash
_ -> CompactAddr -> Either Addr CompactAddr
forall a b. b -> Either a b
Right CompactAddr
cAddr
  TxOutCompactRefScript CompactAddr
cAddr CompactForm (Value era)
_ Datum era
_ Script era
_ -> CompactAddr -> Either Addr CompactAddr
forall a b. b -> Either a b
Right CompactAddr
cAddr
  TxOutCompactDatum CompactAddr
cAddr CompactForm (Value era)
_ BinaryData era
_ -> CompactAddr -> Either Addr CompactAddr
forall a b. b -> Either a b
Right CompactAddr
cAddr
  TxOut_AddrHash28_AdaOnly Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
_ ->
    Addr -> Either Addr CompactAddr
forall a b. a -> Either a b
Left (Addr -> Either Addr CompactAddr)
-> Addr -> Either Addr CompactAddr
forall a b. (a -> b) -> a -> b
$ Credential 'Staking -> Addr28Extra -> Addr
decodeAddress28 Credential 'Staking
stakeRef Addr28Extra
addr28Extra
  TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
stakeRef Addr28Extra
addr28Extra CompactForm Coin
_ DataHash32
_ ->
    Addr -> Either Addr CompactAddr
forall a b. a -> Either a b
Left (Addr -> Either Addr CompactAddr)
-> Addr -> Either Addr CompactAddr
forall a b. (a -> b) -> a -> b
$ Credential 'Staking -> Addr28Extra -> Addr
decodeAddress28 Credential 'Staking
stakeRef Addr28Extra
addr28Extra
{-# INLINE getEitherAddrBabbageTxOut #-}

-- TODO: Switch to using `getDatumBabbageTxOut`
getDataBabbageTxOut :: Era era => BabbageTxOut era -> StrictMaybe (Data era)
getDataBabbageTxOut :: forall era. Era era => BabbageTxOut era -> StrictMaybe (Data era)
getDataBabbageTxOut = \case
  TxOutCompact' {} -> StrictMaybe (Data era)
forall a. StrictMaybe a
SNothing
  TxOutCompactDH' {} -> StrictMaybe (Data era)
forall a. StrictMaybe a
SNothing
  TxOutCompactDatum CompactAddr
_ CompactForm (Value era)
_ BinaryData era
binaryData -> Data era -> StrictMaybe (Data era)
forall a. a -> StrictMaybe a
SJust (Data era -> StrictMaybe (Data era))
-> Data era -> StrictMaybe (Data era)
forall a b. (a -> b) -> a -> b
$ BinaryData era -> Data era
forall era. Era era => BinaryData era -> Data era
binaryDataToData BinaryData era
binaryData
  TxOutCompactRefScript CompactAddr
_ CompactForm (Value era)
_ Datum era
datum Script era
_
    | Datum BinaryData era
binaryData <- Datum era
datum -> Data era -> StrictMaybe (Data era)
forall a. a -> StrictMaybe a
SJust (Data era -> StrictMaybe (Data era))
-> Data era -> StrictMaybe (Data era)
forall a b. (a -> b) -> a -> b
$ BinaryData era -> Data era
forall era. Era era => BinaryData era -> Data era
binaryDataToData BinaryData era
binaryData
    | Bool
otherwise -> StrictMaybe (Data era)
forall a. StrictMaybe a
SNothing
  TxOut_AddrHash28_AdaOnly {} -> StrictMaybe (Data era)
forall a. StrictMaybe a
SNothing
  TxOut_AddrHash28_AdaOnly_DataHash32 {} -> StrictMaybe (Data era)
forall a. StrictMaybe a
SNothing
{-# INLINE getDataBabbageTxOut #-}

-- TODO: Switch to using `getDatumBabbageTxOut`

-- | Return the data hash of a given transaction output, if one is present.
--  Note that this function does *not* return the hash of an inline datum
--  if one is present.
getDataHashBabbageTxOut ::
  BabbageTxOut era ->
  StrictMaybe DataHash
getDataHashBabbageTxOut :: forall era. BabbageTxOut era -> StrictMaybe DataHash
getDataHashBabbageTxOut BabbageTxOut era
txOut =
  case BabbageTxOut era -> Datum era
forall era. BabbageTxOut era -> Datum era
getDatumBabbageTxOut BabbageTxOut era
txOut of
    Datum era
NoDatum -> StrictMaybe DataHash
forall a. StrictMaybe a
SNothing
    DatumHash DataHash
dh -> DataHash -> StrictMaybe DataHash
forall a. a -> StrictMaybe a
SJust DataHash
dh
    Datum BinaryData era
_d -> StrictMaybe DataHash
forall a. StrictMaybe a
SNothing
{-# INLINE getDataHashBabbageTxOut #-}

getScriptBabbageTxOut :: BabbageTxOut era -> StrictMaybe (Script era)
getScriptBabbageTxOut :: forall era. BabbageTxOut era -> StrictMaybe (Script era)
getScriptBabbageTxOut = \case
  TxOutCompact' {} -> StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
  TxOutCompactDH' {} -> StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
  TxOutCompactDatum {} -> StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
  TxOutCompactRefScript CompactAddr
_ CompactForm (Value era)
_ Datum era
_ Script era
s -> Script era -> StrictMaybe (Script era)
forall a. a -> StrictMaybe a
SJust Script era
s
  TxOut_AddrHash28_AdaOnly {} -> StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
  TxOut_AddrHash28_AdaOnly_DataHash32 {} -> StrictMaybe (Script era)
forall a. StrictMaybe a
SNothing
{-# INLINE getScriptBabbageTxOut #-}

getDatumBabbageTxOut :: BabbageTxOut era -> Datum era
getDatumBabbageTxOut :: forall era. BabbageTxOut era -> Datum era
getDatumBabbageTxOut = \case
  TxOutCompact' {} -> Datum era
forall era. Datum era
NoDatum
  TxOutCompactDH' CompactAddr
_ CompactForm (Value era)
_ DataHash
dh -> DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash DataHash
dh
  TxOutCompactDatum CompactAddr
_ CompactForm (Value era)
_ BinaryData era
binaryData -> BinaryData era -> Datum era
forall era. BinaryData era -> Datum era
Datum BinaryData era
binaryData
  TxOutCompactRefScript CompactAddr
_ CompactForm (Value era)
_ Datum era
datum Script era
_ -> Datum era
datum
  TxOut_AddrHash28_AdaOnly {} -> Datum era
forall era. Datum era
NoDatum
  TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
_ Addr28Extra
_ CompactForm Coin
_ DataHash32
dataHash32 ->
    DataHash -> Datum era
forall era. DataHash -> Datum era
DatumHash (DataHash -> Datum era) -> DataHash -> Datum era
forall a b. (a -> b) -> a -> b
$ DataHash32 -> DataHash
decodeDataHash32 DataHash32
dataHash32
{-# INLINEABLE getDatumBabbageTxOut #-}

getCompactValueBabbageTxOut :: EraTxOut era => BabbageTxOut era -> CompactForm (Value era)
getCompactValueBabbageTxOut :: forall era.
EraTxOut era =>
BabbageTxOut era -> CompactForm (Value era)
getCompactValueBabbageTxOut =
  \case
    TxOutCompact' CompactAddr
_ CompactForm (Value era)
cv -> CompactForm (Value era)
cv
    TxOutCompactDH' CompactAddr
_ CompactForm (Value era)
cv DataHash
_ -> CompactForm (Value era)
cv
    TxOutCompactDatum CompactAddr
_ CompactForm (Value era)
cv BinaryData era
_ -> CompactForm (Value era)
cv
    TxOutCompactRefScript CompactAddr
_ CompactForm (Value era)
cv Datum era
_ Script era
_ -> CompactForm (Value era)
cv
    TxOut_AddrHash28_AdaOnly Credential 'Staking
_ Addr28Extra
_ CompactForm Coin
cc -> CompactForm Coin -> CompactForm (Value era)
forall t. Val t => CompactForm Coin -> CompactForm t
injectCompact CompactForm Coin
cc
    TxOut_AddrHash28_AdaOnly_DataHash32 Credential 'Staking
_ Addr28Extra
_ CompactForm Coin
cc DataHash32
_ -> CompactForm Coin -> CompactForm (Value era)
forall t. Val t => CompactForm Coin -> CompactForm t
injectCompact CompactForm Coin
cc
{-# INLINE getCompactValueBabbageTxOut #-}

txOutData :: Era era => BabbageTxOut era -> Maybe (Data era)
txOutData :: forall era. Era era => BabbageTxOut era -> Maybe (Data era)
txOutData = StrictMaybe (Data era) -> Maybe (Data era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (StrictMaybe (Data era) -> Maybe (Data era))
-> (BabbageTxOut era -> StrictMaybe (Data era))
-> BabbageTxOut era
-> Maybe (Data era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> StrictMaybe (Data era)
forall era. Era era => BabbageTxOut era -> StrictMaybe (Data era)
getDataBabbageTxOut
{-# DEPRECATED txOutData "In favor of `dataTxOutL` or `getDataBabbageTxOut`" #-}

txOutDataHash :: BabbageTxOut era -> Maybe DataHash
txOutDataHash :: forall era. BabbageTxOut era -> Maybe DataHash
txOutDataHash = StrictMaybe DataHash -> Maybe DataHash
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (StrictMaybe DataHash -> Maybe DataHash)
-> (BabbageTxOut era -> StrictMaybe DataHash)
-> BabbageTxOut era
-> Maybe DataHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> StrictMaybe DataHash
forall era. BabbageTxOut era -> StrictMaybe DataHash
getDataHashBabbageTxOut
{-# DEPRECATED txOutDataHash "In favor of `dataHashTxOutL` or `getDataHashBabbageTxOut`" #-}

txOutScript :: BabbageTxOut era -> Maybe (Script era)
txOutScript :: forall era. BabbageTxOut era -> Maybe (Script era)
txOutScript = StrictMaybe (Script era) -> Maybe (Script era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (StrictMaybe (Script era) -> Maybe (Script era))
-> (BabbageTxOut era -> StrictMaybe (Script era))
-> BabbageTxOut era
-> Maybe (Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageTxOut era -> StrictMaybe (Script era)
forall era. BabbageTxOut era -> StrictMaybe (Script era)
getScriptBabbageTxOut
{-# DEPRECATED txOutScript "In favor of `dataTxOutL` or `getScriptBabbageTxOut`" #-}

decodeCIC :: DecCBOR b => T.Text -> Decoder s b
decodeCIC :: forall b s. DecCBOR b => Text -> Decoder s b
decodeCIC Text
s = do
  Version
version <- Decoder s Version
forall s. Decoder s Version
getDecoderVersion
  ByteString
bs <- Decoder s ByteString
forall s. Decoder s ByteString
decodeNestedCborBytes
  case Version -> ByteString -> Either DecoderError b
forall a.
DecCBOR a =>
Version -> ByteString -> Either DecoderError a
decodeFull' Version
version ByteString
bs of
    Left DecoderError
e -> String -> Decoder s b
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Decoder s b) -> String -> Decoder s b
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
s String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
": " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> DecoderError -> String
forall a. Show a => a -> String
show DecoderError
e
    Right b
x -> b -> Decoder s b
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
x
{-# INLINEABLE decodeCIC #-}