{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}

-- | User-friendly pretty-printing for textual user interfaces (TUI)
module Cardano.CLI.Compatible.Json.Friendly
  ( -- * Functions in IO

  --
  -- Use them when writing to stdout or to files.
    friendlyTx
  , friendlyTxBody
  , friendlyProposal
  , friendlyDRep

    -- * Functions that are not in IO

  --
  -- They are more low-level, but can be used in any context.
  -- The '*Impl' functions give you access to the Aeson representation
  -- of various structures.
  , friendlyTxImpl
  , friendlyTxBodyImpl
  , friendlyProposalImpl
  )
where

import Cardano.Api as Api
import Cardano.Api.Experimental (obtainCommonConstraints)
import Cardano.Api.Experimental qualified as Exp
import Cardano.Api.Ledger (ExUnits (..), extractHash, strictMaybeToMaybe)
import Cardano.Api.Ledger qualified as Alonzo
import Cardano.Api.Ledger qualified as L
import Cardano.Api.Ledger qualified as Ledger

import Cardano.CLI.Json.Encode qualified as Json
import Cardano.CLI.Orphan ()
import Cardano.CLI.Type.Common (FormatJson (..), FormatYaml (..))
import Cardano.CLI.Type.MonadWarning (MonadWarning, runWarningIO)
import Cardano.Crypto.Hash (hashToTextAsHex)
import Cardano.Ledger.Core qualified as C
import Cardano.Ledger.Credential (credKeyHash, credScriptHash)

import Data.Aeson (Value (..), object, (.=))
import Data.Aeson qualified as Aeson
import Data.Aeson.Key qualified as Aeson
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Aeson.Types qualified as Aeson
import Data.ByteString.Char8 qualified as BSC
import Data.Char (isAscii)
import Data.Function ((&))
import Data.Functor ((<&>))
import Data.Map.Strict qualified as Map
import Data.Maybe
import Data.Ratio (numerator)
import Data.Text qualified as T
import Data.Text qualified as Text
import Data.Typeable (Typeable)
import Data.Vector qualified as Vector
import Data.Yaml (array)
import GHC.Exts (IsList (..))
import GHC.Real (denominator)
import GHC.Unicode (isAlphaNum)
import Lens.Micro ((^.))
import Vary (Vary)
import Vary qualified

friendly
  :: (MonadIO m, Aeson.ToJSON a)
  => Vary [FormatJson, FormatYaml]
  -> Maybe (File () Out)
  -> a
  -> m (Either (FileError e) ())
friendly :: forall (m :: * -> *) a e.
(MonadIO m, ToJSON a) =>
Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out) -> a -> m (Either (FileError e) ())
friendly Vary '[FormatJson, FormatYaml]
format Maybe (File () 'Out)
mOutFile a
value = do
  output <-
    ByteString -> m ByteString
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      (ByteString -> m ByteString) -> ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ Vary '[FormatJson, FormatYaml]
format
        Vary '[FormatJson, FormatYaml]
-> (Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> a
-> ByteString
forall a b. a -> (a -> b) -> b
& ( (Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> Vary '[FormatJson, FormatYaml] -> a -> ByteString
forall a. a -> a
id
              ((Vary '[FormatJson, FormatYaml] -> a -> ByteString)
 -> Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> ((Vary '[] -> a -> ByteString)
    -> Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> (Vary '[] -> a -> ByteString)
-> Vary '[FormatJson, FormatYaml]
-> a
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FormatJson -> a -> ByteString)
-> (Vary '[FormatYaml] -> a -> ByteString)
-> Vary '[FormatJson, FormatYaml]
-> a
-> ByteString
forall a b (l :: [*]).
(a -> b) -> (Vary l -> b) -> Vary (a : l) -> b
Vary.on (\FormatJson
FormatJson -> a -> ByteString
forall a. ToJSON a => a -> ByteString
Json.encodeJson)
              ((Vary '[FormatYaml] -> a -> ByteString)
 -> Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> ((Vary '[] -> a -> ByteString)
    -> Vary '[FormatYaml] -> a -> ByteString)
-> (Vary '[] -> a -> ByteString)
-> Vary '[FormatJson, FormatYaml]
-> a
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FormatYaml -> a -> ByteString)
-> (Vary '[] -> a -> ByteString)
-> Vary '[FormatYaml]
-> a
-> ByteString
forall a b (l :: [*]).
(a -> b) -> (Vary l -> b) -> Vary (a : l) -> b
Vary.on (\FormatYaml
FormatYaml -> a -> ByteString
forall a. ToJSON a => a -> ByteString
Json.encodeYaml)
              ((Vary '[] -> a -> ByteString)
 -> Vary '[FormatJson, FormatYaml] -> a -> ByteString)
-> (Vary '[] -> a -> ByteString)
-> Vary '[FormatJson, FormatYaml]
-> a
-> ByteString
forall a b. (a -> b) -> a -> b
$ Vary '[] -> a -> ByteString
forall anything. Vary '[] -> anything
Vary.exhaustiveCase
          )
      (a -> ByteString) -> a -> ByteString
forall a b. (a -> b) -> a -> b
$ a
value

  writeLazyByteStringOutput mOutFile output

friendlyTx
  :: MonadIO m
  => Vary [FormatJson, FormatYaml]
  -> Maybe (File () Out)
  -> ShelleyBasedEra era
  -> Tx era
  -> m (Either (FileError e) ())
friendlyTx :: forall (m :: * -> *) era e.
MonadIO m =>
Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out)
-> ShelleyBasedEra era
-> Tx era
-> m (Either (FileError e) ())
friendlyTx Vary '[FormatJson, FormatYaml]
format Maybe (File () 'Out)
mOutFile ShelleyBasedEra era
era Tx era
tx = do
  pairs <- WarningIO m [(Key, Value)] -> m [(Key, Value)]
forall (m :: * -> *) a. WarningIO m a -> m a
runWarningIO (WarningIO m [(Key, Value)] -> m [(Key, Value)])
-> WarningIO m [(Key, Value)] -> m [(Key, Value)]
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era -> Tx era -> WarningIO m [(Key, Value)]
forall (m :: * -> *) era.
MonadWarning m =>
ShelleyBasedEra era -> Tx era -> m [(Key, Value)]
friendlyTxImpl ShelleyBasedEra era
era Tx era
tx
  friendly format mOutFile $ object pairs

friendlyTxBody
  :: MonadIO m
  => Vary [FormatJson, FormatYaml]
  -> Maybe (File () Out)
  -> ShelleyBasedEra era
  -> TxBody era
  -> m (Either (FileError e) ())
friendlyTxBody :: forall (m :: * -> *) era e.
MonadIO m =>
Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out)
-> ShelleyBasedEra era
-> TxBody era
-> m (Either (FileError e) ())
friendlyTxBody Vary '[FormatJson, FormatYaml]
format Maybe (File () 'Out)
mOutFile ShelleyBasedEra era
era TxBody era
tx = do
  pairs <- WarningIO m [(Key, Value)] -> m [(Key, Value)]
forall (m :: * -> *) a. WarningIO m a -> m a
runWarningIO (WarningIO m [(Key, Value)] -> m [(Key, Value)])
-> WarningIO m [(Key, Value)] -> m [(Key, Value)]
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era -> TxBody era -> WarningIO m [(Key, Value)]
forall (m :: * -> *) era.
MonadWarning m =>
ShelleyBasedEra era -> TxBody era -> m [(Key, Value)]
friendlyTxBodyImpl ShelleyBasedEra era
era TxBody era
tx
  friendly format mOutFile $ object pairs

friendlyProposal
  :: MonadIO m
  => Exp.IsEra era
  => Vary [FormatJson, FormatYaml]
  -> Maybe (File () Out)
  -> Proposal era
  -> m (Either (FileError e) ())
friendlyProposal :: forall (m :: * -> *) era e.
(MonadIO m, IsEra era) =>
Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out)
-> Proposal era
-> m (Either (FileError e) ())
friendlyProposal Vary '[FormatJson, FormatYaml]
format Maybe (File () 'Out)
mOutFile =
  Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out) -> Value -> m (Either (FileError e) ())
forall (m :: * -> *) a e.
(MonadIO m, ToJSON a) =>
Vary '[FormatJson, FormatYaml]
-> Maybe (File () 'Out) -> a -> m (Either (FileError e) ())
friendly Vary '[FormatJson, FormatYaml]
format Maybe (File () 'Out)
mOutFile (Value -> m (Either (FileError e) ()))
-> (Proposal era -> Value)
-> Proposal era
-> m (Either (FileError e) ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Key, Value)] -> Value
object ([(Key, Value)] -> Value)
-> (Proposal era -> [(Key, Value)]) -> Proposal era -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proposal era -> [(Key, Value)]
forall era. IsEra era => Proposal era -> [(Key, Value)]
friendlyProposalImpl

friendlyProposalImpl :: forall era. Exp.IsEra era => Proposal era -> [Aeson.Pair]
friendlyProposalImpl :: forall era. IsEra era => Proposal era -> [(Key, Value)]
friendlyProposalImpl
  ( Proposal
      ( L.ProposalProcedure
          { Coin
pProcDeposit :: Coin
pProcDeposit :: forall era. ProposalProcedure era -> Coin
L.pProcDeposit
          , AccountAddress
pProcReturnAddr :: AccountAddress
pProcReturnAddr :: forall era. ProposalProcedure era -> AccountAddress
L.pProcReturnAddr
          , GovAction (ShelleyLedgerEra era)
pProcGovAction :: GovAction (ShelleyLedgerEra era)
pProcGovAction :: forall era. ProposalProcedure era -> GovAction era
L.pProcGovAction
          , Anchor
pProcAnchor :: Anchor
pProcAnchor :: forall era. ProposalProcedure era -> Anchor
L.pProcAnchor
          }
        )
    ) =
    Era era
-> (EraCommonConstraints era => [(Key, Value)]) -> [(Key, Value)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
Exp.obtainCommonConstraints
      (forall era. IsEra era => Era era
Exp.useEra @era)
      [ Key
"deposit" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
pProcDeposit
      , Key
"return address" Key -> AccountAddress -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AccountAddress
pProcReturnAddr
      , Key
"governance action" Key -> GovAction (LedgerEra era) -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= GovAction (ShelleyLedgerEra era)
GovAction (LedgerEra era)
pProcGovAction
      , Key
"anchor" Key -> Anchor -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Anchor
pProcAnchor
      ]

friendlyTxImpl
  :: MonadWarning m
  => ShelleyBasedEra era
  -> Tx era
  -> m [Aeson.Pair]
friendlyTxImpl :: forall (m :: * -> *) era.
MonadWarning m =>
ShelleyBasedEra era -> Tx era -> m [(Key, Value)]
friendlyTxImpl ShelleyBasedEra era
era Tx era
tx =
  ((Key
"witnesses" Key -> [Value] -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (KeyWitness era -> Value) -> [KeyWitness era] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map KeyWitness era -> Value
forall era. KeyWitness era -> Value
friendlyKeyWitness [KeyWitness era]
witnesses) (Key, Value) -> [(Key, Value)] -> [(Key, Value)]
forall a. a -> [a] -> [a]
:) ([(Key, Value)] -> [(Key, Value)])
-> m [(Key, Value)] -> m [(Key, Value)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> TxBody era -> m [(Key, Value)]
forall (m :: * -> *) era.
MonadWarning m =>
ShelleyBasedEra era -> TxBody era -> m [(Key, Value)]
friendlyTxBodyImpl ShelleyBasedEra era
era TxBody era
body
 where
  (TxBody era
body, [KeyWitness era]
witnesses) = Tx era -> (TxBody era, [KeyWitness era])
forall era. Tx era -> (TxBody era, [KeyWitness era])
getTxBodyAndWitnesses Tx era
tx

friendlyKeyWitness :: KeyWitness era -> Aeson.Value
friendlyKeyWitness :: forall era. KeyWitness era -> Value
friendlyKeyWitness =
  [(Key, Value)] -> Value
object
    ([(Key, Value)] -> Value)
-> (KeyWitness era -> [(Key, Value)]) -> KeyWitness era -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
      ByronKeyWitness TxInWitness
txInWitness -> [Key
"Byron witness" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxInWitness -> Text
forall a. Show a => a -> Text
textShow TxInWitness
txInWitness]
      ShelleyBootstrapWitness ShelleyBasedEra era
_era BootstrapWitness
bootstrapWitness ->
        [Key
"bootstrap witness" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= BootstrapWitness -> Text
forall a. Show a => a -> Text
textShow BootstrapWitness
bootstrapWitness]
      ShelleyKeyWitness ShelleyBasedEra era
_era (L.WitVKey VKey Witness
key SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
signature) ->
        [Key
"key" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= VKey Witness -> Text
forall a. Show a => a -> Text
textShow VKey Witness
key, Key
"signature" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody) -> Text
forall a. Show a => a -> Text
textShow SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
signature]

friendlyTxBodyImpl
  :: forall m era
   . MonadWarning m
  => ShelleyBasedEra era
  -> TxBody era
  -> m [Aeson.Pair]
friendlyTxBodyImpl :: forall (m :: * -> *) era.
MonadWarning m =>
ShelleyBasedEra era -> TxBody era -> m [(Key, Value)]
friendlyTxBodyImpl ShelleyBasedEra era
sbe TxBody era
tb = do
  let era :: CardanoEra era
era = ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert ShelleyBasedEra era
sbe :: CardanoEra era
  [(Key, Value)] -> m [(Key, Value)]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
    ( [[(Key, Value)]] -> [(Key, Value)]
forall a. Monoid a => [a] -> a
mconcat
        [
          [ Key
"auxiliary scripts" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxAuxScripts era -> Value
forall era. TxAuxScripts era -> Value
friendlyAuxScripts TxAuxScripts era
txAuxScripts
          , Key
"certificates" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ShelleyBasedEra era
-> Value -> (ShelleyBasedEra era -> Value) -> Value
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon ShelleyBasedEra era
sbe Value
Null (ShelleyBasedEra era -> TxCertificates ViewTx era -> Value
forall era.
ShelleyBasedEra era -> TxCertificates ViewTx era -> Value
`friendlyCertificates` TxCertificates ViewTx era
txCertificates)
          , Key
"collateral inputs" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxInsCollateral era -> Value
forall era. TxInsCollateral era -> Value
friendlyCollateralInputs TxInsCollateral era
txInsCollateral
          , Key
"era" Key -> CardanoEra era -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= CardanoEra era
era
          , Key
"fee" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxFee era -> Value
forall era. TxFee era -> Value
friendlyFee TxFee era
txFee
          , Key
"inputs" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(TxIn, BuildTxWith ViewTx (Witness WitCtxTxIn era))] -> Value
forall build. [(TxIn, build)] -> Value
friendlyInputs [(TxIn, BuildTxWith ViewTx (Witness WitCtxTxIn era))]
txIns
          , Key
"metadata" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxMetadataInEra era -> Value
forall era. TxMetadataInEra era -> Value
friendlyMetadata TxMetadataInEra era
txMetadata
          , Key
"mint" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxMintValue ViewTx era -> Value
forall era. TxMintValue ViewTx era -> Value
friendlyMintValue TxMintValue ViewTx era
txMintValue
          , Key
"outputs" Key -> [Value] -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (TxOut CtxTx era -> Value) -> [TxOut CtxTx era] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map (ShelleyBasedEra era -> TxOut CtxTx era -> Value
forall era. ShelleyBasedEra era -> TxOut CtxTx era -> Value
friendlyTxOut ShelleyBasedEra era
sbe) [TxOut CtxTx era]
txOuts
          , Key
"reference inputs" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxInsReference ViewTx era -> Value
forall era build. TxInsReference era build -> Value
friendlyReferenceInputs TxInsReference ViewTx era
txInsReference
          , Key
"total collateral" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxTotalCollateral era -> Value
forall era. TxTotalCollateral era -> Value
friendlyTotalCollateral TxTotalCollateral era
txTotalCollateral
          , Key
"return collateral" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ShelleyBasedEra era -> TxReturnCollateral CtxTx era -> Value
forall era.
ShelleyBasedEra era -> TxReturnCollateral CtxTx era -> Value
friendlyReturnCollateral ShelleyBasedEra era
sbe TxReturnCollateral CtxTx era
txReturnCollateral
          , Key
"required signers (payment key hashes needed for scripts)"
              Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxExtraKeyWitnesses era -> Value
forall era. TxExtraKeyWitnesses era -> Value
friendlyExtraKeyWits TxExtraKeyWitnesses era
txExtraKeyWits
          , Key
"update proposal" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxUpdateProposal era -> Value
forall era. TxUpdateProposal era -> Value
friendlyUpdateProposal TxUpdateProposal era
txUpdateProposal
          , Key
"validity range" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ShelleyBasedEra era
-> (TxValidityLowerBound era, TxValidityUpperBound era) -> Value
forall era.
ShelleyBasedEra era
-> (TxValidityLowerBound era, TxValidityUpperBound era) -> Value
friendlyValidityRange ShelleyBasedEra era
sbe (TxValidityLowerBound era
txValidityLowerBound, TxValidityUpperBound era
txValidityUpperBound)
          , Key
"withdrawals" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxWithdrawals ViewTx era -> Value
forall era. TxWithdrawals ViewTx era -> Value
friendlyWithdrawals TxWithdrawals ViewTx era
txWithdrawals
          ]
        , ShelleyBasedEra era
-> [(Key, Value)] -> (Era era -> [(Key, Value)]) -> [(Key, Value)]
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon
            ShelleyBasedEra era
sbe
            [(Key, Value)]
forall a. Monoid a => a
mempty
            (Era era -> TxBody era -> [(Key, Value)]
forall era. Era era -> TxBody era -> [(Key, Value)]
`getScriptWitnessDetails` TxBody era
tb)
        , ShelleyBasedEra era
-> [(Key, Value)]
-> (ConwayEraOnwards era -> [(Key, Value)])
-> [(Key, Value)]
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon
            ShelleyBasedEra era
sbe
            [(Key, Value)]
forall a. Monoid a => a
mempty
            ( \ConwayEraOnwards era
cOnwards ->
                ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era => [(Key, Value)])
-> [(Key, Value)]
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
cOnwards ((ConwayEraOnwardsConstraints era => [(Key, Value)])
 -> [(Key, Value)])
-> (ConwayEraOnwardsConstraints era => [(Key, Value)])
-> [(Key, Value)]
forall a b. (a -> b) -> a -> b
$
                  case Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures ViewTx era))
txProposalProcedures of
                    Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures ViewTx era))
Nothing -> []
                    Just (Featured ConwayEraOnwards era
_ TxProposalProcedures ViewTx era
TxProposalProceduresNone) -> []
                    Just (Featured ConwayEraOnwards era
_ TxProposalProcedures ViewTx era
pp) -> do
                      let lProposals :: [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
lProposals = OSet (ProposalProcedure (ShelleyLedgerEra era))
-> [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
forall l. IsList l => l -> [Item l]
toList (OSet (ProposalProcedure (ShelleyLedgerEra era))
 -> [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))])
-> OSet (ProposalProcedure (ShelleyLedgerEra era))
-> [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
forall a b. (a -> b) -> a -> b
$ TxProposalProcedures ViewTx era
-> OSet (ProposalProcedure (ShelleyLedgerEra era))
forall build era.
TxProposalProcedures build era
-> OSet (ProposalProcedure (ShelleyLedgerEra era))
convProposalProcedures TxProposalProcedures ViewTx era
pp
                      [Key
"governance actions" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Era era -> [ProposalProcedure (ShelleyLedgerEra era)] -> Value
forall era.
Typeable era =>
Era era -> [ProposalProcedure (ShelleyLedgerEra era)] -> Value
friendlyLedgerProposals (ConwayEraOnwards era -> Era era
forall era. ConwayEraOnwards era -> Era era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert ConwayEraOnwards era
cOnwards) [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
[ProposalProcedure (ShelleyLedgerEra era)]
lProposals]
            )
        , ShelleyBasedEra era
-> [(Key, Value)]
-> (ConwayEraOnwards era -> [(Key, Value)])
-> [(Key, Value)]
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon
            ShelleyBasedEra era
sbe
            [(Key, Value)]
forall a. Monoid a => a
mempty
            ( \ConwayEraOnwards era
cOnwards ->
                case Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures ViewTx era))
txVotingProcedures of
                  Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures ViewTx era))
Nothing -> []
                  Just (Featured ConwayEraOnwards era
_ TxVotingProcedures ViewTx era
TxVotingProceduresNone) -> []
                  Just (Featured ConwayEraOnwards era
_ (TxVotingProcedures VotingProcedures (ShelleyLedgerEra era)
votes BuildTxWith ViewTx (Map Voter (ScriptWitness WitCtxStake era))
_witnesses)) ->
                    [Key
"voters" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ConwayEraOnwards era
-> VotingProcedures (ShelleyLedgerEra era) -> Value
forall era.
ConwayEraOnwards era
-> VotingProcedures (ShelleyLedgerEra era) -> Value
friendlyVotingProcedures ConwayEraOnwards era
cOnwards VotingProcedures (ShelleyLedgerEra era)
votes]
            )
        , forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon @ConwayEraOnwards
            ShelleyBasedEra era
sbe
            [(Key, Value)]
forall a. Monoid a => a
mempty
            ([(Key, Value)] -> ConwayEraOnwards era -> [(Key, Value)]
forall a b. a -> b -> a
const [Key
"currentTreasuryValue" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe (Maybe Coin) -> Value
forall a. ToJSON a => a -> Value
toJSON (Featured ConwayEraOnwards era (Maybe Coin) -> Maybe Coin
forall (eon :: * -> *) era a. Featured eon era a -> a
unFeatured (Featured ConwayEraOnwards era (Maybe Coin) -> Maybe Coin)
-> Maybe (Featured ConwayEraOnwards era (Maybe Coin))
-> Maybe (Maybe Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Featured ConwayEraOnwards era (Maybe Coin))
txCurrentTreasuryValue)])
        , forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> a -> (eon era -> a) -> a
forShelleyBasedEraInEon @ConwayEraOnwards
            ShelleyBasedEra era
sbe
            [(Key, Value)]
forall a. Monoid a => a
mempty
            ([(Key, Value)] -> ConwayEraOnwards era -> [(Key, Value)]
forall a b. a -> b -> a
const [Key
"treasuryDonation" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Coin -> Value
forall a. ToJSON a => a -> Value
toJSON (Featured ConwayEraOnwards era Coin -> Coin
forall (eon :: * -> *) era a. Featured eon era a -> a
unFeatured (Featured ConwayEraOnwards era Coin -> Coin)
-> Maybe (Featured ConwayEraOnwards era Coin) -> Maybe Coin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Featured ConwayEraOnwards era Coin)
txTreasuryDonation)])
        ]
    )
 where
  -- Enumerating the fields, so that we are warned by GHC when we add a new one
  TxBodyContent
    [(TxIn, BuildTxWith ViewTx (Witness WitCtxTxIn era))]
txIns
    TxInsCollateral era
txInsCollateral
    TxInsReference ViewTx era
txInsReference
    [TxOut CtxTx era]
txOuts
    TxTotalCollateral era
txTotalCollateral
    TxReturnCollateral CtxTx era
txReturnCollateral
    TxFee era
txFee
    TxValidityLowerBound era
txValidityLowerBound
    TxValidityUpperBound era
txValidityUpperBound
    TxMetadataInEra era
txMetadata
    TxAuxScripts era
txAuxScripts
    TxExtraKeyWitnesses era
txExtraKeyWits
    BuildTxWith ViewTx (Maybe (LedgerProtocolParameters era))
_txProtocolParams
    TxWithdrawals ViewTx era
txWithdrawals
    TxCertificates ViewTx era
txCertificates
    TxUpdateProposal era
txUpdateProposal
    TxMintValue ViewTx era
txMintValue
    TxScriptValidity era
_txScriptValidity
    Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures ViewTx era))
txProposalProcedures
    Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures ViewTx era))
txVotingProcedures
    Maybe (Featured ConwayEraOnwards era (Maybe Coin))
txCurrentTreasuryValue
    Maybe (Featured ConwayEraOnwards era Coin)
txTreasuryDonation = TxBody era -> TxBodyContent ViewTx era
forall era. TxBody era -> TxBodyContent ViewTx era
getTxBodyContent TxBody era
tb

friendlyLedgerProposals
  :: Typeable era => Exp.Era era -> [L.ProposalProcedure (ShelleyLedgerEra era)] -> Aeson.Value
friendlyLedgerProposals :: forall era.
Typeable era =>
Era era -> [ProposalProcedure (ShelleyLedgerEra era)] -> Value
friendlyLedgerProposals Era era
e [ProposalProcedure (ShelleyLedgerEra era)]
proposalProcedures =
  Array -> Value
Array (Array -> Value) -> Array -> Value
forall a b. (a -> b) -> a -> b
$ [Item Array] -> Array
forall l. IsList l => [Item l] -> l
fromList ([Item Array] -> Array) -> [Item Array] -> Array
forall a b. (a -> b) -> a -> b
$ (ProposalProcedure (ShelleyLedgerEra era) -> Item Array)
-> [ProposalProcedure (ShelleyLedgerEra era)] -> [Item Array]
forall a b. (a -> b) -> [a] -> [b]
map (Era era
-> (EraCommonConstraints era =>
    ProposalProcedure (ShelleyLedgerEra era) -> Value)
-> ProposalProcedure (ShelleyLedgerEra era)
-> Value
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
e EraCommonConstraints era =>
ProposalProcedure (ShelleyLedgerEra era) -> Value
ProposalProcedure (ShelleyLedgerEra era) -> Value
forall era.
(Typeable era, IsEra era) =>
ProposalProcedure (ShelleyLedgerEra era) -> Value
friendlyLedgerProposal) [ProposalProcedure (ShelleyLedgerEra era)]
proposalProcedures

friendlyLedgerProposal
  :: (Typeable era, Exp.IsEra era) => L.ProposalProcedure (ShelleyLedgerEra era) -> Aeson.Value
friendlyLedgerProposal :: forall era.
(Typeable era, IsEra era) =>
ProposalProcedure (ShelleyLedgerEra era) -> Value
friendlyLedgerProposal ProposalProcedure (ShelleyLedgerEra era)
proposalProcedure = [(Key, Value)] -> Value
object ([(Key, Value)] -> Value) -> [(Key, Value)] -> Value
forall a b. (a -> b) -> a -> b
$ Proposal era -> [(Key, Value)]
forall era. IsEra era => Proposal era -> [(Key, Value)]
friendlyProposalImpl (ProposalProcedure (ShelleyLedgerEra era) -> Proposal era
forall era.
Typeable era =>
ProposalProcedure (ShelleyLedgerEra era) -> Proposal era
Proposal ProposalProcedure (ShelleyLedgerEra era)
proposalProcedure)

friendlyVotingProcedures
  :: ConwayEraOnwards era -> L.VotingProcedures (ShelleyLedgerEra era) -> Aeson.Value
friendlyVotingProcedures :: forall era.
ConwayEraOnwards era
-> VotingProcedures (ShelleyLedgerEra era) -> Value
friendlyVotingProcedures ConwayEraOnwards era
cOnwards VotingProcedures (ShelleyLedgerEra era)
x = ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era => Value) -> Value
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
cOnwards ((ConwayEraOnwardsConstraints era => Value) -> Value)
-> (ConwayEraOnwardsConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$ VotingProcedures (ShelleyLedgerEra era) -> Value
forall a. ToJSON a => a -> Value
toJSON VotingProcedures (ShelleyLedgerEra era)
x

data EraIndependentPlutusScriptPurpose
  = Spending
  | Minting
  | Certifying
  | Rewarding
  | Voting
  | Proposing
  | Guarding

getScriptWitnessDetails
  :: forall era. Exp.Era era -> TxBody era -> [Aeson.Pair]
getScriptWitnessDetails :: forall era. Era era -> TxBody era -> [(Key, Value)]
getScriptWitnessDetails Era era
era TxBody era
tb =
  let ShelleyTx ShelleyBasedEra era
_ Tx TopTx (ShelleyLedgerEra era)
ledgerTx = [KeyWitness era] -> TxBody era -> Tx era
forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction [] TxBody era
tb
   in [ Key
"redeemers" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyRedeemers Tx TopTx (ShelleyLedgerEra era)
ledgerTx
      , Key
"scripts" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyScriptData Tx TopTx (ShelleyLedgerEra era)
ledgerTx
      , Key
"datums" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyDats Tx TopTx (ShelleyLedgerEra era)
ledgerTx
      ]
 where
  aeo :: AlonzoEraOnwards era
aeo = Era era -> AlonzoEraOnwards era
forall era. Era era -> AlonzoEraOnwards era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert Era era
era
  friendlyRedeemers
    :: Ledger.Tx C.TopTx (ShelleyLedgerEra era)
    -> Aeson.Value
  friendlyRedeemers :: Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyRedeemers Tx TopTx (ShelleyLedgerEra era)
tx =
    AlonzoEraOnwards era
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall era a.
AlonzoEraOnwards era -> (AlonzoEraOnwardsConstraints era => a) -> a
alonzoEraOnwardsConstraints AlonzoEraOnwards era
aeo ((AlonzoEraOnwardsConstraints era => Value) -> Value)
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$ do
      let plutusScriptPurposeAndExUnits :: [(PlutusPurpose AsIx (ShelleyLedgerEra era),
  (Data (ShelleyLedgerEra era), ExUnits))]
plutusScriptPurposeAndExUnits = Map
  (PlutusPurpose AsIx (ShelleyLedgerEra era))
  (Data (ShelleyLedgerEra era), ExUnits)
-> [(PlutusPurpose AsIx (ShelleyLedgerEra era),
     (Data (ShelleyLedgerEra era), ExUnits))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map
   (PlutusPurpose AsIx (ShelleyLedgerEra era))
   (Data (ShelleyLedgerEra era), ExUnits)
 -> [(PlutusPurpose AsIx (ShelleyLedgerEra era),
      (Data (ShelleyLedgerEra era), ExUnits))])
-> Map
     (PlutusPurpose AsIx (ShelleyLedgerEra era))
     (Data (ShelleyLedgerEra era), ExUnits)
-> [(PlutusPurpose AsIx (ShelleyLedgerEra era),
     (Data (ShelleyLedgerEra era), ExUnits))]
forall a b. (a -> b) -> a -> b
$ Redeemers (ShelleyLedgerEra era)
-> Map
     (PlutusPurpose AsIx (ShelleyLedgerEra era))
     (Data (ShelleyLedgerEra era), ExUnits)
forall era.
Redeemers era -> Map (PlutusPurpose AsIx era) (Data era, ExUnits)
Ledger.unRedeemers (Redeemers (ShelleyLedgerEra era)
 -> Map
      (PlutusPurpose AsIx (ShelleyLedgerEra era))
      (Data (ShelleyLedgerEra era), ExUnits))
-> Redeemers (ShelleyLedgerEra era)
-> Map
     (PlutusPurpose AsIx (ShelleyLedgerEra era))
     (Data (ShelleyLedgerEra era), ExUnits)
forall a b. (a -> b) -> a -> b
$ Tx TopTx (ShelleyLedgerEra era)
tx Tx TopTx (ShelleyLedgerEra era)
-> Getting
     (Redeemers (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
     (Redeemers (ShelleyLedgerEra era))
-> Redeemers (ShelleyLedgerEra era)
forall s a. s -> Getting a s a -> a
^. (TxWits (ShelleyLedgerEra era)
 -> Const
      (Redeemers (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
-> Tx TopTx (ShelleyLedgerEra era)
-> Const
     (Redeemers (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxWits era)
forall (l :: TxLevel).
Lens' (Tx l (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era))
Ledger.witsTxL ((TxWits (ShelleyLedgerEra era)
  -> Const
       (Redeemers (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
 -> Tx TopTx (ShelleyLedgerEra era)
 -> Const
      (Redeemers (ShelleyLedgerEra era))
      (Tx TopTx (ShelleyLedgerEra era)))
-> ((Redeemers (ShelleyLedgerEra era)
     -> Const
          (Redeemers (ShelleyLedgerEra era))
          (Redeemers (ShelleyLedgerEra era)))
    -> TxWits (ShelleyLedgerEra era)
    -> Const
         (Redeemers (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
-> Getting
     (Redeemers (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
     (Redeemers (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Redeemers (ShelleyLedgerEra era)
 -> Const
      (Redeemers (ShelleyLedgerEra era))
      (Redeemers (ShelleyLedgerEra era)))
-> TxWits (ShelleyLedgerEra era)
-> Const
     (Redeemers (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era))
forall era.
AlonzoEraTxWits era =>
Lens' (TxWits era) (Redeemers era)
Lens'
  (TxWits (ShelleyLedgerEra era)) (Redeemers (ShelleyLedgerEra era))
Ledger.rdmrsTxWitsL
          redeemerList :: [Value]
redeemerList = ((PlutusPurpose AsIx (ShelleyLedgerEra era),
  (Data (ShelleyLedgerEra era), ExUnits))
 -> Value)
-> [(PlutusPurpose AsIx (ShelleyLedgerEra era),
     (Data (ShelleyLedgerEra era), ExUnits))]
-> [Value]
forall a b. (a -> b) -> [a] -> [b]
map ((PlutusPurpose AsIx (ShelleyLedgerEra era)
 -> (Data (ShelleyLedgerEra era), ExUnits) -> Value)
-> (PlutusPurpose AsIx (ShelleyLedgerEra era),
    (Data (ShelleyLedgerEra era), ExUnits))
-> Value
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((PlutusPurpose AsIx (ShelleyLedgerEra era)
  -> (Data (ShelleyLedgerEra era), ExUnits) -> Value)
 -> (PlutusPurpose AsIx (ShelleyLedgerEra era),
     (Data (ShelleyLedgerEra era), ExUnits))
 -> Value)
-> (PlutusPurpose AsIx (ShelleyLedgerEra era)
    -> (Data (ShelleyLedgerEra era), ExUnits) -> Value)
-> (PlutusPurpose AsIx (ShelleyLedgerEra era),
    (Data (ShelleyLedgerEra era), ExUnits))
-> Value
forall a b. (a -> b) -> a -> b
$ Tx TopTx (ShelleyLedgerEra era)
-> PlutusPurpose AsIx (ShelleyLedgerEra era)
-> (Data (ShelleyLedgerEra era), ExUnits)
-> Value
friendlyRedeemerInfo Tx TopTx (ShelleyLedgerEra era)
tx) [(PlutusPurpose AsIx (ShelleyLedgerEra era),
  (Data (ShelleyLedgerEra era), ExUnits))]
plutusScriptPurposeAndExUnits
      Array -> Value
Aeson.Array (Array -> Value) -> Array -> Value
forall a b. (a -> b) -> a -> b
$ [Value] -> Array
forall a. [a] -> Vector a
Vector.fromList [Value]
redeemerList

  friendlyRedeemerInfo
    :: Ledger.Tx C.TopTx (ShelleyLedgerEra era)
    -> Ledger.PlutusPurpose Ledger.AsIx (ShelleyLedgerEra era)
    -> (Ledger.Data (ShelleyLedgerEra era), ExUnits)
    -> Aeson.Value
  friendlyRedeemerInfo :: Tx TopTx (ShelleyLedgerEra era)
-> PlutusPurpose AsIx (ShelleyLedgerEra era)
-> (Data (ShelleyLedgerEra era), ExUnits)
-> Value
friendlyRedeemerInfo Tx TopTx (ShelleyLedgerEra era)
tx PlutusPurpose AsIx (ShelleyLedgerEra era)
redeemerPurpose (Data (ShelleyLedgerEra era)
redeemerData, ExUnits
exUnits) =
    AlonzoEraOnwards era
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall era a.
AlonzoEraOnwards era -> (AlonzoEraOnwardsConstraints era => a) -> a
alonzoEraOnwardsConstraints AlonzoEraOnwards era
aeo ((AlonzoEraOnwardsConstraints era => Value) -> Value)
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$ do
      let inputNotFoundError :: Value
inputNotFoundError =
            [(Key, Value)] -> Value
Aeson.object
              [ Key
"error" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
Aeson.String (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"Could not find corresponding input to " String -> String -> String
forall a. [a] -> [a] -> [a]
++ PlutusPurpose AsIx (ShelleyLedgerEra era) -> String
forall a. Show a => a -> String
show PlutusPurpose AsIx (ShelleyLedgerEra era)
redeemerPurpose)
              ]
          mCorrespondingInput :: Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
mCorrespondingInput = StrictMaybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
-> Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (StrictMaybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
 -> Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era)))
-> StrictMaybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
-> Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
forall a b. (a -> b) -> a -> b
$ TxBody TopTx (ShelleyLedgerEra era)
-> PlutusPurpose AsIx (ShelleyLedgerEra era)
-> StrictMaybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
forall era (l :: TxLevel).
AlonzoEraTxBody era =>
TxBody l era
-> PlutusPurpose AsIx era
-> StrictMaybe (PlutusPurpose AsIxItem era)
forall (l :: TxLevel).
TxBody l (ShelleyLedgerEra era)
-> PlutusPurpose AsIx (ShelleyLedgerEra era)
-> StrictMaybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
Ledger.redeemerPointerInverse (Tx TopTx (ShelleyLedgerEra era)
tx Tx TopTx (ShelleyLedgerEra era)
-> Getting
     (TxBody TopTx (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
     (TxBody TopTx (ShelleyLedgerEra era))
-> TxBody TopTx (ShelleyLedgerEra era)
forall s a. s -> Getting a s a -> a
^. Getting
  (TxBody TopTx (ShelleyLedgerEra era))
  (Tx TopTx (ShelleyLedgerEra era))
  (TxBody TopTx (ShelleyLedgerEra era))
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxBody l era)
forall (l :: TxLevel).
Lens'
  (Tx l (ShelleyLedgerEra era)) (TxBody l (ShelleyLedgerEra era))
Ledger.bodyTxL) PlutusPurpose AsIx (ShelleyLedgerEra era)
redeemerPurpose
          mFriendlyPurposeResult :: Maybe Value
mFriendlyPurposeResult = AlonzoEraOnwards era
-> PlutusPurpose AsIxItem (ShelleyLedgerEra era) -> Value
friendlyPurpose AlonzoEraOnwards era
aeo (PlutusPurpose AsIxItem (ShelleyLedgerEra era) -> Value)
-> Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
-> Maybe Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (PlutusPurpose AsIxItem (ShelleyLedgerEra era))
mCorrespondingInput
       in [(Key, Value)] -> Value
object
            [ Key
"purpose" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value -> Maybe Value -> Value
forall a. a -> Maybe a -> a
fromMaybe Value
inputNotFoundError Maybe Value
mFriendlyPurposeResult
            , Key
"redeemer" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Data (ShelleyLedgerEra era) -> ExUnits -> Value
friendlyRedeemer Data (ShelleyLedgerEra era)
redeemerData ExUnits
exUnits
            ]

  friendlyRedeemer :: Ledger.Data (ShelleyLedgerEra era) -> ExUnits -> Aeson.Value
  friendlyRedeemer :: Data (ShelleyLedgerEra era) -> ExUnits -> Value
friendlyRedeemer Data (ShelleyLedgerEra era)
scriptData ExUnits{exUnitsSteps :: ExUnits -> Natural
exUnitsSteps = Natural
exSteps, exUnitsMem :: ExUnits -> Natural
exUnitsMem = Natural
exMemUnits} =
    [(Key, Value)] -> Value
object
      [ Key
"data" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
Aeson.String (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Data -> String
forall a. Show a => a -> String
show (Data -> String) -> Data -> String
forall a b. (a -> b) -> a -> b
$ Data (ShelleyLedgerEra era) -> Data
forall era. Data era -> Data
Ledger.unData Data (ShelleyLedgerEra era)
scriptData)
      , Key
"execution units"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
            [ Key
"steps" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Scientific -> Value
Aeson.Number (Natural -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
exSteps)
            , Key
"memory" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Scientific -> Value
Aeson.Number (Natural -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
exMemUnits)
            ]
      ]

  friendlyPurpose
    :: AlonzoEraOnwards era -> Ledger.PlutusPurpose L.AsIxItem (ShelleyLedgerEra era) -> Aeson.Value
  friendlyPurpose :: AlonzoEraOnwards era
-> PlutusPurpose AsIxItem (ShelleyLedgerEra era) -> Value
friendlyPurpose AlonzoEraOnwards era
AlonzoEraOnwardsAlonzo PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose =
    case PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose of
      Ledger.AlonzoSpending (L.AsIxItem Word32
_ TxIn
sp) -> EraIndependentPlutusScriptPurpose -> Value -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Spending (TxIn -> Value
friendlyInput TxIn
sp)
      Ledger.AlonzoMinting (L.AsIxItem Word32
_ PolicyID
mp) -> EraIndependentPlutusScriptPurpose -> PolicyID -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Minting PolicyID
mp
      Ledger.AlonzoCertifying (L.AsIxItem Word32
_ ShelleyTxCert AlonzoEra
cp) -> EraIndependentPlutusScriptPurpose
-> ShelleyTxCert AlonzoEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Certifying ShelleyTxCert AlonzoEra
cp
      Ledger.AlonzoRewarding (L.AsIxItem Word32
_ AccountAddress
rp) -> EraIndependentPlutusScriptPurpose -> AccountAddress -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Rewarding AccountAddress
rp
  friendlyPurpose AlonzoEraOnwards era
AlonzoEraOnwardsBabbage PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose =
    case PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose of
      Ledger.AlonzoSpending (L.AsIxItem Word32
_ TxIn
sp) -> EraIndependentPlutusScriptPurpose -> Value -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Spending (TxIn -> Value
friendlyInput TxIn
sp)
      Ledger.AlonzoMinting (L.AsIxItem Word32
_ PolicyID
mp) -> EraIndependentPlutusScriptPurpose -> PolicyID -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Minting PolicyID
mp
      Ledger.AlonzoCertifying (L.AsIxItem Word32
_ ShelleyTxCert BabbageEra
cp) -> EraIndependentPlutusScriptPurpose
-> ShelleyTxCert BabbageEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Certifying ShelleyTxCert BabbageEra
cp
      Ledger.AlonzoRewarding (L.AsIxItem Word32
_ AccountAddress
rp) -> EraIndependentPlutusScriptPurpose -> AccountAddress -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Rewarding AccountAddress
rp
  friendlyPurpose AlonzoEraOnwards era
AlonzoEraOnwardsConway PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose =
    case PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose of
      Ledger.ConwaySpending (L.AsIxItem Word32
_ TxIn
sp) -> EraIndependentPlutusScriptPurpose -> Value -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Spending (TxIn -> Value
friendlyInput TxIn
sp)
      Ledger.ConwayMinting (L.AsIxItem Word32
_ PolicyID
mp) -> EraIndependentPlutusScriptPurpose -> PolicyID -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Minting PolicyID
mp
      Ledger.ConwayCertifying (L.AsIxItem Word32
_ ConwayTxCert ConwayEra
cp) -> EraIndependentPlutusScriptPurpose
-> ConwayTxCert ConwayEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Certifying ConwayTxCert ConwayEra
cp
      Ledger.ConwayRewarding (L.AsIxItem Word32
_ AccountAddress
rp) -> EraIndependentPlutusScriptPurpose -> AccountAddress -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Rewarding AccountAddress
rp
      Ledger.ConwayVoting (L.AsIxItem Word32
_ Voter
vp) -> EraIndependentPlutusScriptPurpose -> Voter -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Voting Voter
vp
      Ledger.ConwayProposing (L.AsIxItem Word32
_ ProposalProcedure ConwayEra
pp) -> EraIndependentPlutusScriptPurpose
-> ProposalProcedure ConwayEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Proposing ProposalProcedure ConwayEra
pp
  friendlyPurpose AlonzoEraOnwards era
AlonzoEraOnwardsDijkstra PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose = do
    let era' :: Era era
era' = Maybe (Era era) -> Era era
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Era era) -> Era era) -> Maybe (Era era) -> Era era
forall a b. (a -> b) -> a -> b
$ CardanoEra era -> Maybe (Era era)
forall (eon :: * -> *) era.
Eon eon =>
CardanoEra era -> Maybe (eon era)
forEraMaybeEon (Era era -> CardanoEra era
forall era. Era era -> CardanoEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert Era era
era)
    Era era -> (EraCommonConstraints era => Value) -> Value
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era' ((EraCommonConstraints era => Value) -> Value)
-> (EraCommonConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$
      case PlutusPurpose AsIxItem (ShelleyLedgerEra era)
purpose of
        Ledger.DijkstraSpending (L.AsIxItem Word32
_ TxIn
sp) -> EraIndependentPlutusScriptPurpose -> Value -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Spending (TxIn -> Value
friendlyInput TxIn
sp)
        Ledger.DijkstraMinting (L.AsIxItem Word32
_ PolicyID
mp) -> EraIndependentPlutusScriptPurpose -> PolicyID -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Minting PolicyID
mp
        Ledger.DijkstraCertifying (L.AsIxItem Word32
_ DijkstraTxCert DijkstraEra
cp) -> EraIndependentPlutusScriptPurpose
-> DijkstraTxCert DijkstraEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Certifying DijkstraTxCert DijkstraEra
cp
        Ledger.DijkstraRewarding (L.AsIxItem Word32
_ AccountAddress
rp) -> EraIndependentPlutusScriptPurpose -> AccountAddress -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Rewarding AccountAddress
rp
        Ledger.DijkstraVoting (L.AsIxItem Word32
_ Voter
vp) -> EraIndependentPlutusScriptPurpose -> Voter -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Voting Voter
vp
        Ledger.DijkstraProposing (L.AsIxItem Word32
_ ProposalProcedure DijkstraEra
pp) -> EraIndependentPlutusScriptPurpose
-> ProposalProcedure DijkstraEra -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Proposing ProposalProcedure DijkstraEra
pp
        Ledger.DijkstraGuarding (L.AsIxItem Word32
_ ScriptHash
pp) -> EraIndependentPlutusScriptPurpose -> ScriptHash -> Value
forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Guarding ScriptHash
pp
  friendlyInput :: Ledger.TxIn -> Aeson.Value
  friendlyInput :: TxIn -> Value
friendlyInput (Ledger.TxIn (Ledger.TxId SafeHash EraIndependentTxBody
txidHash) TxIx
ix) =
    Text -> Value
Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$
      String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
        Text -> String
T.unpack (Hash HASH EraIndependentTxBody -> Text
forall h a. Hash h a -> Text
hashToTextAsHex (SafeHash EraIndependentTxBody -> Hash HASH EraIndependentTxBody
forall i. SafeHash i -> Hash HASH i
extractHash SafeHash EraIndependentTxBody
txidHash)) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (TxIx -> Int
Ledger.txIxToInt TxIx
ix)

  addLabelToPurpose
    :: ToJSON v
    => EraIndependentPlutusScriptPurpose
    -> v
    -> Aeson.Value
  addLabelToPurpose :: forall v.
ToJSON v =>
EraIndependentPlutusScriptPurpose -> v -> Value
addLabelToPurpose EraIndependentPlutusScriptPurpose
Spending v
sp = [(Key, Value)] -> Value
Aeson.object [Key
"spending script witnessed input" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
sp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Minting v
mp = [(Key, Value)] -> Value
Aeson.object [Key
"minting currency with policy id" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
mp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Certifying v
cp = [(Key, Value)] -> Value
Aeson.object [Key
"validating certificate with script credentials" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
cp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Rewarding v
rp = [(Key, Value)] -> Value
Aeson.object [Key
"withdrawing reward from script address" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
rp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Voting v
vp = [(Key, Value)] -> Value
Aeson.object [Key
"voting using script protected voter credentials" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
vp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Proposing v
pp = [(Key, Value)] -> Value
Aeson.object [Key
"submitting a proposal following proposal policy" Key -> v -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
pp]
  addLabelToPurpose EraIndependentPlutusScriptPurpose
Guarding v
_ = String -> Value
forall a. HasCallStack => String -> a
error String
"TODO Dijkstra"

  friendlyScriptData :: Ledger.Tx C.TopTx (ShelleyLedgerEra era) -> Aeson.Value
  friendlyScriptData :: Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyScriptData Tx TopTx (ShelleyLedgerEra era)
tx =
    AlonzoEraOnwards era
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall era a.
AlonzoEraOnwards era -> (AlonzoEraOnwardsConstraints era => a) -> a
alonzoEraOnwardsConstraints AlonzoEraOnwards era
aeo ((AlonzoEraOnwardsConstraints era => Value) -> Value)
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$ do
      Array -> Value
Aeson.Array (Array -> Value) -> Array -> Value
forall a b. (a -> b) -> a -> b
$
        [Value] -> Array
forall a. [a] -> Vector a
Vector.fromList ([Value] -> Array) -> [Value] -> Array
forall a b. (a -> b) -> a -> b
$
          [ Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$
              [(Key, Value)] -> Object
forall v. [(Key, v)] -> KeyMap v
KeyMap.fromList
                [ Key
"script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
scriptHash
                , Key
"script data" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Script (ShelleyLedgerEra era) -> Value
forall era.
AlonzoEraOnwardsConstraints era =>
Script (ShelleyLedgerEra era) -> Value
friendlyScript Script (ShelleyLedgerEra era)
scriptData
                ]
          | (ScriptHash
scriptHash, Script (ShelleyLedgerEra era)
scriptData) <- Map ScriptHash (Script (ShelleyLedgerEra era))
-> [(ScriptHash, Script (ShelleyLedgerEra era))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map ScriptHash (Script (ShelleyLedgerEra era))
 -> [(ScriptHash, Script (ShelleyLedgerEra era))])
-> Map ScriptHash (Script (ShelleyLedgerEra era))
-> [(ScriptHash, Script (ShelleyLedgerEra era))]
forall a b. (a -> b) -> a -> b
$ Tx TopTx (ShelleyLedgerEra era)
tx Tx TopTx (ShelleyLedgerEra era)
-> Getting
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
     (Tx TopTx (ShelleyLedgerEra era))
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
-> Map ScriptHash (Script (ShelleyLedgerEra era))
forall s a. s -> Getting a s a -> a
^. (TxWits (ShelleyLedgerEra era)
 -> Const
      (Map ScriptHash (Script (ShelleyLedgerEra era)))
      (TxWits (ShelleyLedgerEra era)))
-> Tx TopTx (ShelleyLedgerEra era)
-> Const
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
     (Tx TopTx (ShelleyLedgerEra era))
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxWits era)
forall (l :: TxLevel).
Lens' (Tx l (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era))
Ledger.witsTxL ((TxWits (ShelleyLedgerEra era)
  -> Const
       (Map ScriptHash (Script (ShelleyLedgerEra era)))
       (TxWits (ShelleyLedgerEra era)))
 -> Tx TopTx (ShelleyLedgerEra era)
 -> Const
      (Map ScriptHash (Script (ShelleyLedgerEra era)))
      (Tx TopTx (ShelleyLedgerEra era)))
-> ((Map ScriptHash (Script (ShelleyLedgerEra era))
     -> Const
          (Map ScriptHash (Script (ShelleyLedgerEra era)))
          (Map ScriptHash (Script (ShelleyLedgerEra era))))
    -> TxWits (ShelleyLedgerEra era)
    -> Const
         (Map ScriptHash (Script (ShelleyLedgerEra era)))
         (TxWits (ShelleyLedgerEra era)))
-> Getting
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
     (Tx TopTx (ShelleyLedgerEra era))
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map ScriptHash (Script (ShelleyLedgerEra era))
 -> Const
      (Map ScriptHash (Script (ShelleyLedgerEra era)))
      (Map ScriptHash (Script (ShelleyLedgerEra era))))
-> TxWits (ShelleyLedgerEra era)
-> Const
     (Map ScriptHash (Script (ShelleyLedgerEra era)))
     (TxWits (ShelleyLedgerEra era))
forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
Lens'
  (TxWits (ShelleyLedgerEra era))
  (Map ScriptHash (Script (ShelleyLedgerEra era)))
Ledger.scriptTxWitsL
          ]

  friendlyDats :: Ledger.Tx C.TopTx (ShelleyLedgerEra era) -> Aeson.Value
  friendlyDats :: Tx TopTx (ShelleyLedgerEra era) -> Value
friendlyDats Tx TopTx (ShelleyLedgerEra era)
tx =
    AlonzoEraOnwards era
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall era a.
AlonzoEraOnwards era -> (AlonzoEraOnwardsConstraints era => a) -> a
alonzoEraOnwardsConstraints AlonzoEraOnwards era
aeo ((AlonzoEraOnwardsConstraints era => Value) -> Value)
-> (AlonzoEraOnwardsConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$
      let Ledger.TxDats Map (SafeHash EraIndependentData) (Data (ShelleyLedgerEra era))
dats = Tx TopTx (ShelleyLedgerEra era)
tx Tx TopTx (ShelleyLedgerEra era)
-> Getting
     (TxDats (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
     (TxDats (ShelleyLedgerEra era))
-> TxDats (ShelleyLedgerEra era)
forall s a. s -> Getting a s a -> a
^. (TxWits (ShelleyLedgerEra era)
 -> Const
      (TxDats (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
-> Tx TopTx (ShelleyLedgerEra era)
-> Const
     (TxDats (ShelleyLedgerEra era)) (Tx TopTx (ShelleyLedgerEra era))
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxWits era)
forall (l :: TxLevel).
Lens' (Tx l (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era))
Ledger.witsTxL ((TxWits (ShelleyLedgerEra era)
  -> Const
       (TxDats (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
 -> Tx TopTx (ShelleyLedgerEra era)
 -> Const
      (TxDats (ShelleyLedgerEra era)) (Tx TopTx (ShelleyLedgerEra era)))
-> ((TxDats (ShelleyLedgerEra era)
     -> Const
          (TxDats (ShelleyLedgerEra era)) (TxDats (ShelleyLedgerEra era)))
    -> TxWits (ShelleyLedgerEra era)
    -> Const
         (TxDats (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era)))
-> Getting
     (TxDats (ShelleyLedgerEra era))
     (Tx TopTx (ShelleyLedgerEra era))
     (TxDats (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxDats (ShelleyLedgerEra era)
 -> Const
      (TxDats (ShelleyLedgerEra era)) (TxDats (ShelleyLedgerEra era)))
-> TxWits (ShelleyLedgerEra era)
-> Const
     (TxDats (ShelleyLedgerEra era)) (TxWits (ShelleyLedgerEra era))
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens'
  (TxWits (ShelleyLedgerEra era)) (TxDats (ShelleyLedgerEra era))
Ledger.datsTxWitsL
       in Array -> Value
Aeson.Array (Array -> Value) -> Array -> Value
forall a b. (a -> b) -> a -> b
$
            [Value] -> Array
forall a. [a] -> Vector a
Vector.fromList ([Value] -> Array) -> [Value] -> Array
forall a b. (a -> b) -> a -> b
$
              [ Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$
                  [(Key, Value)] -> Object
forall v. [(Key, v)] -> KeyMap v
KeyMap.fromList
                    [ Key
"datum hash" Key -> SafeHash EraIndependentData -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SafeHash EraIndependentData
datHash
                    , Key
"datum" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Data (ShelleyLedgerEra era) -> Value
forall era.
AlonzoEraOnwardsConstraints era =>
Data (ShelleyLedgerEra era) -> Value
friendlyDatum Data (ShelleyLedgerEra era)
dat
                    ]
              | (SafeHash EraIndependentData
datHash, Data (ShelleyLedgerEra era)
dat) <- Map (SafeHash EraIndependentData) (Data (ShelleyLedgerEra era))
-> [(SafeHash EraIndependentData, Data (ShelleyLedgerEra era))]
forall k a. Map k a -> [(k, a)]
Map.toList Map (SafeHash EraIndependentData) (Data (ShelleyLedgerEra era))
dats
              ]

-- | Create a friendly JSON out of a script
friendlyScript
  :: AlonzoEraOnwardsConstraints era => Ledger.Script (ShelleyLedgerEra era) -> Aeson.Value
friendlyScript :: forall era.
AlonzoEraOnwardsConstraints era =>
Script (ShelleyLedgerEra era) -> Value
friendlyScript Script (ShelleyLedgerEra era)
script = Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$
  [(Key, Value)] -> Object
forall v. [(Key, v)] -> KeyMap v
KeyMap.fromList ([(Key, Value)] -> Object) -> [(Key, Value)] -> Object
forall a b. (a -> b) -> a -> b
$
    case Script (ShelleyLedgerEra era)
-> Maybe (NativeScript (ShelleyLedgerEra era))
forall era. EraScript era => Script era -> Maybe (NativeScript era)
Ledger.getNativeScript Script (ShelleyLedgerEra era)
script of
      Just NativeScript (ShelleyLedgerEra era)
nativeScript ->
        [ (Key
"type", Value
"native")
        , (Key
"script", Text -> Value
Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ NativeScript (ShelleyLedgerEra era) -> String
forall era. AllegraEraScript era => NativeScript era -> String
Ledger.showTimelock NativeScript (ShelleyLedgerEra era)
nativeScript)
        ]
      Maybe (NativeScript (ShelleyLedgerEra era))
Nothing ->
        ( case Script (ShelleyLedgerEra era)
-> Maybe (PlutusScript (ShelleyLedgerEra era))
forall era.
AlonzoEraScript era =>
Script era -> Maybe (PlutusScript era)
Ledger.toPlutusScript Script (ShelleyLedgerEra era)
script of
            Just PlutusScript (ShelleyLedgerEra era)
plutusScript ->
              PlutusScript (ShelleyLedgerEra era)
-> (forall (l :: Language).
    PlutusLanguage l =>
    Plutus l -> [(Key, Value)])
-> [(Key, Value)]
forall era a.
AlonzoEraScript era =>
PlutusScript era
-> (forall (l :: Language). PlutusLanguage l => Plutus l -> a) -> a
forall a.
PlutusScript (ShelleyLedgerEra era)
-> (forall (l :: Language). PlutusLanguage l => Plutus l -> a) -> a
Ledger.withPlutusScript PlutusScript (ShelleyLedgerEra era)
plutusScript ((forall (l :: Language).
  PlutusLanguage l =>
  Plutus l -> [(Key, Value)])
 -> [(Key, Value)])
-> (forall (l :: Language).
    PlutusLanguage l =>
    Plutus l -> [(Key, Value)])
-> [(Key, Value)]
forall a b. (a -> b) -> a -> b
$
                Language -> Plutus l -> [(Key, Value)]
forall (l :: Language). Language -> Plutus l -> [(Key, Value)]
friendlyPlutusScript (Language -> Plutus l -> [(Key, Value)])
-> Language -> Plutus l -> [(Key, Value)]
forall a b. (a -> b) -> a -> b
$
                  PlutusScript (ShelleyLedgerEra era) -> Language
forall era. AlonzoEraScript era => PlutusScript era -> Language
Ledger.plutusScriptLanguage PlutusScript (ShelleyLedgerEra era)
plutusScript
            Maybe (PlutusScript (ShelleyLedgerEra era))
Nothing -> [(Key
"error", Text -> Value
Aeson.String Text
"Unsupported script type")]
        )
 where
  friendlyPlutusScript :: Ledger.Language -> Ledger.Plutus l -> [(KeyMap.Key, Aeson.Value)]
  friendlyPlutusScript :: forall (l :: Language). Language -> Plutus l -> [(Key, Value)]
friendlyPlutusScript Language
language Plutus l
plutusScript =
    [ (Key
"type", Value
"plutus")
    , (Key
"plutus version", Text -> Value
Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ Language -> Text
Ledger.languageToText Language
language)
    , (Key
"script", Text -> Value
Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ PlutusBinary -> Text
forall a. ToCBOR a => a -> Text
Ledger.serializeAsHexText (PlutusBinary -> Text) -> PlutusBinary -> Text
forall a b. (a -> b) -> a -> b
$ Plutus l -> PlutusBinary
forall (l :: Language). Plutus l -> PlutusBinary
Ledger.plutusBinary Plutus l
plutusScript)
    ]

-- | Create a friendly JSON out of a datum
friendlyDatum
  :: AlonzoEraOnwardsConstraints era => Alonzo.Data (ShelleyLedgerEra era) -> Aeson.Value
friendlyDatum :: forall era.
AlonzoEraOnwardsConstraints era =>
Data (ShelleyLedgerEra era) -> Value
friendlyDatum (Alonzo.Data Data
datum) = Text -> Value
Aeson.String (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Data -> String
forall a. Show a => a -> String
show Data
datum)

friendlyTotalCollateral :: TxTotalCollateral era -> Aeson.Value
friendlyTotalCollateral :: forall era. TxTotalCollateral era -> Value
friendlyTotalCollateral TxTotalCollateral era
TxTotalCollateralNone = Value
Aeson.Null
friendlyTotalCollateral (TxTotalCollateral BabbageEraOnwards era
_ Coin
coll) = Coin -> Value
forall a. ToJSON a => a -> Value
toJSON Coin
coll

friendlyReturnCollateral
  :: ()
  => ShelleyBasedEra era
  -> TxReturnCollateral CtxTx era
  -> Aeson.Value
friendlyReturnCollateral :: forall era.
ShelleyBasedEra era -> TxReturnCollateral CtxTx era -> Value
friendlyReturnCollateral ShelleyBasedEra era
era = \case
  TxReturnCollateral CtxTx era
TxReturnCollateralNone -> Value
Aeson.Null
  TxReturnCollateral BabbageEraOnwards era
_ TxOut CtxTx era
collOut -> ShelleyBasedEra era -> TxOut CtxTx era -> Value
forall era. ShelleyBasedEra era -> TxOut CtxTx era -> Value
friendlyTxOut ShelleyBasedEra era
era TxOut CtxTx era
collOut

friendlyExtraKeyWits :: TxExtraKeyWitnesses era -> Aeson.Value
friendlyExtraKeyWits :: forall era. TxExtraKeyWitnesses era -> Value
friendlyExtraKeyWits = \case
  TxExtraKeyWitnesses era
TxExtraKeyWitnessesNone -> Value
Null
  TxExtraKeyWitnesses AlonzoEraOnwards era
_supported [Hash PaymentKey]
paymentKeyHashes -> [Hash PaymentKey] -> Value
forall a. ToJSON a => a -> Value
toJSON [Hash PaymentKey]
paymentKeyHashes

friendlyValidityRange
  :: ShelleyBasedEra era
  -> (TxValidityLowerBound era, TxValidityUpperBound era)
  -> Aeson.Value
friendlyValidityRange :: forall era.
ShelleyBasedEra era
-> (TxValidityLowerBound era, TxValidityUpperBound era) -> Value
friendlyValidityRange ShelleyBasedEra era
era = \case
  (TxValidityLowerBound era
lowerBound, TxValidityUpperBound era
upperBound)
    | Bool
isLowerBoundSupported Bool -> Bool -> Bool
|| Bool
isUpperBoundSupported ->
        [(Key, Value)] -> Value
object
          [ Key
"lower bound"
              Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= case TxValidityLowerBound era
lowerBound of
                TxValidityLowerBound era
TxValidityNoLowerBound -> Value
Null
                TxValidityLowerBound AllegraEraOnwards era
_ SlotNo
s -> SlotNo -> Value
forall a. ToJSON a => a -> Value
toJSON SlotNo
s
          , Key
"upper bound"
              Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= case TxValidityUpperBound era
upperBound of
                TxValidityUpperBound ShelleyBasedEra era
_ Maybe SlotNo
s -> Maybe SlotNo -> Value
forall a. ToJSON a => a -> Value
toJSON Maybe SlotNo
s
          ]
    | Bool
otherwise -> Value
Null
 where
  isLowerBoundSupported :: Bool
isLowerBoundSupported = Maybe (SlotNo -> TxValidityLowerBound era) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (SlotNo -> TxValidityLowerBound era) -> Bool)
-> Maybe (SlotNo -> TxValidityLowerBound era) -> Bool
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era
-> (AllegraEraOnwards era -> SlotNo -> TxValidityLowerBound era)
-> Maybe (SlotNo -> TxValidityLowerBound era)
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> (eon era -> a) -> Maybe a
forShelleyBasedEraInEonMaybe ShelleyBasedEra era
era AllegraEraOnwards era -> SlotNo -> TxValidityLowerBound era
forall era.
AllegraEraOnwards era -> SlotNo -> TxValidityLowerBound era
TxValidityLowerBound
  isUpperBoundSupported :: Bool
isUpperBoundSupported = Maybe (Maybe SlotNo -> TxValidityUpperBound era) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (Maybe SlotNo -> TxValidityUpperBound era) -> Bool)
-> Maybe (Maybe SlotNo -> TxValidityUpperBound era) -> Bool
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era
-> (ShelleyBasedEra era
    -> Maybe SlotNo -> TxValidityUpperBound era)
-> Maybe (Maybe SlotNo -> TxValidityUpperBound era)
forall (eon :: * -> *) era a.
Eon eon =>
ShelleyBasedEra era -> (eon era -> a) -> Maybe a
forShelleyBasedEraInEonMaybe ShelleyBasedEra era
era ShelleyBasedEra era -> Maybe SlotNo -> TxValidityUpperBound era
forall era.
ShelleyBasedEra era -> Maybe SlotNo -> TxValidityUpperBound era
TxValidityUpperBound

friendlyWithdrawals :: TxWithdrawals ViewTx era -> Aeson.Value
friendlyWithdrawals :: forall era. TxWithdrawals ViewTx era -> Value
friendlyWithdrawals TxWithdrawals ViewTx era
TxWithdrawalsNone = Value
Null
friendlyWithdrawals (TxWithdrawals ShelleyBasedEra era
_ [(StakeAddress, Coin,
  BuildTxWith ViewTx (Witness WitCtxStake era))]
withdrawals) =
  [Value] -> Value
array
    [ [(Key, Value)] -> Value
object ([(Key, Value)] -> Value) -> [(Key, Value)] -> Value
forall a b. (a -> b) -> a -> b
$
        Key
"address" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StakeAddress -> Text
forall addr. SerialiseAddress addr => addr -> Text
serialiseAddress StakeAddress
addr
          (Key, Value) -> [(Key, Value)] -> [(Key, Value)]
forall a. a -> [a] -> [a]
: Key
"amount" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin -> Value
friendlyLovelace Coin
amount
          (Key, Value) -> [(Key, Value)] -> [(Key, Value)]
forall a. a -> [a] -> [a]
: StakeAddress -> [(Key, Value)]
friendlyStakeAddress StakeAddress
addr
    | (StakeAddress
addr, Coin
amount, BuildTxWith ViewTx (Witness WitCtxStake era)
_) <- [(StakeAddress, Coin,
  BuildTxWith ViewTx (Witness WitCtxStake era))]
withdrawals
    ]

friendlyStakeAddress :: StakeAddress -> [Aeson.Pair]
friendlyStakeAddress :: StakeAddress -> [(Key, Value)]
friendlyStakeAddress (StakeAddress Network
net Credential Staking
cred) =
  [ Key
"network" Key -> Network -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Network
net
  , Credential Staking -> (Key, Value)
friendlyStakeCredential Credential Staking
cred
  ]

friendlyTxOut :: ShelleyBasedEra era -> TxOut CtxTx era -> Aeson.Value
friendlyTxOut :: forall era. ShelleyBasedEra era -> TxOut CtxTx era -> Value
friendlyTxOut ShelleyBasedEra era
sbe (TxOut AddressInEra era
addr TxOutValue era
amount TxOutDatum CtxTx era
mdatum ReferenceScript era
script) =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => Value) -> Value
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => Value) -> Value)
-> (ShelleyBasedEraConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$
    [(Key, Value)] -> Value
object ([(Key, Value)] -> Value) -> [(Key, Value)] -> Value
forall a b. (a -> b) -> a -> b
$
      case AddressInEra era
addr of
        AddressInEra AddressTypeInEra addrtype era
ByronAddressInAnyEra Address addrtype
byronAdr ->
          [ Key
"address era" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
String Text
"Byron"
          , Key
"address" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Address addrtype -> Text
forall addr. SerialiseAddress addr => addr -> Text
serialiseAddress Address addrtype
byronAdr
          , Key
"amount" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era -> Value
forall era. TxOutValue era -> Value
friendlyTxOutValue TxOutValue era
amount
          ]
        AddressInEra (ShelleyAddressInEra ShelleyBasedEra era
_) saddr :: Address addrtype
saddr@(ShelleyAddress Network
net Credential Payment
cred StakeReference
stake) ->
          let preAlonzo :: [(Key, Value)]
preAlonzo =
                PaymentCredential -> (Key, Value)
friendlyPaymentCredential (Credential Payment -> PaymentCredential
fromShelleyPaymentCredential Credential Payment
cred)
                  (Key, Value) -> [(Key, Value)] -> [(Key, Value)]
forall a. a -> [a] -> [a]
: [ Key
"address era" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
Aeson.String Text
"Shelley"
                    , Key
"network" Key -> Network -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Network
net
                    , Key
"address" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Address addrtype -> Text
forall addr. SerialiseAddress addr => addr -> Text
serialiseAddress Address addrtype
saddr
                    , Key
"amount" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era -> Value
forall era. TxOutValue era -> Value
friendlyTxOutValue TxOutValue era
amount
                    , Key
"stake reference" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StakeAddressReference -> Value
friendlyStakeReference (StakeReference -> StakeAddressReference
fromShelleyStakeReference StakeReference
stake)
                    ]
              datum :: [(Key, Value)]
datum = [Key
"datum" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
d | Value
d <- Maybe Value -> [Value]
forall a. Maybe a -> [a]
maybeToList (Maybe Value -> [Value]) -> Maybe Value -> [Value]
forall a b. (a -> b) -> a -> b
$ TxOutDatum CtxTx era -> Maybe Value
forall era. TxOutDatum CtxTx era -> Maybe Value
renderDatum TxOutDatum CtxTx era
mdatum]
              sinceAlonzo :: [(Key, Value)]
sinceAlonzo = [Key
"reference script" Key -> ReferenceScript era -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ReferenceScript era
script]
           in [(Key, Value)]
preAlonzo [(Key, Value)] -> [(Key, Value)] -> [(Key, Value)]
forall a. [a] -> [a] -> [a]
++ [(Key, Value)]
datum [(Key, Value)] -> [(Key, Value)] -> [(Key, Value)]
forall a. [a] -> [a] -> [a]
++ [(Key, Value)]
sinceAlonzo
 where
  renderDatum :: TxOutDatum CtxTx era -> Maybe Aeson.Value
  renderDatum :: forall era. TxOutDatum CtxTx era -> Maybe Value
renderDatum = \case
    TxOutDatum CtxTx era
TxOutDatumNone -> Maybe Value
forall a. Maybe a
Nothing
    TxOutDatumHash AlonzoEraOnwards era
_ Hash ScriptData
h -> Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Maybe Value) -> Value -> Maybe Value
forall a b. (a -> b) -> a -> b
$ Hash ScriptData -> Value
forall a. ToJSON a => a -> Value
toJSON Hash ScriptData
h
    TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
sData -> Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Maybe Value) -> Value -> Maybe Value
forall a b. (a -> b) -> a -> b
$ ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
sData
    TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
sData -> Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Maybe Value) -> Value -> Maybe Value
forall a b. (a -> b) -> a -> b
$ ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
sData

friendlyStakeReference :: StakeAddressReference -> Aeson.Value
friendlyStakeReference :: StakeAddressReference -> Value
friendlyStakeReference = \case
  StakeAddressReference
NoStakeAddress -> Value
Null
  StakeAddressByPointer StakeAddressPointer
ptr -> Text -> Value
String (StakeAddressPointer -> Text
forall a. Show a => a -> Text
textShow StakeAddressPointer
ptr)
  StakeAddressByValue StakeCredential
cred -> [(Key, Value)] -> Value
object [Credential Staking -> (Key, Value)
friendlyStakeCredential (Credential Staking -> (Key, Value))
-> Credential Staking -> (Key, Value)
forall a b. (a -> b) -> a -> b
$ StakeCredential -> Credential Staking
toShelleyStakeCredential StakeCredential
cred]

friendlyUpdateProposal :: TxUpdateProposal era -> Aeson.Value
friendlyUpdateProposal :: forall era. TxUpdateProposal era -> Value
friendlyUpdateProposal = \case
  TxUpdateProposal era
TxUpdateProposalNone -> Value
Null
  TxUpdateProposal ShelleyToBabbageEra era
_ (UpdateProposal Map (Hash GenesisKey) ProtocolParametersUpdate
parameterUpdates EpochNo
epoch) ->
    [(Key, Value)] -> Value
object
      [ Key
"epoch" Key -> EpochNo -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EpochNo
epoch
      , Key
"updates"
          Key -> [Value] -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [ [(Key, Value)] -> Value
object
                 [ Key
"genesis key hash" Key -> Hash GenesisKey -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash GenesisKey
genesisKeyHash
                 , Key
"update" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ProtocolParametersUpdate -> Value
friendlyProtocolParametersUpdate ProtocolParametersUpdate
parameterUpdate
                 ]
             | (Hash GenesisKey
genesisKeyHash, ProtocolParametersUpdate
parameterUpdate) <- Map (Hash GenesisKey) ProtocolParametersUpdate
-> [(Hash GenesisKey, ProtocolParametersUpdate)]
forall k a. Map k a -> [(k, a)]
Map.assocs Map (Hash GenesisKey) ProtocolParametersUpdate
parameterUpdates
             ]
      ]

friendlyProtocolParametersUpdate :: ProtocolParametersUpdate -> Aeson.Value
friendlyProtocolParametersUpdate :: ProtocolParametersUpdate -> Value
friendlyProtocolParametersUpdate
  ProtocolParametersUpdate
    { Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , Maybe Rational
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateDecentralization
    , Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
    , Maybe Word16
protocolUpdateMaxBlockHeaderSize :: Maybe Word16
protocolUpdateMaxBlockHeaderSize :: ProtocolParametersUpdate -> Maybe Word16
protocolUpdateMaxBlockHeaderSize
    , Maybe Word32
protocolUpdateMaxBlockBodySize :: Maybe Word32
protocolUpdateMaxBlockBodySize :: ProtocolParametersUpdate -> Maybe Word32
protocolUpdateMaxBlockBodySize
    , Maybe Word32
protocolUpdateMaxTxSize :: Maybe Word32
protocolUpdateMaxTxSize :: ProtocolParametersUpdate -> Maybe Word32
protocolUpdateMaxTxSize
    , Maybe Coin
protocolUpdateTxFeeFixed :: Maybe Coin
protocolUpdateTxFeeFixed :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateTxFeeFixed
    , Maybe Coin
protocolUpdateTxFeePerByte :: Maybe Coin
protocolUpdateTxFeePerByte :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateTxFeePerByte
    , Maybe Coin
protocolUpdateMinUTxOValue :: Maybe Coin
protocolUpdateMinUTxOValue :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateMinUTxOValue
    , Maybe Coin
protocolUpdateStakeAddressDeposit :: Maybe Coin
protocolUpdateStakeAddressDeposit :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateStakeAddressDeposit
    , Maybe Coin
protocolUpdateStakePoolDeposit :: Maybe Coin
protocolUpdateStakePoolDeposit :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateStakePoolDeposit
    , Maybe Coin
protocolUpdateMinPoolCost :: Maybe Coin
protocolUpdateMinPoolCost :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateMinPoolCost
    , Maybe EpochInterval
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochInterval
protocolUpdatePoolRetireMaxEpoch :: ProtocolParametersUpdate -> Maybe EpochInterval
protocolUpdatePoolRetireMaxEpoch
    , Maybe Word16
protocolUpdateStakePoolTargetNum :: Maybe Word16
protocolUpdateStakePoolTargetNum :: ProtocolParametersUpdate -> Maybe Word16
protocolUpdateStakePoolTargetNum
    , Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence
    , Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion
    , Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut
    , Maybe Word16
protocolUpdateCollateralPercent :: Maybe Word16
protocolUpdateCollateralPercent :: ProtocolParametersUpdate -> Maybe Word16
protocolUpdateCollateralPercent
    , Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
    , Maybe Word16
protocolUpdateMaxCollateralInputs :: Maybe Word16
protocolUpdateMaxCollateralInputs :: ProtocolParametersUpdate -> Maybe Word16
protocolUpdateMaxCollateralInputs
    , Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
    , Maybe Word32
protocolUpdateMaxValueSize :: Maybe Word32
protocolUpdateMaxValueSize :: ProtocolParametersUpdate -> Maybe Word32
protocolUpdateMaxValueSize
    , Maybe ExecutionUnitPrices
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices :: ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdatePrices
    , Maybe Coin
protocolUpdateUTxOCostPerByte :: Maybe Coin
protocolUpdateUTxOCostPerByte :: ProtocolParametersUpdate -> Maybe Coin
protocolUpdateUTxOCostPerByte
    } =
    [(Key, Value)] -> Value
object ([(Key, Value)] -> Value)
-> ([Maybe (Key, Value)] -> [(Key, Value)])
-> [Maybe (Key, Value)]
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe (Key, Value)] -> [(Key, Value)]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (Key, Value)] -> Value) -> [Maybe (Key, Value)] -> Value
forall a b. (a -> b) -> a -> b
$
      [ Maybe (Natural, Natural)
protocolUpdateProtocolVersion Maybe (Natural, Natural)
-> ((Natural, Natural) -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \(Natural
major, Natural
minor) ->
          Key
"protocol version" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Natural -> Text
forall a. Show a => a -> Text
textShow Natural
major Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"." Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Natural -> Text
forall a. Show a => a -> Text
textShow Natural
minor)
      , Maybe Rational
protocolUpdateDecentralization
          Maybe Rational -> (Rational -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"decentralization parameter" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (Rational -> Value) -> Rational -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value
friendlyRational
      , Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
          Maybe (Maybe PraosNonce)
-> (Maybe PraosNonce -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"extra entropy" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (Maybe PraosNonce -> Value) -> Maybe PraosNonce -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> (PraosNonce -> Value) -> Maybe PraosNonce -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Value
"reset" PraosNonce -> Value
forall a. ToJSON a => a -> Value
toJSON
      , Maybe Word16
protocolUpdateMaxBlockHeaderSize Maybe Word16 -> (Word16 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max block header size" Key -> Word16 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Word32
protocolUpdateMaxBlockBodySize Maybe Word32 -> (Word32 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max block body size" Key -> Word32 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Word32
protocolUpdateMaxTxSize Maybe Word32 -> (Word32 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max transaction size" Key -> Word32 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Coin
protocolUpdateTxFeeFixed Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"transaction fee constant" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Coin
protocolUpdateTxFeePerByte Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"transaction fee linear per byte" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Coin
protocolUpdateMinUTxOValue Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"min UTxO value" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value)) -> (Coin -> Value) -> Coin -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coin -> Value
friendlyLovelace
      , Maybe Coin
protocolUpdateStakeAddressDeposit
          Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"key registration deposit" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value)) -> (Coin -> Value) -> Coin -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coin -> Value
friendlyLovelace
      , Maybe Coin
protocolUpdateStakePoolDeposit
          Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"pool registration deposit" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value)) -> (Coin -> Value) -> Coin -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coin -> Value
friendlyLovelace
      , Maybe Coin
protocolUpdateMinPoolCost Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"min pool cost" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value)) -> (Coin -> Value) -> Coin -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coin -> Value
friendlyLovelace
      , Maybe EpochInterval
protocolUpdatePoolRetireMaxEpoch Maybe EpochInterval
-> (EpochInterval -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"pool retirement epoch boundary" Key -> EpochInterval -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Word16
protocolUpdateStakePoolTargetNum Maybe Word16 -> (Word16 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"number of pools" Key -> Word16 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Rational
protocolUpdatePoolPledgeInfluence
          Maybe Rational -> (Rational -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"pool influence" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (Rational -> Value) -> Rational -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value
friendlyRational
      , Maybe Rational
protocolUpdateMonetaryExpansion
          Maybe Rational -> (Rational -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"monetary expansion" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (Rational -> Value) -> Rational -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value
friendlyRational
      , Maybe Rational
protocolUpdateTreasuryCut Maybe Rational -> (Rational -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"treasury expansion" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (Rational -> Value) -> Rational -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value
friendlyRational
      , Maybe Word16
protocolUpdateCollateralPercent
          Maybe Word16 -> (Word16 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"collateral inputs share" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Text -> (Key, Value))
-> (Word16 -> Text) -> Word16 -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"%") (Text -> Text) -> (Word16 -> Text) -> Word16 -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Text
forall a. Show a => a -> Text
textShow
      , Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits Maybe ExecutionUnits
-> (ExecutionUnits -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max block execution units" Key -> ExecutionUnits -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Word16
protocolUpdateMaxCollateralInputs Maybe Word16 -> (Word16 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max collateral inputs" Key -> Word16 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe ExecutionUnits
protocolUpdateMaxTxExUnits Maybe ExecutionUnits
-> (ExecutionUnits -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max transaction execution units" Key -> ExecutionUnits -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe Word32
protocolUpdateMaxValueSize Maybe Word32 -> (Word32 -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"max value size" Key -> Word32 -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=)
      , Maybe ExecutionUnitPrices
protocolUpdatePrices Maybe ExecutionUnitPrices
-> (ExecutionUnitPrices -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"execution prices" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value))
-> (ExecutionUnitPrices -> Value)
-> ExecutionUnitPrices
-> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExecutionUnitPrices -> Value
friendlyPrices
      , Maybe Coin
protocolUpdateUTxOCostPerByte
          Maybe Coin -> (Coin -> (Key, Value)) -> Maybe (Key, Value)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Key
"UTxO storage cost per byte" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.=) (Value -> (Key, Value)) -> (Coin -> Value) -> Coin -> (Key, Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coin -> Value
friendlyLovelace
      ]

friendlyPrices :: ExecutionUnitPrices -> Aeson.Value
friendlyPrices :: ExecutionUnitPrices -> Value
friendlyPrices ExecutionUnitPrices{Rational
priceExecutionMemory :: Rational
priceExecutionMemory :: ExecutionUnitPrices -> Rational
priceExecutionMemory, Rational
priceExecutionSteps :: Rational
priceExecutionSteps :: ExecutionUnitPrices -> Rational
priceExecutionSteps} =
  [(Key, Value)] -> Value
object
    [ Key
"memory" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
friendlyRational Rational
priceExecutionMemory
    , Key
"steps" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
friendlyRational Rational
priceExecutionSteps
    ]

friendlyCertificates :: ShelleyBasedEra era -> TxCertificates ViewTx era -> Aeson.Value
friendlyCertificates :: forall era.
ShelleyBasedEra era -> TxCertificates ViewTx era -> Value
friendlyCertificates ShelleyBasedEra era
sbe = \case
  TxCertificates ViewTx era
TxCertificatesNone -> Value
Null
  TxCertificates ShelleyBasedEra era
_ OMap
  (Certificate (ShelleyLedgerEra era))
  (BuildTxWith
     ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
cs -> [Value] -> Value
array ([Value] -> Value) -> [Value] -> Value
forall a b. (a -> b) -> a -> b
$ ((Certificate (ShelleyLedgerEra era),
  BuildTxWith
    ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
 -> Value)
-> [(Certificate (ShelleyLedgerEra era),
     BuildTxWith
       ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))]
-> [Value]
forall a b. (a -> b) -> [a] -> [b]
map (ShelleyBasedEra era -> Certificate (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Certificate (ShelleyLedgerEra era) -> Value
friendlyCertificate ShelleyBasedEra era
sbe (Certificate (ShelleyLedgerEra era) -> Value)
-> ((Certificate (ShelleyLedgerEra era),
     BuildTxWith
       ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
    -> Certificate (ShelleyLedgerEra era))
-> (Certificate (ShelleyLedgerEra era),
    BuildTxWith
      ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Certificate (ShelleyLedgerEra era),
 BuildTxWith
   ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
-> Certificate (ShelleyLedgerEra era)
forall a b. (a, b) -> a
fst) ([(Certificate (ShelleyLedgerEra era),
   BuildTxWith
     ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))]
 -> [Value])
-> [(Certificate (ShelleyLedgerEra era),
     BuildTxWith
       ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))]
-> [Value]
forall a b. (a -> b) -> a -> b
$ OMap
  (Certificate (ShelleyLedgerEra era))
  (BuildTxWith
     ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
-> [Item
      (OMap
         (Certificate (ShelleyLedgerEra era))
         (BuildTxWith
            ViewTx (Maybe (StakeCredential, Witness WitCtxStake era))))]
forall l. IsList l => l -> [Item l]
toList OMap
  (Certificate (ShelleyLedgerEra era))
  (BuildTxWith
     ViewTx (Maybe (StakeCredential, Witness WitCtxStake era)))
cs

friendlyCertificate :: ShelleyBasedEra era -> Exp.Certificate (ShelleyLedgerEra era) -> Aeson.Value
friendlyCertificate :: forall era.
ShelleyBasedEra era -> Certificate (ShelleyLedgerEra era) -> Value
friendlyCertificate ShelleyBasedEra era
sbe =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era =>
    Certificate (ShelleyLedgerEra era) -> Value)
-> Certificate (ShelleyLedgerEra era)
-> Value
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era =>
  Certificate (ShelleyLedgerEra era) -> Value)
 -> Certificate (ShelleyLedgerEra era) -> Value)
-> (ShelleyBasedEraConstraints era =>
    Certificate (ShelleyLedgerEra era) -> Value)
-> Certificate (ShelleyLedgerEra era)
-> Value
forall a b. (a -> b) -> a -> b
$
    [(Key, Value)] -> Value
object ([(Key, Value)] -> Value)
-> (Certificate (ShelleyLedgerEra era) -> [(Key, Value)])
-> Certificate (ShelleyLedgerEra era)
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Key, Value) -> [(Key, Value)] -> [(Key, Value)]
forall a. a -> [a] -> [a]
: []) ((Key, Value) -> [(Key, Value)])
-> (Certificate (ShelleyLedgerEra era) -> (Key, Value))
-> Certificate (ShelleyLedgerEra era)
-> [(Key, Value)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyBasedEra era
-> Certificate (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> Certificate (ShelleyLedgerEra era) -> (Key, Value)
renderCertificate ShelleyBasedEra era
sbe

renderCertificate
  :: ShelleyBasedEra era -> Exp.Certificate (ShelleyLedgerEra era) -> (Aeson.Key, Aeson.Value)
renderCertificate :: forall era.
ShelleyBasedEra era
-> Certificate (ShelleyLedgerEra era) -> (Key, Value)
renderCertificate ShelleyBasedEra era
sbe (Exp.Certificate TxCert (ShelleyLedgerEra era)
c) =
  case ShelleyBasedEra era
sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley -> ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe TxCert (ShelleyLedgerEra era)
ShelleyTxCert (ShelleyLedgerEra era)
c
    ShelleyBasedEra era
ShelleyBasedEraAllegra -> ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe TxCert (ShelleyLedgerEra era)
ShelleyTxCert (ShelleyLedgerEra era)
c
    ShelleyBasedEra era
ShelleyBasedEraMary -> ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe TxCert (ShelleyLedgerEra era)
ShelleyTxCert (ShelleyLedgerEra era)
c
    ShelleyBasedEra era
ShelleyBasedEraAlonzo -> ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe TxCert (ShelleyLedgerEra era)
ShelleyTxCert (ShelleyLedgerEra era)
c
    ShelleyBasedEra era
ShelleyBasedEraBabbage -> ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe TxCert (ShelleyLedgerEra era)
ShelleyTxCert (ShelleyLedgerEra era)
c
    ShelleyBasedEra era
ShelleyBasedEraConway -> ConwayTxCert (ShelleyLedgerEra ConwayEra) -> (Key, Value)
renderConwayCertificate TxCert (ShelleyLedgerEra era)
ConwayTxCert (ShelleyLedgerEra ConwayEra)
c
    ShelleyBasedEra era
ShelleyBasedEraDijkstra -> String -> (Key, Value)
forall a. HasCallStack => String -> a
error String
"renderCertificate: TODO Dijkstra era not supported"

renderDrepCredential
  :: ()
  => L.Credential L.DRepRole
  -> Aeson.Value
renderDrepCredential :: Credential DRepRole -> Value
renderDrepCredential =
  [(Key, Value)] -> Value
object ([(Key, Value)] -> Value)
-> (Credential DRepRole -> [(Key, Value)])
-> Credential DRepRole
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
    L.ScriptHashObj ScriptHash
sHash -> [Key
"scriptHash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
sHash]
    L.KeyHashObj KeyHash DRepRole
keyHash -> [Key
"keyHash" Key -> KeyHash DRepRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash DRepRole
keyHash]

delegateeJson
  :: L.Delegatee
  -> Aeson.Value
delegateeJson :: Delegatee -> Value
delegateeJson =
  [(Key, Value)] -> Value
object ([(Key, Value)] -> Value)
-> (Delegatee -> [(Key, Value)]) -> Delegatee -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
    L.DelegStake hk :: KeyHash StakePool
hk@L.KeyHash{} ->
      [ Key
"delegatee type" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
String Text
"stake"
      , Key
"key hash" Key -> KeyHash StakePool -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash StakePool
hk
      ]
    L.DelegVote DRep
drep -> do
      [Key
"delegatee type" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
String Text
"vote", Key
"DRep" Key -> DRep -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DRep
drep]
    L.DelegStakeVote KeyHash StakePool
kh DRep
drep ->
      [ Key
"delegatee type" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
String Text
"stake vote"
      , Key
"key hash" Key -> KeyHash StakePool -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash StakePool
kh
      , Key
"DRep" Key -> DRep -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DRep
drep
      ]

renderShelleyCertificate
  :: ShelleyBasedEra era -> Ledger.ShelleyTxCert (ShelleyLedgerEra era) -> (Aeson.Key, Aeson.Value)
renderShelleyCertificate :: forall era.
ShelleyBasedEra era
-> ShelleyTxCert (ShelleyLedgerEra era) -> (Key, Value)
renderShelleyCertificate ShelleyBasedEra era
sbe ShelleyTxCert (ShelleyLedgerEra era)
c =
  case ShelleyTxCert (ShelleyLedgerEra era)
c of
    L.ShelleyTxCertDelegCert (L.ShelleyRegCert Credential Staking
cred) ->
      Key
"stake address registration" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
cred
    L.ShelleyTxCertDelegCert (L.ShelleyUnRegCert Credential Staking
cred) ->
      Key
"stake address deregistration" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
cred
    L.ShelleyTxCertDelegCert (L.ShelleyDelegCert Credential Staking
cred KeyHash StakePool
poolId) ->
      Key
"stake address delegation"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
cred
          , Key
"pool" Key -> KeyHash StakePool -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash StakePool
poolId
          ]
    L.ShelleyTxCertPool (L.RetirePool KeyHash StakePool
poolId EpochNo
retirementEpoch) ->
      Key
"stake pool retirement"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"pool" Key -> Hash StakePoolKey -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash StakePool -> Hash StakePoolKey
StakePoolKeyHash KeyHash StakePool
poolId
          , Key
"epoch" Key -> EpochNo -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EpochNo
retirementEpoch
          ]
    L.ShelleyTxCertPool (L.RegPool StakePoolParams
poolParams) ->
      Key
"stake pool registration" Key -> StakePoolParams -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StakePoolParams
poolParams
    L.ShelleyTxCertGenesisDeleg (L.GenesisDelegCert KeyHash GenesisRole
genesisKeyHash KeyHash GenesisDelegate
delegateKeyHash VRFVerKeyHash GenDelegVRF
vrfKeyHash) ->
      Key
"genesis key delegation"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"genesis key hash" Key -> KeyHash GenesisRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash GenesisRole
genesisKeyHash
          , Key
"delegate key hash" Key -> KeyHash GenesisDelegate -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash GenesisDelegate
delegateKeyHash
          , Key
"VRF key hash" Key -> VRFVerKeyHash GenDelegVRF -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= VRFVerKeyHash GenDelegVRF
vrfKeyHash
          ]
    L.ShelleyTxCertMir (L.MIRCert MIRPot
pot MIRTarget
target) ->
      Key
"MIR"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"pot" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MIRPot -> Value
friendlyMirPot MIRPot
pot
          , ShelleyBasedEra era -> MIRTarget -> (Key, Value)
forall era. ShelleyBasedEra era -> MIRTarget -> (Key, Value)
friendlyMirTarget ShelleyBasedEra era
sbe MIRTarget
target
          ]

renderConwayCertificate
  :: Ledger.ConwayTxCert (ShelleyLedgerEra ConwayEra) -> (Aeson.Key, Aeson.Value)
renderConwayCertificate :: ConwayTxCert (ShelleyLedgerEra ConwayEra) -> (Key, Value)
renderConwayCertificate ConwayTxCert (ShelleyLedgerEra ConwayEra)
cert =
  case ConwayTxCert (ShelleyLedgerEra ConwayEra)
cert of
    L.RegDRepTxCert Credential DRepRole
credential Coin
coin StrictMaybe Anchor
mAnchor ->
      Key
"Drep registration certificate"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"deposit" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
coin
          , Key
"certificate" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Value
renderDrepCredential Credential DRepRole
credential
          , Key
"anchor" Key -> StrictMaybe Anchor -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StrictMaybe Anchor
mAnchor
          ]
    L.UnRegDRepTxCert Credential DRepRole
credential Coin
coin ->
      Key
"Drep unregistration certificate"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"refund" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
coin
          , Key
"certificate" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Value
renderDrepCredential Credential DRepRole
credential
          ]
    L.AuthCommitteeHotKeyTxCert Credential ColdCommitteeRole
coldCred Credential HotCommitteeRole
hotCred
      | L.ScriptHashObj ScriptHash
sh <- Credential ColdCommitteeRole
coldCred ->
          Key
"Cold committee authorization"
            Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
              [Key
"script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
sh]
      | L.ScriptHashObj ScriptHash
sh <- Credential HotCommitteeRole
hotCred ->
          Key
"Hot committee authorization"
            Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
              [Key
"script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
sh]
      | L.KeyHashObj ck :: KeyHash ColdCommitteeRole
ck@L.KeyHash{} <- Credential ColdCommitteeRole
coldCred
      , L.KeyHashObj hk :: KeyHash HotCommitteeRole
hk@L.KeyHash{} <- Credential HotCommitteeRole
hotCred ->
          Key
"Constitutional committee member hot key registration"
            Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
              [ Key
"cold key hash" Key -> KeyHash ColdCommitteeRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash ColdCommitteeRole
ck
              , Key
"hot key hash" Key -> KeyHash HotCommitteeRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash HotCommitteeRole
hk
              ]
    L.ResignCommitteeColdTxCert Credential ColdCommitteeRole
cred StrictMaybe Anchor
anchor -> case Credential ColdCommitteeRole
cred of
      L.ScriptHashObj ScriptHash
sh ->
        Key
"Cold committee resignation"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
            [ Key
"script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
sh
            , Key
"anchor" Key -> StrictMaybe Anchor -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StrictMaybe Anchor
anchor
            ]
      L.KeyHashObj ck :: KeyHash ColdCommitteeRole
ck@L.KeyHash{} ->
        Key
"Constitutional committee cold key resignation"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
            [ Key
"cold key hash" Key -> KeyHash ColdCommitteeRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash ColdCommitteeRole
ck
            ]
    L.RegTxCert Credential Staking
stakeCredential ->
      Key
"Stake address registration"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          ]
    L.UnRegTxCert Credential Staking
stakeCredential ->
      Key
"Stake address deregistration"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          ]
    L.RegDepositTxCert Credential Staking
stakeCredential Coin
deposit ->
      Key
"Stake address registration"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          , Key
"deposit" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
deposit
          ]
    L.UnRegDepositTxCert Credential Staking
stakeCredential Coin
refund ->
      Key
"Stake address deregistration"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          , Key
"refund" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
refund
          ]
    L.DelegTxCert Credential Staking
stakeCredential Delegatee
delegatee ->
      Key
"Stake address delegation"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          , Key
"delegatee" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Delegatee -> Value
delegateeJson Delegatee
delegatee
          ]
    L.RegDepositDelegTxCert Credential Staking
stakeCredential Delegatee
delegatee Coin
deposit ->
      Key
"Stake address registration and delegation"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake credential" Key -> Credential Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential Staking
stakeCredential
          , Key
"delegatee" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Delegatee -> Value
delegateeJson Delegatee
delegatee
          , Key
"deposit" Key -> Coin -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin
deposit
          ]
    L.RegPoolTxCert StakePoolParams
poolParams ->
      Key
"Pool registration"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"pool params" Key -> StakePoolParams -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StakePoolParams
poolParams
          ]
    L.RetirePoolTxCert kh :: KeyHash StakePool
kh@L.KeyHash{} EpochNo
epoch ->
      Key
"Pool retirement"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"stake pool key hash" Key -> KeyHash StakePool -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash StakePool
kh
          , Key
"epoch" Key -> EpochNo -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EpochNo
epoch
          ]
    L.UpdateDRepTxCert Credential DRepRole
drepCredential StrictMaybe Anchor
mbAnchor ->
      Key
"Drep certificate update"
        Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object
          [ Key
"Drep credential" Key -> Credential DRepRole -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole
drepCredential
          , Key
"anchor " Key -> StrictMaybe Anchor -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StrictMaybe Anchor
mbAnchor
          ]
    ConwayTxCert (ShelleyLedgerEra ConwayEra)
_ -> Key
"unsupported certificate" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
String (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ ConwayTxCert ConwayEra -> String
forall a. Show a => a -> String
show ConwayTxCert (ShelleyLedgerEra ConwayEra)
ConwayTxCert ConwayEra
cert)

friendlyMirTarget
  :: ShelleyBasedEra era -> L.MIRTarget -> Aeson.Pair
friendlyMirTarget :: forall era. ShelleyBasedEra era -> MIRTarget -> (Key, Value)
friendlyMirTarget ShelleyBasedEra era
sbe = \case
  L.StakeAddressesMIR Map (Credential Staking) DeltaCoin
addresses ->
    Key
"target stake addresses"
      Key -> [Value] -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [ [(Key, Value)] -> Value
object
             [ Credential Staking -> (Key, Value)
friendlyStakeCredential Credential Staking
credential
             , Key
"amount" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin -> Value
friendlyLovelace (Integer -> Coin
L.Coin Integer
0 Coin -> DeltaCoin -> Coin
`L.addDeltaCoin` DeltaCoin
lovelace)
             ]
         | (Credential Staking
credential, DeltaCoin
lovelace) <- ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era =>
    [(Credential Staking, DeltaCoin)])
-> [(Credential Staking, DeltaCoin)]
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era =>
  [(Credential Staking, DeltaCoin)])
 -> [(Credential Staking, DeltaCoin)])
-> (ShelleyBasedEraConstraints era =>
    [(Credential Staking, DeltaCoin)])
-> [(Credential Staking, DeltaCoin)]
forall a b. (a -> b) -> a -> b
$ Map (Credential Staking) DeltaCoin
-> [Item (Map (Credential Staking) DeltaCoin)]
forall l. IsList l => l -> [Item l]
toList Map (Credential Staking) DeltaCoin
addresses
         ]
  L.SendToOppositePotMIR Coin
amount -> Key
"MIR amount" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Coin -> Value
friendlyLovelace Coin
amount

friendlyStakeCredential
  :: L.Credential L.Staking -> Aeson.Pair
friendlyStakeCredential :: Credential Staking -> (Key, Value)
friendlyStakeCredential = \case
  L.KeyHashObj KeyHash Staking
keyHash ->
    Key
"stake credential key hash" Key -> KeyHash Staking -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= KeyHash Staking
keyHash
  L.ScriptHashObj ScriptHash
scriptHash ->
    Key
"stake credential script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
scriptHash

friendlyPaymentCredential :: PaymentCredential -> Aeson.Pair
friendlyPaymentCredential :: PaymentCredential -> (Key, Value)
friendlyPaymentCredential = \case
  PaymentCredentialByKey Hash PaymentKey
keyHash ->
    Key
"payment credential key hash" Key -> Hash PaymentKey -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash PaymentKey
keyHash
  PaymentCredentialByScript ScriptHash
scriptHash ->
    Key
"payment credential script hash" Key -> ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ScriptHash
scriptHash

friendlyMirPot :: L.MIRPot -> Aeson.Value
friendlyMirPot :: MIRPot -> Value
friendlyMirPot = \case
  MIRPot
L.ReservesMIR -> Value
"reserves"
  MIRPot
L.TreasuryMIR -> Value
"treasury"

friendlyRational :: Rational -> Aeson.Value
friendlyRational :: Rational -> Value
friendlyRational Rational
r =
  Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$
    case Integer
d of
      Integer
1 -> Integer -> Text
forall a. Show a => a -> Text
textShow Integer
n
      Integer
_ -> Integer -> Text
forall a. Show a => a -> Text
textShow Integer
n Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Integer -> Text
forall a. Show a => a -> Text
textShow Integer
d
 where
  n :: Integer
n = Rational -> Integer
forall a. Ratio a -> a
numerator Rational
r
  d :: Integer
d = Rational -> Integer
forall a. Ratio a -> a
denominator Rational
r

friendlyFee :: TxFee era -> Aeson.Value
friendlyFee :: forall era. TxFee era -> Value
friendlyFee = \case
  TxFeeExplicit ShelleyBasedEra era
_ Coin
fee -> Coin -> Value
friendlyLovelace Coin
fee

friendlyLovelace :: Lovelace -> Aeson.Value
friendlyLovelace :: Coin -> Value
friendlyLovelace Coin
value = Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle -> Text
docToText (Coin -> Doc AnsiStyle
forall ann. Coin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Coin
value)

friendlyMintValue :: forall era. TxMintValue ViewTx era -> Aeson.Value
friendlyMintValue :: forall era. TxMintValue ViewTx era -> Value
friendlyMintValue = \case
  TxMintValue ViewTx era
TxMintNone -> Value
Null
  txMintValue :: TxMintValue ViewTx era
txMintValue@(TxMintValue MaryEraOnwards era
w Map
  PolicyId
  (PolicyAssets, BuildTxWith ViewTx (ScriptWitness WitCtxMint era))
_) -> forall era. ShelleyBasedEra era -> Value -> Value
friendlyValue @era (MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert MaryEraOnwards era
w) (Value -> Value) -> Value -> Value
forall a b. (a -> b) -> a -> b
$ TxMintValue ViewTx era -> Value
forall build era. TxMintValue build era -> Value
txMintValueToValue TxMintValue ViewTx era
txMintValue

friendlyTxOutValue :: TxOutValue era -> Aeson.Value
friendlyTxOutValue :: forall era. TxOutValue era -> Value
friendlyTxOutValue = \case
  TxOutValueByron Coin
lovelace -> Coin -> Value
friendlyLovelace Coin
lovelace
  TxOutValueShelleyBased ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v -> ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
friendlyLedgerValue ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v

friendlyLedgerValue
  :: ()
  => ShelleyBasedEra era
  -> L.Value (ShelleyLedgerEra era)
  -> Aeson.Value
friendlyLedgerValue :: forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
friendlyLedgerValue ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v = ShelleyBasedEra era -> Value -> Value
forall era. ShelleyBasedEra era -> Value -> Value
friendlyValue ShelleyBasedEra era
sbe (Value -> Value) -> Value -> Value
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
Api.fromLedgerValue ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v

friendlyValue
  :: ()
  => ShelleyBasedEra era
  -> Api.Value
  -> Aeson.Value
friendlyValue :: forall era. ShelleyBasedEra era -> Value -> Value
friendlyValue ShelleyBasedEra era
_ Value
v =
  [(Key, Value)] -> Value
object
    [ case ValueNestedBundle
bundle of
        ValueNestedBundleAda Quantity
q -> Key
"lovelace" Key -> Quantity -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Quantity
q
        ValueNestedBundle PolicyId
policy Map AssetName Quantity
assets ->
          Text -> Key
Aeson.fromText (PolicyId -> Text
friendlyPolicyId PolicyId
policy) Key -> Map Text Quantity -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Map AssetName Quantity -> Map Text Quantity
forall {a}. Map AssetName a -> Map Text a
friendlyAssets Map AssetName Quantity
assets
    | ValueNestedBundle
bundle <- [ValueNestedBundle]
bundles
    ]
 where
  ValueNestedRep [ValueNestedBundle]
bundles = Value -> ValueNestedRep
valueToNestedRep Value
v

  friendlyPolicyId :: PolicyId -> Text
friendlyPolicyId = (Text
"policy " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> (PolicyId -> Text) -> PolicyId -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PolicyId -> Text
forall a. SerialiseAsRawBytes a => a -> Text
serialiseToRawBytesHexText

  friendlyAssets :: Map AssetName a -> Map Text a
friendlyAssets = (AssetName -> Text) -> Map AssetName a -> Map Text a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys AssetName -> Text
friendlyAssetName

  friendlyAssetName :: AssetName -> Text
friendlyAssetName = \case
    UnsafeAssetName ByteString
"" -> Text
"default asset"
    name :: AssetName
name@(UnsafeAssetName ByteString
nameBS) ->
      Text
"asset " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> AssetName -> Text
forall a. SerialiseAsRawBytes a => a -> Text
serialiseToRawBytesHexText AssetName
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
nameAsciiSuffix
     where
      nameAsciiSuffix :: Text
nameAsciiSuffix
        | Bool
nameIsAscii = Text
" (" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
nameAscii Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")"
        | Bool
otherwise = Text
""
      nameIsAscii :: Bool
nameIsAscii = (Char -> Bool) -> ByteString -> Bool
BSC.all (\Char
c -> Char -> Bool
isAscii Char
c Bool -> Bool -> Bool
&& Char -> Bool
isAlphaNum Char
c) ByteString
nameBS
      nameAscii :: Text
nameAscii = String -> Text
Text.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ ByteString -> String
BSC.unpack ByteString
nameBS

friendlyMetadata :: TxMetadataInEra era -> Aeson.Value
friendlyMetadata :: forall era. TxMetadataInEra era -> Value
friendlyMetadata = \case
  TxMetadataInEra era
TxMetadataNone -> Value
Null
  TxMetadataInEra ShelleyBasedEra era
_ (TxMetadata Map Word64 TxMetadataValue
m) -> Map Word64 Value -> Value
forall a. ToJSON a => a -> Value
toJSON (Map Word64 Value -> Value) -> Map Word64 Value -> Value
forall a b. (a -> b) -> a -> b
$ TxMetadataValue -> Value
friendlyMetadataValue (TxMetadataValue -> Value)
-> Map Word64 TxMetadataValue -> Map Word64 Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Word64 TxMetadataValue
m

friendlyMetadataValue :: TxMetadataValue -> Aeson.Value
friendlyMetadataValue :: TxMetadataValue -> Value
friendlyMetadataValue = \case
  TxMetaNumber Integer
int -> Integer -> Value
forall a. ToJSON a => a -> Value
toJSON Integer
int
  TxMetaBytes ByteString
bytes -> Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
forall a. Show a => a -> Text
textShow ByteString
bytes
  TxMetaList [TxMetadataValue]
lst -> [Value] -> Value
array ([Value] -> Value) -> [Value] -> Value
forall a b. (a -> b) -> a -> b
$ (TxMetadataValue -> Value) -> [TxMetadataValue] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map TxMetadataValue -> Value
friendlyMetadataValue [TxMetadataValue]
lst
  TxMetaMap [(TxMetadataValue, TxMetadataValue)]
m ->
    [Value] -> Value
array
      [[Value] -> Value
array [TxMetadataValue -> Value
friendlyMetadataValue TxMetadataValue
k, TxMetadataValue -> Value
friendlyMetadataValue TxMetadataValue
v] | (TxMetadataValue
k, TxMetadataValue
v) <- [(TxMetadataValue, TxMetadataValue)]
m]
  TxMetaText Text
text -> Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
text

friendlyAuxScripts :: TxAuxScripts era -> Aeson.Value
friendlyAuxScripts :: forall era. TxAuxScripts era -> Value
friendlyAuxScripts = \case
  TxAuxScripts era
TxAuxScriptsNone -> Value
Null
  TxAuxScripts AllegraEraOnwards era
_ [ScriptInEra era]
scripts -> Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ [ScriptInEra era] -> Text
forall a. Show a => a -> Text
textShow [ScriptInEra era]
scripts

friendlyReferenceInputs :: TxInsReference era build -> Aeson.Value
friendlyReferenceInputs :: forall era build. TxInsReference era build -> Value
friendlyReferenceInputs TxInsReference era build
TxInsReferenceNone = Value
Null
friendlyReferenceInputs (TxInsReference BabbageEraOnwards build
_ [TxIn]
txins TxInsReferenceDatums era
_) = [TxIn] -> Value
forall a. ToJSON a => a -> Value
toJSON [TxIn]
txins

friendlyInputs :: [(TxIn, build)] -> Aeson.Value
friendlyInputs :: forall build. [(TxIn, build)] -> Value
friendlyInputs = [TxIn] -> Value
forall a. ToJSON a => a -> Value
toJSON ([TxIn] -> Value)
-> ([(TxIn, build)] -> [TxIn]) -> [(TxIn, build)] -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxIn, build) -> TxIn) -> [(TxIn, build)] -> [TxIn]
forall a b. (a -> b) -> [a] -> [b]
map (TxIn, build) -> TxIn
forall a b. (a, b) -> a
fst

friendlyCollateralInputs :: TxInsCollateral era -> Aeson.Value
friendlyCollateralInputs :: forall era. TxInsCollateral era -> Value
friendlyCollateralInputs = \case
  TxInsCollateral era
TxInsCollateralNone -> Value
Null
  TxInsCollateral AlonzoEraOnwards era
_ [TxIn]
txins -> [TxIn] -> Value
forall a. ToJSON a => a -> Value
toJSON [TxIn]
txins

friendlyDRep :: L.DRep -> Aeson.Value
friendlyDRep :: DRep -> Value
friendlyDRep DRep
L.DRepAlwaysAbstain = Value
"alwaysAbstain"
friendlyDRep DRep
L.DRepAlwaysNoConfidence = Value
"alwaysNoConfidence"
friendlyDRep (L.DRepCredential sch :: Credential DRepRole
sch@(L.ScriptHashObj (C.ScriptHash Hash ADDRHASH EraIndependentScript
_))) =
  [(Key, Value)] -> Value
Aeson.object
    [ Key
"scriptHash" Key -> Maybe ScriptHash -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Maybe ScriptHash
forall (kr :: KeyRole). Credential kr -> Maybe ScriptHash
credScriptHash Credential DRepRole
sch
    , Key
"cip129Hex" Key -> ByteString -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> ByteString
forall a. Cip129 a => a -> ByteString
cip129SerialiseRaw Credential DRepRole
sch
    , Key
"cip129Bech32" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Text
forall a. Cip129 a => a -> Text
serialiseToBech32Cip129 Credential DRepRole
sch
    ]
friendlyDRep (L.DRepCredential kh :: Credential DRepRole
kh@(L.KeyHashObj (C.KeyHash Hash ADDRHASH (VerKeyDSIGN DSIGN)
_))) =
  [(Key, Value)] -> Value
Aeson.object
    [ Key
"keyHash" Key -> Maybe (KeyHash DRepRole) -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Maybe (KeyHash DRepRole)
forall (r :: KeyRole). Credential r -> Maybe (KeyHash r)
credKeyHash Credential DRepRole
kh
    , Key
"cip129Hex" Key -> ByteString -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> ByteString
forall a. Cip129 a => a -> ByteString
cip129SerialiseRaw Credential DRepRole
kh
    , Key
"cip129Bech32" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Credential DRepRole -> Text
forall a. Cip129 a => a -> Text
serialiseToBech32Cip129 Credential DRepRole
kh
    ]