{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
-- The Shelley ledger uses promoted data kinds which we have to use, but we do
-- not export any from this API. We also use them unticked as nature intended.
{-# OPTIONS_GHC -Wno-unticked-promoted-constructors #-}

-- | Queries from local clients to the node.
module Cardano.Api.Internal.Query
  ( -- * Queries
    QueryInMode (..)
  , QueryInEra (..)
  , QueryInShelleyBasedEra (..)
  , QueryUTxOFilter (..)
  , UTxOInAnyEra (..)

    -- * Internal conversion functions
  , toConsensusQuery
  , fromConsensusQueryResult

    -- * Wrapper types used in queries
  , SerialisedDebugLedgerState (..)
  , ProtocolState (..)
  , decodeProtocolState
  , DebugLedgerState (..)
  , decodeDebugLedgerState
  , SerialisedCurrentEpochState (..)
  , CurrentEpochState (..)
  , decodeCurrentEpochState
  , SerialisedPoolState (..)
  , PoolState (..)
  , decodePoolState
  , SerialisedPoolDistribution (..)
  , PoolDistribution (..)
  , decodePoolDistribution
  , SerialisedStakeSnapshots (..)
  , StakeSnapshot (..)
  , decodeStakeSnapshot
  , EraHistory (..)
  , SystemStart (..)
  , LedgerEpochInfo (..)
  , toLedgerEpochInfo
  , SlotsInEpoch (..)
  , SlotsToEpochEnd (..)
  , slotToEpoch
  , LedgerState (..)
  , getProgress
  , getSlotForRelativeTime
  , decodeBigLedgerPeerSnapshot

    -- * Internal conversion functions
  , toLedgerUTxO
  , fromLedgerUTxO
  )
where

import Cardano.Api.Internal.Address
import Cardano.Api.Internal.Block
import Cardano.Api.Internal.Certificate
import Cardano.Api.Internal.Eon.ShelleyBasedEra
import Cardano.Api.Internal.Eras.Case
import Cardano.Api.Internal.Eras.Core
import Cardano.Api.Internal.GenesisParameters
import Cardano.Api.Internal.HasTypeProxy (HasTypeProxy (..), Proxy)
import Cardano.Api.Internal.IPC.Version
import Cardano.Api.Internal.Keys.Shelley
import Cardano.Api.Internal.Modes
import Cardano.Api.Internal.NetworkId
import Cardano.Api.Internal.Query.Types
import Cardano.Api.Internal.ReexposeLedger qualified as Ledger
import Cardano.Api.Internal.SerialiseCBOR (SerialiseAsCBOR (deserialiseFromCBOR, serialiseToCBOR))
import Cardano.Api.Internal.SerialiseTextEnvelope
  ( HasTextEnvelope (textEnvelopeType)
  , TextEnvelopeType
  )
import Cardano.Api.Internal.Tx.Body
import Cardano.Api.Internal.Tx.UTxO (UTxO (..))

import Cardano.Binary qualified as CBOR
import Cardano.Chain.Update.Validation.Interface qualified as Byron.Update
import Cardano.Ledger.Api qualified as L
import Cardano.Ledger.Api.State.Query qualified as L
import Cardano.Ledger.Binary
import Cardano.Ledger.Binary.Plain qualified as Plain
import Cardano.Ledger.CertState qualified as L
import Cardano.Ledger.Coin qualified as L
import Cardano.Ledger.Credential qualified as Shelley
import Cardano.Ledger.Shelley.API qualified as Shelley
import Cardano.Ledger.Shelley.Core qualified as Core
import Cardano.Ledger.Shelley.LedgerState qualified as L
import Cardano.Slotting.EpochInfo (hoistEpochInfo)
import Cardano.Slotting.Slot (WithOrigin (..))
import Cardano.Slotting.Time (SystemStart (..))
import Ouroboros.Consensus.BlockchainTime.WallClock.Types (RelativeTime, SlotLength)
import Ouroboros.Consensus.Byron.Ledger qualified as Consensus
import Ouroboros.Consensus.Cardano.Block (LedgerState (..), StandardCrypto)
import Ouroboros.Consensus.Cardano.Block qualified as Consensus
import Ouroboros.Consensus.HardFork.Combinator qualified as Consensus
import Ouroboros.Consensus.HardFork.Combinator.AcrossEras (EraMismatch)
import Ouroboros.Consensus.HardFork.Combinator.AcrossEras qualified as Consensus
import Ouroboros.Consensus.HardFork.History qualified as Consensus
import Ouroboros.Consensus.HardFork.History qualified as History
import Ouroboros.Consensus.HardFork.History.Qry qualified as Qry
import Ouroboros.Consensus.Ledger.Query qualified as Consensus
import Ouroboros.Consensus.Protocol.Abstract qualified as Consensus
import Ouroboros.Consensus.Shelley.Ledger qualified as Consensus
import Ouroboros.Consensus.Shelley.Ledger.Query.Types qualified as Consensus
import Ouroboros.Consensus.Shelley.Protocol.Abstract (ProtoCrypto)
import Ouroboros.Network.Block (Serialised (..))
import Ouroboros.Network.NodeToClient.Version (NodeToClientVersion (..))
import Ouroboros.Network.PeerSelection.LedgerPeers.Type (LedgerPeerSnapshot)
import Ouroboros.Network.Protocol.LocalStateQuery.Client (Some (..))

import Codec.Serialise qualified as CBOR
import Control.Monad.Trans.Except
import Data.Bifunctor (bimap, first)
import Data.ByteString qualified as BS
import Data.ByteString.Lazy qualified as LBS
import Data.Either.Combinators (rightToMaybe)
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Maybe (mapMaybe)
import Data.SOP.Constraint (SListI)
import Data.Sequence (Seq)
import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Word (Word64)
import GHC.Exts (IsList (..))
import GHC.Stack

-- ----------------------------------------------------------------------------
-- Queries
--

data QueryInMode result where
  QueryCurrentEra
    :: QueryInMode AnyCardanoEra
  QueryInEra
    :: QueryInEra era result
    -> QueryInMode (Either EraMismatch result)
  QueryEraHistory
    :: QueryInMode EraHistory
  QuerySystemStart
    :: QueryInMode SystemStart
  QueryChainBlockNo
    :: QueryInMode (WithOrigin BlockNo)
  QueryChainPoint
    :: QueryInMode ChainPoint
  QueryLedgerConfig
    :: QueryInMode (Consensus.CardanoLedgerConfig StandardCrypto)

instance NodeToClientVersionOf (QueryInMode result) where
  nodeToClientVersionOf :: QueryInMode result -> NodeToClientVersion
nodeToClientVersionOf = \case
    QueryInMode result
QueryCurrentEra -> NodeToClientVersion
NodeToClientV_16
    QueryInEra QueryInEra era result
q -> QueryInEra era result -> NodeToClientVersion
forall a. NodeToClientVersionOf a => a -> NodeToClientVersion
nodeToClientVersionOf QueryInEra era result
q
    QueryInMode result
QueryEraHistory -> NodeToClientVersion
NodeToClientV_16
    QueryInMode result
QuerySystemStart -> NodeToClientVersion
NodeToClientV_16
    QueryInMode result
QueryChainBlockNo -> NodeToClientVersion
NodeToClientV_16
    QueryInMode result
QueryChainPoint -> NodeToClientVersion
NodeToClientV_16
    QueryInMode result
QueryLedgerConfig -> NodeToClientVersion
NodeToClientV_20

data EraHistory where
  EraHistory
    :: Consensus.CardanoBlock StandardCrypto ~ Consensus.HardForkBlock xs
    => History.Interpreter xs
    -> EraHistory

instance HasTypeProxy EraHistory where
  data AsType EraHistory = AsEraHistory

  proxyToAsType :: Proxy EraHistory -> AsType EraHistory
  proxyToAsType :: Proxy EraHistory -> AsType EraHistory
proxyToAsType Proxy EraHistory
_ = AsType EraHistory
AsEraHistory

instance SerialiseAsCBOR EraHistory where
  serialiseToCBOR :: EraHistory -> BS.ByteString
  serialiseToCBOR :: EraHistory -> ByteString
serialiseToCBOR (EraHistory Interpreter xs
interpreter) = Encoding -> ByteString
CBOR.toStrictByteString (Interpreter xs -> Encoding
forall a. Serialise a => a -> Encoding
CBOR.encode Interpreter xs
interpreter)

  deserialiseFromCBOR :: AsType EraHistory -> BS.ByteString -> Either DecoderError EraHistory
  deserialiseFromCBOR :: AsType EraHistory -> ByteString -> Either DecoderError EraHistory
deserialiseFromCBOR AsType EraHistory
_ ByteString
bs =
    Interpreter (CardanoEras StandardCrypto) -> EraHistory
forall (xs :: [*]).
(CardanoBlock StandardCrypto ~ HardForkBlock xs) =>
Interpreter xs -> EraHistory
EraHistory
      (Interpreter (CardanoEras StandardCrypto) -> EraHistory)
-> Either DecoderError (Interpreter (CardanoEras StandardCrypto))
-> Either DecoderError EraHistory
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> (forall s. Decoder s (Interpreter (CardanoEras StandardCrypto)))
-> ByteString
-> Either DecoderError (Interpreter (CardanoEras StandardCrypto))
forall a.
Text
-> (forall s. Decoder s a) -> ByteString -> Either DecoderError a
CBOR.decodeFullDecoder' Text
"EraHistory" Decoder s (Interpreter (CardanoEras StandardCrypto))
forall s. Decoder s (Interpreter (CardanoEras StandardCrypto))
forall a s. Serialise a => Decoder s a
CBOR.decode ByteString
bs

-- | The @HasTextEnvelope@ instance for @EraHistory@ is required by the
-- @transaction calculate-plutus-script-cost@ command in @cartdano-cli and it
-- can be obtained through the @query era-history@ command.
instance HasTextEnvelope EraHistory where
  textEnvelopeType :: AsType EraHistory -> TextEnvelopeType
  textEnvelopeType :: AsType EraHistory -> TextEnvelopeType
textEnvelopeType AsType EraHistory
_ = TextEnvelopeType
"EraHistory"

getProgress
  :: ()
  => SlotNo
  -> EraHistory
  -> Either Qry.PastHorizonException (RelativeTime, SlotLength)
getProgress :: SlotNo
-> EraHistory
-> Either PastHorizonException (RelativeTime, SlotLength)
getProgress SlotNo
slotNo (EraHistory Interpreter xs
interpreter) = Interpreter xs
-> Qry (RelativeTime, SlotLength)
-> Either PastHorizonException (RelativeTime, SlotLength)
forall (xs :: [*]) a.
HasCallStack =>
Interpreter xs -> Qry a -> Either PastHorizonException a
Qry.interpretQuery Interpreter xs
interpreter (SlotNo -> Qry (RelativeTime, SlotLength)
Qry.slotToWallclock SlotNo
slotNo)

-- | Returns the slot number for provided relative time from 'SystemStart'
getSlotForRelativeTime
  :: ()
  => RelativeTime
  -> EraHistory
  -> Either Qry.PastHorizonException SlotNo
getSlotForRelativeTime :: RelativeTime -> EraHistory -> Either PastHorizonException SlotNo
getSlotForRelativeTime RelativeTime
relTime (EraHistory Interpreter xs
interpreter) = do
  (SlotNo
slotNo, NominalDiffTime
_, NominalDiffTime
_) <- Interpreter xs
-> Qry (SlotNo, NominalDiffTime, NominalDiffTime)
-> Either
     PastHorizonException (SlotNo, NominalDiffTime, NominalDiffTime)
forall (xs :: [*]) a.
HasCallStack =>
Interpreter xs -> Qry a -> Either PastHorizonException a
Qry.interpretQuery Interpreter xs
interpreter (Qry (SlotNo, NominalDiffTime, NominalDiffTime)
 -> Either
      PastHorizonException (SlotNo, NominalDiffTime, NominalDiffTime))
-> Qry (SlotNo, NominalDiffTime, NominalDiffTime)
-> Either
     PastHorizonException (SlotNo, NominalDiffTime, NominalDiffTime)
forall a b. (a -> b) -> a -> b
$ RelativeTime -> Qry (SlotNo, NominalDiffTime, NominalDiffTime)
Qry.wallclockToSlot RelativeTime
relTime
  SlotNo -> Either PastHorizonException SlotNo
forall a. a -> Either PastHorizonException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SlotNo
slotNo

newtype LedgerEpochInfo = LedgerEpochInfo {LedgerEpochInfo -> EpochInfo (Either Text)
unLedgerEpochInfo :: Consensus.EpochInfo (Either Text)}

toLedgerEpochInfo
  :: ()
  => EraHistory
  -> LedgerEpochInfo
toLedgerEpochInfo :: EraHistory -> LedgerEpochInfo
toLedgerEpochInfo (EraHistory Interpreter xs
interpreter) =
  EpochInfo (Either Text) -> LedgerEpochInfo
LedgerEpochInfo (EpochInfo (Either Text) -> LedgerEpochInfo)
-> EpochInfo (Either Text) -> LedgerEpochInfo
forall a b. (a -> b) -> a -> b
$
    (forall a. Except PastHorizonException a -> Either Text a)
-> EpochInfo (Except PastHorizonException)
-> EpochInfo (Either Text)
forall (m :: * -> *) (n :: * -> *).
(forall a. m a -> n a) -> EpochInfo m -> EpochInfo n
hoistEpochInfo ((PastHorizonException -> Text)
-> Either PastHorizonException a -> Either Text a
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> Text
Text.pack (String -> Text)
-> (PastHorizonException -> String) -> PastHorizonException -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PastHorizonException -> String
forall a. Show a => a -> String
show) (Either PastHorizonException a -> Either Text a)
-> (Except PastHorizonException a -> Either PastHorizonException a)
-> Except PastHorizonException a
-> Either Text a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Except PastHorizonException a -> Either PastHorizonException a
forall e a. Except e a -> Either e a
runExcept) (EpochInfo (Except PastHorizonException)
 -> EpochInfo (Either Text))
-> EpochInfo (Except PastHorizonException)
-> EpochInfo (Either Text)
forall a b. (a -> b) -> a -> b
$
      Interpreter xs -> EpochInfo (Except PastHorizonException)
forall (xs :: [*]).
Interpreter xs -> EpochInfo (Except PastHorizonException)
Consensus.interpreterToEpochInfo Interpreter xs
interpreter

newtype SlotsInEpoch = SlotsInEpoch Word64

newtype SlotsToEpochEnd = SlotsToEpochEnd Word64

slotToEpoch
  :: ()
  => SlotNo
  -> EraHistory
  -> Either Qry.PastHorizonException (EpochNo, SlotsInEpoch, SlotsToEpochEnd)
slotToEpoch :: SlotNo
-> EraHistory
-> Either
     PastHorizonException (EpochNo, SlotsInEpoch, SlotsToEpochEnd)
slotToEpoch SlotNo
slotNo (EraHistory Interpreter xs
interpreter) = case Interpreter xs
-> Qry (EpochNo, Word64, Word64)
-> Either PastHorizonException (EpochNo, Word64, Word64)
forall (xs :: [*]) a.
HasCallStack =>
Interpreter xs -> Qry a -> Either PastHorizonException a
Qry.interpretQuery Interpreter xs
interpreter (SlotNo -> Qry (EpochNo, Word64, Word64)
Qry.slotToEpoch SlotNo
slotNo) of
  Right (EpochNo
epochNumber, Word64
slotsInEpoch, Word64
slotsToEpochEnd) -> (EpochNo, SlotsInEpoch, SlotsToEpochEnd)
-> Either
     PastHorizonException (EpochNo, SlotsInEpoch, SlotsToEpochEnd)
forall a b. b -> Either a b
Right (EpochNo
epochNumber, Word64 -> SlotsInEpoch
SlotsInEpoch Word64
slotsInEpoch, Word64 -> SlotsToEpochEnd
SlotsToEpochEnd Word64
slotsToEpochEnd)
  Left PastHorizonException
e -> PastHorizonException
-> Either
     PastHorizonException (EpochNo, SlotsInEpoch, SlotsToEpochEnd)
forall a b. a -> Either a b
Left PastHorizonException
e

deriving instance Show (QueryInMode result)

data QueryInEra era result where
  QueryByronUpdateState :: QueryInEra ByronEra ByronUpdateState
  QueryInShelleyBasedEra
    :: ShelleyBasedEra era
    -> QueryInShelleyBasedEra era result
    -> QueryInEra era result

instance NodeToClientVersionOf (QueryInEra era result) where
  nodeToClientVersionOf :: QueryInEra era result -> NodeToClientVersion
nodeToClientVersionOf QueryInEra era result
QueryByronUpdateState = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryInShelleyBasedEra ShelleyBasedEra era
_ QueryInShelleyBasedEra era result
q) = QueryInShelleyBasedEra era result -> NodeToClientVersion
forall a. NodeToClientVersionOf a => a -> NodeToClientVersion
nodeToClientVersionOf QueryInShelleyBasedEra era result
q

deriving instance Show (QueryInEra era result)

data QueryInShelleyBasedEra era result where
  QueryEpoch
    :: QueryInShelleyBasedEra era EpochNo
  QueryGenesisParameters
    :: QueryInShelleyBasedEra era (GenesisParameters ShelleyEra)
  QueryProtocolParameters
    :: QueryInShelleyBasedEra era (Ledger.PParams (ShelleyLedgerEra era))
  QueryStakeDistribution
    :: QueryInShelleyBasedEra era (Map (Hash StakePoolKey) Rational)
  QueryUTxO
    :: QueryUTxOFilter
    -> QueryInShelleyBasedEra era (UTxO era)
  QueryStakeAddresses
    :: Set StakeCredential
    -> NetworkId
    -> QueryInShelleyBasedEra era (Map StakeAddress L.Coin, Map StakeAddress PoolId)
  QueryStakePools
    :: QueryInShelleyBasedEra era (Set PoolId)
  QueryStakePoolParameters
    :: Set PoolId
    -> QueryInShelleyBasedEra era (Map PoolId StakePoolParameters)
  -- TODO: add support for RewardProvenance
  -- QueryPoolRanking
  --   :: QueryInShelleyBasedEra era RewardProvenance

  QueryDebugLedgerState
    :: QueryInShelleyBasedEra era (SerialisedDebugLedgerState era)
  QueryProtocolState
    :: QueryInShelleyBasedEra era (ProtocolState era)
  QueryCurrentEpochState
    :: QueryInShelleyBasedEra era (SerialisedCurrentEpochState era)
  QueryPoolState
    :: Maybe (Set PoolId)
    -> QueryInShelleyBasedEra era (SerialisedPoolState era)
  QueryPoolDistribution
    :: Maybe (Set PoolId)
    -> QueryInShelleyBasedEra era (SerialisedPoolDistribution era)
  QueryStakeSnapshot
    :: Maybe (Set PoolId)
    -> QueryInShelleyBasedEra era (SerialisedStakeSnapshots era)
  QueryStakeDelegDeposits
    :: Set StakeCredential
    -> QueryInShelleyBasedEra era (Map StakeCredential L.Coin)
  QueryAccountState
    :: QueryInShelleyBasedEra era L.AccountState
  QueryConstitution
    :: QueryInShelleyBasedEra era (L.Constitution (ShelleyLedgerEra era))
  QueryGovState
    :: QueryInShelleyBasedEra era (L.GovState (ShelleyLedgerEra era))
  QueryRatifyState
    :: QueryInShelleyBasedEra era (L.RatifyState (ShelleyLedgerEra era))
  QueryFuturePParams
    :: QueryInShelleyBasedEra era (Maybe (Core.PParams (ShelleyLedgerEra era)))
  QueryDRepState
    :: Set (Shelley.Credential Shelley.DRepRole)
    -> QueryInShelleyBasedEra
         era
         (Map (Shelley.Credential Shelley.DRepRole) L.DRepState)
  QueryDRepStakeDistr
    :: Set Ledger.DRep
    -> QueryInShelleyBasedEra era (Map Ledger.DRep L.Coin)
  QuerySPOStakeDistr
    :: Set (Ledger.KeyHash 'Ledger.StakePool)
    -> QueryInShelleyBasedEra era (Map (Ledger.KeyHash 'Ledger.StakePool) L.Coin)
  QueryCommitteeMembersState
    :: Set (Shelley.Credential Shelley.ColdCommitteeRole)
    -> Set (Shelley.Credential Shelley.HotCommitteeRole)
    -> Set L.MemberStatus
    -> QueryInShelleyBasedEra era L.CommitteeMembersState
  QueryStakeVoteDelegatees
    :: Set StakeCredential
    -> QueryInShelleyBasedEra era (Map StakeCredential Ledger.DRep)
  QueryProposals
    :: Set L.GovActionId
    -> QueryInShelleyBasedEra era (Seq (L.GovActionState (ShelleyLedgerEra era)))
  QueryLedgerPeerSnapshot
    :: QueryInShelleyBasedEra era (Serialised LedgerPeerSnapshot)
  QueryStakePoolDefaultVote
    :: Ledger.KeyHash 'Ledger.StakePool
    -> QueryInShelleyBasedEra era L.DefaultVote

-- | Mapping for queries in Shelley-based eras returning minimal node-to-client protocol versions. More
-- information about queries versioning can be found:
--   * https://ouroboros-network.cardano.intersectmbo.org/ouroboros-network/Ouroboros-Network-NodeToClient.html#t:NodeToClientVersion
--   * https://ouroboros-consensus.cardano.intersectmbo.org/docs/for-developers/QueryVersioning/#implementation
instance NodeToClientVersionOf (QueryInShelleyBasedEra era result) where
  nodeToClientVersionOf :: QueryInShelleyBasedEra era result -> NodeToClientVersion
nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryEpoch = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryGenesisParameters = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryProtocolParameters = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryStakeDistribution = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryUTxO QueryUTxOFilter
f) = QueryUTxOFilter -> NodeToClientVersion
forall a. NodeToClientVersionOf a => a -> NodeToClientVersion
nodeToClientVersionOf QueryUTxOFilter
f
  nodeToClientVersionOf (QueryStakeAddresses Set StakeCredential
_ NetworkId
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryStakePools = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryStakePoolParameters Set (Hash StakePoolKey)
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryDebugLedgerState = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryProtocolState = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryCurrentEpochState = NodeToClientVersion
NodeToClientV_16
  -- Babbage >= v13
  nodeToClientVersionOf (QueryPoolState Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryPoolDistribution Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryStakeSnapshot Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryStakeDelegDeposits Set StakeCredential
_) = NodeToClientVersion
NodeToClientV_16
  -- Conway >= v16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryAccountState = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryConstitution = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryGovState = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryDRepState{} = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryDRepStakeDistr{} = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QuerySPOStakeDistr{} = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryCommitteeMembersState{} = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryStakeVoteDelegatees{} = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf QueryProposals{} = NodeToClientVersion
NodeToClientV_17
  nodeToClientVersionOf QueryRatifyState{} = NodeToClientVersion
NodeToClientV_17
  nodeToClientVersionOf QueryFuturePParams{} = NodeToClientVersion
NodeToClientV_18
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryLedgerPeerSnapshot = NodeToClientVersion
NodeToClientV_19
  nodeToClientVersionOf QueryStakePoolDefaultVote{} = NodeToClientVersion
NodeToClientV_20

deriving instance Show (QueryInShelleyBasedEra era result)

-- ----------------------------------------------------------------------------
-- Wrapper types used in queries
--

-- | Getting the /whole/ UTxO is obviously not efficient since the result can
-- be huge. Filtering by address is also not efficient because it requires a
-- linear search.
--
-- The 'QueryUTxOFilterByTxIn' is efficient since it fits with the structure of
-- the UTxO (which is indexed by 'TxIn').
data QueryUTxOFilter
  = -- | /O(n) time and space/ for utxo size n
    QueryUTxOWhole
  | -- | /O(n) time, O(m) space/ for utxo size n, and address set size m
    QueryUTxOByAddress (Set AddressAny)
  | -- | /O(m log n) time, O(m) space/ for utxo size n, and address set size m
    QueryUTxOByTxIn (Set TxIn)
  deriving (QueryUTxOFilter -> QueryUTxOFilter -> Bool
(QueryUTxOFilter -> QueryUTxOFilter -> Bool)
-> (QueryUTxOFilter -> QueryUTxOFilter -> Bool)
-> Eq QueryUTxOFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryUTxOFilter -> QueryUTxOFilter -> Bool
== :: QueryUTxOFilter -> QueryUTxOFilter -> Bool
$c/= :: QueryUTxOFilter -> QueryUTxOFilter -> Bool
/= :: QueryUTxOFilter -> QueryUTxOFilter -> Bool
Eq, Int -> QueryUTxOFilter -> ShowS
[QueryUTxOFilter] -> ShowS
QueryUTxOFilter -> String
(Int -> QueryUTxOFilter -> ShowS)
-> (QueryUTxOFilter -> String)
-> ([QueryUTxOFilter] -> ShowS)
-> Show QueryUTxOFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryUTxOFilter -> ShowS
showsPrec :: Int -> QueryUTxOFilter -> ShowS
$cshow :: QueryUTxOFilter -> String
show :: QueryUTxOFilter -> String
$cshowList :: [QueryUTxOFilter] -> ShowS
showList :: [QueryUTxOFilter] -> ShowS
Show)

instance NodeToClientVersionOf QueryUTxOFilter where
  nodeToClientVersionOf :: QueryUTxOFilter -> NodeToClientVersion
nodeToClientVersionOf QueryUTxOFilter
QueryUTxOWhole = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryUTxOByAddress Set AddressAny
_) = NodeToClientVersion
NodeToClientV_16
  nodeToClientVersionOf (QueryUTxOByTxIn Set TxIn
_) = NodeToClientVersion
NodeToClientV_16

newtype ByronUpdateState = ByronUpdateState Byron.Update.State
  deriving Int -> ByronUpdateState -> ShowS
[ByronUpdateState] -> ShowS
ByronUpdateState -> String
(Int -> ByronUpdateState -> ShowS)
-> (ByronUpdateState -> String)
-> ([ByronUpdateState] -> ShowS)
-> Show ByronUpdateState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ByronUpdateState -> ShowS
showsPrec :: Int -> ByronUpdateState -> ShowS
$cshow :: ByronUpdateState -> String
show :: ByronUpdateState -> String
$cshowList :: [ByronUpdateState] -> ShowS
showList :: [ByronUpdateState] -> ShowS
Show

data UTxOInAnyEra where
  UTxOInAnyEra
    :: CardanoEra era
    -> UTxO era
    -> UTxOInAnyEra

deriving instance Show UTxOInAnyEra

newtype SerialisedDebugLedgerState era
  = SerialisedDebugLedgerState (Serialised (Shelley.NewEpochState (ShelleyLedgerEra era)))

decodeDebugLedgerState
  :: forall era
   . ()
  => FromCBOR (DebugLedgerState era)
  => SerialisedDebugLedgerState era
  -> Either (LBS.ByteString, DecoderError) (DebugLedgerState era)
decodeDebugLedgerState :: forall era.
FromCBOR (DebugLedgerState era) =>
SerialisedDebugLedgerState era
-> Either (ByteString, DecoderError) (DebugLedgerState era)
decodeDebugLedgerState (SerialisedDebugLedgerState (Serialised ByteString
ls)) =
  (DecoderError -> (ByteString, DecoderError))
-> Either DecoderError (DebugLedgerState era)
-> Either (ByteString, DecoderError) (DebugLedgerState era)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (ByteString
ls,) (ByteString -> Either DecoderError (DebugLedgerState era)
forall a. FromCBOR a => ByteString -> Either DecoderError a
Plain.decodeFull ByteString
ls)

newtype ProtocolState era
  = ProtocolState (Serialised (Consensus.ChainDepState (ConsensusProtocol era)))

-- ChainDepState can use Praos or TPraos crypto
decodeProtocolState
  :: FromCBOR (Consensus.ChainDepState (ConsensusProtocol era))
  => ProtocolState era
  -> Either (LBS.ByteString, DecoderError) (Consensus.ChainDepState (ConsensusProtocol era))
decodeProtocolState :: forall era.
FromCBOR (ChainDepState (ConsensusProtocol era)) =>
ProtocolState era
-> Either
     (ByteString, DecoderError) (ChainDepState (ConsensusProtocol era))
decodeProtocolState (ProtocolState (Serialised ByteString
pbs)) = (DecoderError -> (ByteString, DecoderError))
-> Either DecoderError (ChainDepState (ConsensusProtocol era))
-> Either
     (ByteString, DecoderError) (ChainDepState (ConsensusProtocol era))
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (ByteString
pbs,) (Either DecoderError (ChainDepState (ConsensusProtocol era))
 -> Either
      (ByteString, DecoderError) (ChainDepState (ConsensusProtocol era)))
-> Either DecoderError (ChainDepState (ConsensusProtocol era))
-> Either
     (ByteString, DecoderError) (ChainDepState (ConsensusProtocol era))
forall a b. (a -> b) -> a -> b
$ ByteString
-> Either DecoderError (ChainDepState (ConsensusProtocol era))
forall a. FromCBOR a => ByteString -> Either DecoderError a
Plain.decodeFull ByteString
pbs

newtype SerialisedCurrentEpochState era
  = SerialisedCurrentEpochState (Serialised (Shelley.EpochState (ShelleyLedgerEra era)))

newtype CurrentEpochState era = CurrentEpochState (Shelley.EpochState (ShelleyLedgerEra era))

decodeCurrentEpochState
  :: ShelleyBasedEra era
  -> SerialisedCurrentEpochState era
  -> Either DecoderError (CurrentEpochState era)
decodeCurrentEpochState :: forall era.
ShelleyBasedEra era
-> SerialisedCurrentEpochState era
-> Either DecoderError (CurrentEpochState era)
decodeCurrentEpochState ShelleyBasedEra era
sbe (SerialisedCurrentEpochState (Serialised ByteString
ls)) =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era =>
    Either DecoderError (CurrentEpochState era))
-> Either DecoderError (CurrentEpochState era)
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era =>
  Either DecoderError (CurrentEpochState era))
 -> Either DecoderError (CurrentEpochState era))
-> (ShelleyBasedEraConstraints era =>
    Either DecoderError (CurrentEpochState era))
-> Either DecoderError (CurrentEpochState era)
forall a b. (a -> b) -> a -> b
$ EpochState (ShelleyLedgerEra era) -> CurrentEpochState era
forall era.
EpochState (ShelleyLedgerEra era) -> CurrentEpochState era
CurrentEpochState (EpochState (ShelleyLedgerEra era) -> CurrentEpochState era)
-> Either DecoderError (EpochState (ShelleyLedgerEra era))
-> Either DecoderError (CurrentEpochState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString
-> Either DecoderError (EpochState (ShelleyLedgerEra era))
forall a. FromCBOR a => ByteString -> Either DecoderError a
Plain.decodeFull ByteString
ls

newtype SerialisedPoolState era
  = SerialisedPoolState (Serialised (Shelley.PState (ShelleyLedgerEra era)))

newtype PoolState era = PoolState (Shelley.PState (ShelleyLedgerEra era))

decodePoolState
  :: forall era
   . ()
  => Core.Era (ShelleyLedgerEra era)
  => DecCBOR (Shelley.PState (ShelleyLedgerEra era))
  => SerialisedPoolState era
  -> Either DecoderError (PoolState era)
decodePoolState :: forall era.
(Era (ShelleyLedgerEra era),
 DecCBOR (PState (ShelleyLedgerEra era))) =>
SerialisedPoolState era -> Either DecoderError (PoolState era)
decodePoolState (SerialisedPoolState (Serialised ByteString
ls)) =
  PState (ShelleyLedgerEra era) -> PoolState era
forall era. PState (ShelleyLedgerEra era) -> PoolState era
PoolState (PState (ShelleyLedgerEra era) -> PoolState era)
-> Either DecoderError (PState (ShelleyLedgerEra era))
-> Either DecoderError (PoolState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Version
-> ByteString
-> Either DecoderError (PState (ShelleyLedgerEra era))
forall a.
DecCBOR a =>
Version -> ByteString -> Either DecoderError a
decodeFull (forall era. Era era => Version
Core.eraProtVerLow @(ShelleyLedgerEra era)) ByteString
ls

newtype SerialisedPoolDistribution era
  = SerialisedPoolDistribution
      (Serialised (Consensus.PoolDistr StandardCrypto))

newtype PoolDistribution era = PoolDistribution
  { forall era. PoolDistribution era -> PoolDistr StandardCrypto
unPoolDistr :: Consensus.PoolDistr StandardCrypto
  }

decodePoolDistribution
  :: forall era
   . ShelleyBasedEra era
  -> SerialisedPoolDistribution era
  -> Either DecoderError (PoolDistribution era)
decodePoolDistribution :: forall era.
ShelleyBasedEra era
-> SerialisedPoolDistribution era
-> Either DecoderError (PoolDistribution era)
decodePoolDistribution ShelleyBasedEra era
sbe (SerialisedPoolDistribution (Serialised ByteString
ls)) =
  PoolDistr StandardCrypto -> PoolDistribution era
forall era. PoolDistr StandardCrypto -> PoolDistribution era
PoolDistribution (PoolDistr StandardCrypto -> PoolDistribution era)
-> Either DecoderError (PoolDistr StandardCrypto)
-> Either DecoderError (PoolDistribution era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Version
-> ByteString -> Either DecoderError (PoolDistr StandardCrypto)
forall a.
DecCBOR a =>
Version -> ByteString -> Either DecoderError a
decodeFull (ShelleyBasedEra era -> Version
forall era. ShelleyBasedEra era -> Version
eraProtVerLow ShelleyBasedEra era
sbe) ByteString
ls

newtype SerialisedStakeSnapshots era
  = SerialisedStakeSnapshots
      (Serialised Consensus.StakeSnapshots)

newtype StakeSnapshot era = StakeSnapshot Consensus.StakeSnapshots

decodeStakeSnapshot
  :: forall era
   . SerialisedStakeSnapshots era
  -> Either DecoderError (StakeSnapshot era)
decodeStakeSnapshot :: forall era.
SerialisedStakeSnapshots era
-> Either DecoderError (StakeSnapshot era)
decodeStakeSnapshot (SerialisedStakeSnapshots (Serialised ByteString
ls)) = StakeSnapshots -> StakeSnapshot era
forall era. StakeSnapshots -> StakeSnapshot era
StakeSnapshot (StakeSnapshots -> StakeSnapshot era)
-> Either DecoderError StakeSnapshots
-> Either DecoderError (StakeSnapshot era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Either DecoderError StakeSnapshots
forall a. FromCBOR a => ByteString -> Either DecoderError a
Plain.decodeFull ByteString
ls

decodeBigLedgerPeerSnapshot
  :: Serialised LedgerPeerSnapshot
  -> Either (LBS.ByteString, DecoderError) LedgerPeerSnapshot
decodeBigLedgerPeerSnapshot :: Serialised LedgerPeerSnapshot
-> Either (ByteString, DecoderError) LedgerPeerSnapshot
decodeBigLedgerPeerSnapshot (Serialised ByteString
lps) = (DecoderError -> (ByteString, DecoderError))
-> Either DecoderError LedgerPeerSnapshot
-> Either (ByteString, DecoderError) LedgerPeerSnapshot
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (ByteString
lps,) (ByteString -> Either DecoderError LedgerPeerSnapshot
forall a. FromCBOR a => ByteString -> Either DecoderError a
Plain.decodeFull ByteString
lps)

toShelleyAddrSet
  :: CardanoEra era
  -> Set AddressAny
  -> Set Shelley.Addr
toShelleyAddrSet :: forall era. CardanoEra era -> Set AddressAny -> Set Addr
toShelleyAddrSet CardanoEra era
era =
  [Item (Set Addr)] -> Set Addr
[Addr] -> Set Addr
forall l. IsList l => [Item l] -> l
fromList
    ([Addr] -> Set Addr)
-> (Set AddressAny -> [Addr]) -> Set AddressAny -> Set Addr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AddressInEra era -> Addr) -> [AddressInEra era] -> [Addr]
forall a b. (a -> b) -> [a] -> [b]
map AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr
    -- Ignore any addresses that are not appropriate for the era,
    -- e.g. Shelley addresses in the Byron era, as these would not
    -- appear in the UTxO anyway.
    ([AddressInEra era] -> [Addr])
-> (Set AddressAny -> [AddressInEra era])
-> Set AddressAny
-> [Addr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AddressAny -> Maybe (AddressInEra era))
-> [AddressAny] -> [AddressInEra era]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Either String (AddressInEra era) -> Maybe (AddressInEra era)
forall a b. Either a b -> Maybe b
rightToMaybe (Either String (AddressInEra era) -> Maybe (AddressInEra era))
-> (AddressAny -> Either String (AddressInEra era))
-> AddressAny
-> Maybe (AddressInEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CardanoEra era -> AddressAny -> Either String (AddressInEra era)
forall era.
CardanoEra era -> AddressAny -> Either String (AddressInEra era)
anyAddressInEra CardanoEra era
era)
    ([AddressAny] -> [AddressInEra era])
-> (Set AddressAny -> [AddressAny])
-> Set AddressAny
-> [AddressInEra era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set AddressAny -> [Item (Set AddressAny)]
Set AddressAny -> [AddressAny]
forall l. IsList l => l -> [Item l]
toList

toLedgerUTxO
  :: ()
  => ShelleyBasedEra era
  -> UTxO era
  -> Shelley.UTxO (ShelleyLedgerEra era)
toLedgerUTxO :: forall era.
ShelleyBasedEra era -> UTxO era -> UTxO (ShelleyLedgerEra era)
toLedgerUTxO ShelleyBasedEra era
sbe (UTxO Map TxIn (TxOut CtxUTxO era)
utxo) =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => UTxO (ShelleyLedgerEra era))
-> UTxO (ShelleyLedgerEra era)
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe
    ((ShelleyBasedEraConstraints era => UTxO (ShelleyLedgerEra era))
 -> UTxO (ShelleyLedgerEra era))
-> (ShelleyBasedEraConstraints era => UTxO (ShelleyLedgerEra era))
-> UTxO (ShelleyLedgerEra era)
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut (ShelleyLedgerEra era))
-> UTxO (ShelleyLedgerEra era)
forall era. Map TxIn (TxOut era) -> UTxO era
Shelley.UTxO
      (Map TxIn (TxOut (ShelleyLedgerEra era))
 -> UTxO (ShelleyLedgerEra era))
-> (Map TxIn (TxOut CtxUTxO era)
    -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> Map TxIn (TxOut CtxUTxO era)
-> UTxO (ShelleyLedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn, TxOut (ShelleyLedgerEra era))]
-> Map TxIn (TxOut (ShelleyLedgerEra era))
[Item (Map TxIn (TxOut (ShelleyLedgerEra era)))]
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall l. IsList l => [Item l] -> l
fromList
      ([(TxIn, TxOut (ShelleyLedgerEra era))]
 -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> (Map TxIn (TxOut CtxUTxO era)
    -> [(TxIn, TxOut (ShelleyLedgerEra era))])
-> Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxIn, TxOut CtxUTxO era) -> (TxIn, TxOut (ShelleyLedgerEra era)))
-> [(TxIn, TxOut CtxUTxO era)]
-> [(TxIn, TxOut (ShelleyLedgerEra era))]
forall a b. (a -> b) -> [a] -> [b]
map ((TxIn -> TxIn)
-> (TxOut CtxUTxO era -> TxOut (ShelleyLedgerEra era))
-> (TxIn, TxOut CtxUTxO era)
-> (TxIn, TxOut (ShelleyLedgerEra era))
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap TxIn -> TxIn
toShelleyTxIn (ShelleyBasedEra era
-> TxOut CtxUTxO era -> TxOut (ShelleyLedgerEra era)
forall era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut CtxUTxO era -> TxOut ledgerera
toShelleyTxOut ShelleyBasedEra era
sbe))
      ([(TxIn, TxOut CtxUTxO era)]
 -> [(TxIn, TxOut (ShelleyLedgerEra era))])
-> (Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)])
-> Map TxIn (TxOut CtxUTxO era)
-> [(TxIn, TxOut (ShelleyLedgerEra era))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)]
Map TxIn (TxOut CtxUTxO era)
-> [Item (Map TxIn (TxOut CtxUTxO era))]
forall l. IsList l => l -> [Item l]
toList
    (Map TxIn (TxOut CtxUTxO era) -> UTxO (ShelleyLedgerEra era))
-> Map TxIn (TxOut CtxUTxO era) -> UTxO (ShelleyLedgerEra era)
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut CtxUTxO era)
utxo

fromLedgerUTxO
  :: ()
  => ShelleyBasedEra era
  -> Shelley.UTxO (ShelleyLedgerEra era)
  -> UTxO era
fromLedgerUTxO :: forall era.
ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
fromLedgerUTxO ShelleyBasedEra era
sbe (Shelley.UTxO Map TxIn (TxOut (ShelleyLedgerEra era))
utxo) =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => UTxO era) -> UTxO era
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe
    ((ShelleyBasedEraConstraints era => UTxO era) -> UTxO era)
-> (ShelleyBasedEraConstraints era => UTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO
      (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (Map TxIn (TxOut (ShelleyLedgerEra era))
    -> Map TxIn (TxOut CtxUTxO era))
-> Map TxIn (TxOut (ShelleyLedgerEra era))
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era)
[Item (Map TxIn (TxOut CtxUTxO era))]
-> Map TxIn (TxOut CtxUTxO era)
forall l. IsList l => [Item l] -> l
fromList
      ([(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era))
-> (Map TxIn (TxOut (ShelleyLedgerEra era))
    -> [(TxIn, TxOut CtxUTxO era)])
-> Map TxIn (TxOut (ShelleyLedgerEra era))
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxIn, TxOut (ShelleyLedgerEra era)) -> (TxIn, TxOut CtxUTxO era))
-> [(TxIn, TxOut (ShelleyLedgerEra era))]
-> [(TxIn, TxOut CtxUTxO era)]
forall a b. (a -> b) -> [a] -> [b]
map ((TxIn -> TxIn)
-> (TxOut (ShelleyLedgerEra era) -> TxOut CtxUTxO era)
-> (TxIn, TxOut (ShelleyLedgerEra era))
-> (TxIn, TxOut CtxUTxO era)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap TxIn -> TxIn
fromShelleyTxIn (ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut CtxUTxO era
forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe))
      ([(TxIn, TxOut (ShelleyLedgerEra era))]
 -> [(TxIn, TxOut CtxUTxO era)])
-> (Map TxIn (TxOut (ShelleyLedgerEra era))
    -> [(TxIn, TxOut (ShelleyLedgerEra era))])
-> Map TxIn (TxOut (ShelleyLedgerEra era))
-> [(TxIn, TxOut CtxUTxO era)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map TxIn (TxOut (ShelleyLedgerEra era))
-> [(TxIn, TxOut (ShelleyLedgerEra era))]
Map TxIn (TxOut (ShelleyLedgerEra era))
-> [Item (Map TxIn (TxOut (ShelleyLedgerEra era)))]
forall l. IsList l => l -> [Item l]
toList
    (Map TxIn (TxOut (ShelleyLedgerEra era)) -> UTxO era)
-> Map TxIn (TxOut (ShelleyLedgerEra era)) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut (ShelleyLedgerEra era))
utxo

fromShelleyPoolDistr
  :: Consensus.PoolDistr StandardCrypto
  -> Map (Hash StakePoolKey) Rational
fromShelleyPoolDistr :: PoolDistr StandardCrypto -> Map (Hash StakePoolKey) Rational
fromShelleyPoolDistr =
  -- TODO: write an appropriate property to show it is safe to use
  -- Map.fromListAsc or to use Map.mapKeysMonotonic
  [(Hash StakePoolKey, Rational)] -> Map (Hash StakePoolKey) Rational
[Item (Map (Hash StakePoolKey) Rational)]
-> Map (Hash StakePoolKey) Rational
forall l. IsList l => [Item l] -> l
fromList
    ([(Hash StakePoolKey, Rational)]
 -> Map (Hash StakePoolKey) Rational)
-> (PoolDistr StandardCrypto -> [(Hash StakePoolKey, Rational)])
-> PoolDistr StandardCrypto
-> Map (Hash StakePoolKey) Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((KeyHash 'StakePool, IndividualPoolStake StandardCrypto)
 -> (Hash StakePoolKey, Rational))
-> [(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)]
-> [(Hash StakePoolKey, Rational)]
forall a b. (a -> b) -> [a] -> [b]
map ((KeyHash 'StakePool -> Hash StakePoolKey)
-> (IndividualPoolStake StandardCrypto -> Rational)
-> (KeyHash 'StakePool, IndividualPoolStake StandardCrypto)
-> (Hash StakePoolKey, Rational)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap KeyHash 'StakePool -> Hash StakePoolKey
StakePoolKeyHash IndividualPoolStake StandardCrypto -> Rational
forall c. IndividualPoolStake c -> Rational
Consensus.individualPoolStake)
    ([(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)]
 -> [(Hash StakePoolKey, Rational)])
-> (PoolDistr StandardCrypto
    -> [(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)])
-> PoolDistr StandardCrypto
-> [(Hash StakePoolKey, Rational)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto)
-> [(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)]
Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto)
-> [Item
      (Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto))]
forall l. IsList l => l -> [Item l]
toList
    (Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto)
 -> [(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)])
-> (PoolDistr StandardCrypto
    -> Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto))
-> PoolDistr StandardCrypto
-> [(KeyHash 'StakePool, IndividualPoolStake StandardCrypto)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoolDistr StandardCrypto
-> Map (KeyHash 'StakePool) (IndividualPoolStake StandardCrypto)
forall c.
PoolDistr c -> Map (KeyHash 'StakePool) (IndividualPoolStake c)
Consensus.unPoolDistr

fromShelleyDelegations
  :: Map
       (Shelley.Credential Shelley.Staking)
       (Shelley.KeyHash Shelley.StakePool)
  -> Map StakeCredential PoolId
fromShelleyDelegations :: Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map StakeCredential (Hash StakePoolKey)
fromShelleyDelegations =
  -- TODO: write an appropriate property to show it is safe to use
  -- Map.fromListAsc or to use Map.mapKeysMonotonic
  -- In this case it may not be: the Ord instances for Shelley.Credential
  -- do not match the one for StakeCredential
  [(StakeCredential, Hash StakePoolKey)]
-> Map StakeCredential (Hash StakePoolKey)
[Item (Map StakeCredential (Hash StakePoolKey))]
-> Map StakeCredential (Hash StakePoolKey)
forall l. IsList l => [Item l] -> l
fromList
    ([(StakeCredential, Hash StakePoolKey)]
 -> Map StakeCredential (Hash StakePoolKey))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> [(StakeCredential, Hash StakePoolKey)])
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map StakeCredential (Hash StakePoolKey)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Credential 'Staking, KeyHash 'StakePool)
 -> (StakeCredential, Hash StakePoolKey))
-> [(Credential 'Staking, KeyHash 'StakePool)]
-> [(StakeCredential, Hash StakePoolKey)]
forall a b. (a -> b) -> [a] -> [b]
map ((Credential 'Staking -> StakeCredential)
-> (KeyHash 'StakePool -> Hash StakePoolKey)
-> (Credential 'Staking, KeyHash 'StakePool)
-> (StakeCredential, Hash StakePoolKey)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap Credential 'Staking -> StakeCredential
fromShelleyStakeCredential KeyHash 'StakePool -> Hash StakePoolKey
StakePoolKeyHash)
    ([(Credential 'Staking, KeyHash 'StakePool)]
 -> [(StakeCredential, Hash StakePoolKey)])
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> [(Credential 'Staking, KeyHash 'StakePool)])
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> [(StakeCredential, Hash StakePoolKey)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (Credential 'Staking) (KeyHash 'StakePool)
-> [(Credential 'Staking, KeyHash 'StakePool)]
Map (Credential 'Staking) (KeyHash 'StakePool)
-> [Item (Map (Credential 'Staking) (KeyHash 'StakePool))]
forall l. IsList l => l -> [Item l]
toList

fromShelleyRewardAccounts
  :: Map (Shelley.Credential 'Core.Staking) L.Coin
  -> Map StakeCredential L.Coin
fromShelleyRewardAccounts :: Map (Credential 'Staking) Coin -> Map StakeCredential Coin
fromShelleyRewardAccounts =
  -- TODO: write an appropriate property to show it is safe to use
  -- Map.fromListAsc or to use Map.mapKeysMonotonic
  [(StakeCredential, Coin)] -> Map StakeCredential Coin
[Item (Map StakeCredential Coin)] -> Map StakeCredential Coin
forall l. IsList l => [Item l] -> l
fromList
    ([(StakeCredential, Coin)] -> Map StakeCredential Coin)
-> (Map (Credential 'Staking) Coin -> [(StakeCredential, Coin)])
-> Map (Credential 'Staking) Coin
-> Map StakeCredential Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Credential 'Staking, Coin) -> (StakeCredential, Coin))
-> [(Credential 'Staking, Coin)] -> [(StakeCredential, Coin)]
forall a b. (a -> b) -> [a] -> [b]
map ((Credential 'Staking -> StakeCredential)
-> (Credential 'Staking, Coin) -> (StakeCredential, Coin)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Credential 'Staking -> StakeCredential
fromShelleyStakeCredential)
    ([(Credential 'Staking, Coin)] -> [(StakeCredential, Coin)])
-> (Map (Credential 'Staking) Coin
    -> [(Credential 'Staking, Coin)])
-> Map (Credential 'Staking) Coin
-> [(StakeCredential, Coin)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (Credential 'Staking) Coin -> [(Credential 'Staking, Coin)]
Map (Credential 'Staking) Coin
-> [Item (Map (Credential 'Staking) Coin)]
forall l. IsList l => l -> [Item l]
toList

-- ----------------------------------------------------------------------------
-- Conversions of queries into the consensus types.
--

toConsensusQuery
  :: forall block result
   . ()
  => Consensus.CardanoBlock StandardCrypto ~ block
  => QueryInMode result
  -> Some (Consensus.Query block)
toConsensusQuery :: forall block result.
(CardanoBlock StandardCrypto ~ block) =>
QueryInMode result -> Some (Query block)
toConsensusQuery QueryInMode result
QueryCurrentEra =
  Query block (EraIndex (CardanoEras StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (Query block (EraIndex (CardanoEras StandardCrypto))
 -> Some (Query block))
-> Query block (EraIndex (CardanoEras StandardCrypto))
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
    BlockQuery block (EraIndex (CardanoEras StandardCrypto))
-> Query block (EraIndex (CardanoEras StandardCrypto))
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery (BlockQuery block (EraIndex (CardanoEras StandardCrypto))
 -> Query block (EraIndex (CardanoEras StandardCrypto)))
-> BlockQuery block (EraIndex (CardanoEras StandardCrypto))
-> Query block (EraIndex (CardanoEras StandardCrypto))
forall a b. (a -> b) -> a -> b
$
      QueryHardFork
  (CardanoEras StandardCrypto)
  (EraIndex (CardanoEras StandardCrypto))
-> BlockQuery
     (CardanoBlock StandardCrypto)
     (EraIndex (CardanoEras StandardCrypto))
forall (xs1 :: [*]) x a.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) a -> BlockQuery (HardForkBlock (x : xs1)) a
Consensus.QueryHardFork
        QueryHardFork
  (CardanoEras StandardCrypto)
  (EraIndex (CardanoEras StandardCrypto))
forall (xs :: [*]). QueryHardFork xs (EraIndex xs)
Consensus.GetCurrentEra
toConsensusQuery QueryInMode result
QueryEraHistory =
  Query block (Interpreter (CardanoEras StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (Query block (Interpreter (CardanoEras StandardCrypto))
 -> Some (Query block))
-> Query block (Interpreter (CardanoEras StandardCrypto))
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
    BlockQuery block (Interpreter (CardanoEras StandardCrypto))
-> Query block (Interpreter (CardanoEras StandardCrypto))
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery (BlockQuery block (Interpreter (CardanoEras StandardCrypto))
 -> Query block (Interpreter (CardanoEras StandardCrypto)))
-> BlockQuery block (Interpreter (CardanoEras StandardCrypto))
-> Query block (Interpreter (CardanoEras StandardCrypto))
forall a b. (a -> b) -> a -> b
$
      QueryHardFork
  (CardanoEras StandardCrypto)
  (Interpreter (CardanoEras StandardCrypto))
-> BlockQuery
     (CardanoBlock StandardCrypto)
     (Interpreter (CardanoEras StandardCrypto))
forall (xs1 :: [*]) x a.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) a -> BlockQuery (HardForkBlock (x : xs1)) a
Consensus.QueryHardFork
        QueryHardFork
  (CardanoEras StandardCrypto)
  (Interpreter (CardanoEras StandardCrypto))
forall (xs :: [*]). QueryHardFork xs (Interpreter xs)
Consensus.GetInterpreter
toConsensusQuery QueryInMode result
QuerySystemStart = Query block SystemStart -> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some Query block SystemStart
forall blk. Query blk SystemStart
Consensus.GetSystemStart
toConsensusQuery QueryInMode result
QueryChainBlockNo = Query block (WithOrigin BlockNo) -> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some Query block (WithOrigin BlockNo)
forall blk. Query blk (WithOrigin BlockNo)
Consensus.GetChainBlockNo
toConsensusQuery QueryInMode result
QueryChainPoint = Query block (Point block) -> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some Query block (Point block)
forall blk. Query blk (Point blk)
Consensus.GetChainPoint
toConsensusQuery (QueryInEra QueryInEra era result
QueryByronUpdateState) =
  Query block (CardanoQueryResult StandardCrypto State)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (Query block (CardanoQueryResult StandardCrypto State)
 -> Some (Query block))
-> Query block (CardanoQueryResult StandardCrypto State)
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
    BlockQuery block (CardanoQueryResult StandardCrypto State)
-> Query block (CardanoQueryResult StandardCrypto State)
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery (BlockQuery block (CardanoQueryResult StandardCrypto State)
 -> Query block (CardanoQueryResult StandardCrypto State))
-> BlockQuery block (CardanoQueryResult StandardCrypto State)
-> Query block (CardanoQueryResult StandardCrypto State)
forall a b. (a -> b) -> a -> b
$
      BlockQuery ByronBlock State
-> CardanoQuery
     StandardCrypto (CardanoQueryResult StandardCrypto State)
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery ByronBlock result -> CardanoQuery c a
Consensus.QueryIfCurrentByron
        BlockQuery ByronBlock State
Consensus.GetUpdateInterfaceState
toConsensusQuery (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
sbe QueryInShelleyBasedEra era result
q)) =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => Some (Query block))
-> Some (Query block)
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => Some (Query block))
 -> Some (Query block))
-> (ShelleyBasedEraConstraints era => Some (Query block))
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era
-> QueryInShelleyBasedEra era result -> Some (Query block)
forall era protocol block result.
(ConsensusBlockForEra era
 ~ ShelleyBlock protocol (ShelleyLedgerEra era),
 CardanoBlock StandardCrypto ~ block) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result -> Some (Query block)
toConsensusQueryShelleyBased ShelleyBasedEra era
sbe QueryInShelleyBasedEra era result
q
toConsensusQuery QueryInMode result
QueryLedgerConfig = Query block (HardForkLedgerConfig (CardanoEras StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some Query block (LedgerCfg (LedgerState block))
Query block (HardForkLedgerConfig (CardanoEras StandardCrypto))
forall blk. Query blk (LedgerCfg (LedgerState blk))
Consensus.GetLedgerConfig

toConsensusQueryShelleyBased
  :: forall era protocol block result
   . ()
  => ConsensusBlockForEra era ~ Consensus.ShelleyBlock protocol (ShelleyLedgerEra era)
  => Consensus.CardanoBlock StandardCrypto ~ block
  => ShelleyBasedEra era
  -> QueryInShelleyBasedEra era result
  -> Some (Consensus.Query block)
toConsensusQueryShelleyBased :: forall era protocol block result.
(ConsensusBlockForEra era
 ~ ShelleyBlock protocol (ShelleyLedgerEra era),
 CardanoBlock StandardCrypto ~ block) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result -> Some (Query block)
toConsensusQueryShelleyBased ShelleyBasedEra era
sbe = \case
  QueryInShelleyBasedEra era result
QueryEpoch ->
    Query
  block (HardForkQueryResult (CardanoEras StandardCrypto) EpochNo)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) EpochNo
-> Query
     block (HardForkQueryResult (CardanoEras StandardCrypto) EpochNo)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery (ShelleyBlock protocol (ShelleyLedgerEra era)) EpochNo
forall proto era. BlockQuery (ShelleyBlock proto era) EpochNo
Consensus.GetEpochNo)
  QueryInShelleyBasedEra era result
QueryConstitution ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      (Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$ String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryConstitution is only available in the Conway era")
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Constitution (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Constitution (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Constitution (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (Constitution (ShelleyLedgerEra era))
forall era proto.
ConwayEraGov era =>
BlockQuery (ShelleyBlock proto era) (Constitution era)
Consensus.GetConstitution))
      ShelleyBasedEra era
sbe
  QueryInShelleyBasedEra era result
QueryGenesisParameters ->
    Query
  block
  (HardForkQueryResult (CardanoEras StandardCrypto) CompactGenesis)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) CompactGenesis
-> Query
     block
     (HardForkQueryResult (CardanoEras StandardCrypto) CompactGenesis)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era)) CompactGenesis
forall proto era.
BlockQuery (ShelleyBlock proto era) CompactGenesis
Consensus.GetGenesisConfig)
  QueryInShelleyBasedEra era result
QueryProtocolParameters ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (PParams (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PParams (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (PParams (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (PParams (ShelleyLedgerEra era))
forall proto era. BlockQuery (ShelleyBlock proto era) (PParams era)
Consensus.GetCurrentPParams)
  QueryInShelleyBasedEra era result
QueryStakeDistribution ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (PoolDistr (ProtoCrypto protocol)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PoolDistr (ProtoCrypto protocol))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (PoolDistr (ProtoCrypto protocol)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (PoolDistr (ProtoCrypto protocol))
forall proto era.
BlockQuery (ShelleyBlock proto era) (PoolDistr (ProtoCrypto proto))
Consensus.GetStakeDistribution)
  QueryUTxO QueryUTxOFilter
QueryUTxOWhole ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (UTxO (ShelleyLedgerEra era))
forall proto era. BlockQuery (ShelleyBlock proto era) (UTxO era)
Consensus.GetUTxOWhole)
  QueryUTxO (QueryUTxOByAddress Set AddressAny
addrs) ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set Addr
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
forall proto era.
Set Addr -> BlockQuery (ShelleyBlock proto era) (UTxO era)
Consensus.GetUTxOByAddress Set Addr
addrs'))
   where
    addrs' :: Set Shelley.Addr
    addrs' :: Set Addr
addrs' = CardanoEra era -> Set AddressAny -> Set Addr
forall era. CardanoEra era -> Set AddressAny -> Set Addr
toShelleyAddrSet CardanoEra era
era Set AddressAny
addrs
  QueryUTxO (QueryUTxOByTxIn Set TxIn
txins) ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (UTxO (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set TxIn
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
forall proto era.
Set TxIn -> BlockQuery (ShelleyBlock proto era) (UTxO era)
Consensus.GetUTxOByTxIn Set TxIn
txins'))
   where
    txins' :: Set Shelley.TxIn
    txins' :: Set TxIn
txins' = (TxIn -> TxIn) -> Set TxIn -> Set TxIn
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map TxIn -> TxIn
toShelleyTxIn Set TxIn
txins
  QueryStakeAddresses Set StakeCredential
creds NetworkId
_nId ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Map (Credential 'Staking) (KeyHash 'StakePool),
      Map (Credential 'Staking) Coin))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) (KeyHash 'StakePool),
      Map (Credential 'Staking) Coin)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Map (Credential 'Staking) (KeyHash 'StakePool),
         Map (Credential 'Staking) Coin))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode
          CardanoEra era
era
          (Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) (KeyHash 'StakePool),
      Map (Credential 'Staking) Coin)
forall proto era.
Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock proto era)
     (Map (Credential 'Staking) (KeyHash 'StakePool),
      Map (Credential 'Staking) Coin)
Consensus.GetFilteredDelegationsAndRewardAccounts Set (Credential 'Staking)
creds')
      )
   where
    creds' :: Set (Shelley.Credential Shelley.Staking)
    creds' :: Set (Credential 'Staking)
creds' = (StakeCredential -> Credential 'Staking)
-> Set StakeCredential -> Set (Credential 'Staking)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking
toShelleyStakeCredential Set StakeCredential
creds
  QueryInShelleyBasedEra era result
QueryStakePools ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Set (KeyHash 'StakePool)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Set (KeyHash 'StakePool))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Set (KeyHash 'StakePool)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (Set (KeyHash 'StakePool))
forall proto era.
BlockQuery (ShelleyBlock proto era) (Set (KeyHash 'StakePool))
Consensus.GetStakePools)
  QueryStakePoolParameters Set (Hash StakePoolKey)
poolids ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Map (KeyHash 'StakePool) PoolParams))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (KeyHash 'StakePool) PoolParams)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Map (KeyHash 'StakePool) PoolParams))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set (KeyHash 'StakePool)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (KeyHash 'StakePool) PoolParams)
forall proto era.
Set (KeyHash 'StakePool)
-> BlockQuery
     (ShelleyBlock proto era) (Map (KeyHash 'StakePool) PoolParams)
Consensus.GetStakePoolParams Set (KeyHash 'StakePool)
poolids'))
   where
    poolids' :: Set (Shelley.KeyHash Shelley.StakePool)
    poolids' :: Set (KeyHash 'StakePool)
poolids' = (Hash StakePoolKey -> KeyHash 'StakePool)
-> Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool
unStakePoolKeyHash Set (Hash StakePoolKey)
poolids
  QueryInShelleyBasedEra era result
QueryDebugLedgerState ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Serialised (NewEpochState (ShelleyLedgerEra era))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (NewEpochState (ShelleyLedgerEra era)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Serialised (NewEpochState (ShelleyLedgerEra era))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (NewEpochState (ShelleyLedgerEra era))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (NewEpochState (ShelleyLedgerEra era)))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (NewEpochState (ShelleyLedgerEra era))
forall proto era.
BlockQuery (ShelleyBlock proto era) (NewEpochState era)
Consensus.DebugNewEpochState))
  QueryInShelleyBasedEra era result
QueryProtocolState ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Serialised (ChainDepState protocol)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (ChainDepState protocol))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Serialised (ChainDepState protocol)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (ChainDepState protocol)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (ChainDepState protocol))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (ChainDepState protocol)
forall proto era.
BlockQuery (ShelleyBlock proto era) (ChainDepState proto)
Consensus.DebugChainDepState))
  QueryInShelleyBasedEra era result
QueryCurrentEpochState ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Serialised (EpochState (ShelleyLedgerEra era))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (EpochState (ShelleyLedgerEra era)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Serialised (EpochState (ShelleyLedgerEra era))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (EpochState (ShelleyLedgerEra era))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (EpochState (ShelleyLedgerEra era)))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (EpochState (ShelleyLedgerEra era))
forall proto era.
BlockQuery (ShelleyBlock proto era) (EpochState era)
Consensus.DebugEpochState))
  QueryPoolState Maybe (Set (Hash StakePoolKey))
poolIds ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Serialised (PState (ShelleyLedgerEra era))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PState (ShelleyLedgerEra era)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Serialised (PState (ShelleyLedgerEra era))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode
          CardanoEra era
era
          (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (PState (ShelleyLedgerEra era))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PState (ShelleyLedgerEra era)))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR (Maybe (Set (KeyHash 'StakePool))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PState (ShelleyLedgerEra era))
forall proto era.
Maybe (Set (KeyHash 'StakePool))
-> BlockQuery (ShelleyBlock proto era) (PState era)
Consensus.GetPoolState ((Hash StakePoolKey -> KeyHash 'StakePool)
-> Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool
unStakePoolKeyHash (Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Set (Hash StakePoolKey))
poolIds)))
      )
  QueryStakeSnapshot Maybe (Set (Hash StakePoolKey))
mPoolIds ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Serialised StakeSnapshots))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised StakeSnapshots)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Serialised StakeSnapshots))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode
          CardanoEra era
era
          (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era)) StakeSnapshots
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised StakeSnapshots)
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR (Maybe (Set (KeyHash 'StakePool))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) StakeSnapshots
forall proto era.
Maybe (Set (KeyHash 'StakePool))
-> BlockQuery (ShelleyBlock proto era) StakeSnapshots
Consensus.GetStakeSnapshots ((Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool))
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Hash StakePoolKey -> KeyHash 'StakePool)
-> Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool
unStakePoolKeyHash) Maybe (Set (Hash StakePoolKey))
mPoolIds)))
      )
  QueryPoolDistribution Maybe (Set (Hash StakePoolKey))
poolIds ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Serialised (PoolDistr (ProtoCrypto protocol))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PoolDistr (ProtoCrypto protocol)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Serialised (PoolDistr (ProtoCrypto protocol))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (PoolDistr (ProtoCrypto protocol))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PoolDistr (ProtoCrypto protocol)))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR (Maybe (Set (KeyHash 'StakePool))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PoolDistr (ProtoCrypto protocol))
forall proto era.
Maybe (Set (KeyHash 'StakePool))
-> BlockQuery
     (ShelleyBlock proto era) (PoolDistr (ProtoCrypto proto))
Consensus.GetPoolDistr (Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
getPoolIds (Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Set (Hash StakePoolKey))
poolIds))))
   where
    getPoolIds :: Set PoolId -> Set (Shelley.KeyHash Shelley.StakePool)
    getPoolIds :: Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
getPoolIds = (Hash StakePoolKey -> KeyHash 'StakePool)
-> Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(StakePoolKeyHash KeyHash 'StakePool
kh) -> KeyHash 'StakePool
kh)
  QueryStakeDelegDeposits Set StakeCredential
creds ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Map (Credential 'Staking) Coin))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) Coin)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Map (Credential 'Staking) Coin))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) Coin)
forall proto era.
Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock proto era) (Map (Credential 'Staking) Coin)
Consensus.GetStakeDelegDeposits Set (Credential 'Staking)
creds'))
   where
    creds' :: Set (Credential 'Staking)
creds' = (StakeCredential -> Credential 'Staking)
-> Set StakeCredential -> Set (Credential 'Staking)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking
toShelleyStakeCredential Set StakeCredential
creds
  QueryInShelleyBasedEra era result
QueryAccountState ->
    Query
  block
  (HardForkQueryResult (CardanoEras StandardCrypto) AccountState)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) AccountState
-> Query
     block
     (HardForkQueryResult (CardanoEras StandardCrypto) AccountState)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era)) AccountState
forall proto era. BlockQuery (ShelleyBlock proto era) AccountState
Consensus.GetAccountState)
  QueryInShelleyBasedEra era result
QueryGovState ->
    Query
  block (HardForkQueryResult (CardanoEras StandardCrypto) result)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery (ShelleyBlock protocol (ShelleyLedgerEra era)) result
-> Query
     block (HardForkQueryResult (CardanoEras StandardCrypto) result)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery (ShelleyBlock protocol (ShelleyLedgerEra era)) result
BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (GovState (ShelleyLedgerEra era))
forall proto era.
BlockQuery (ShelleyBlock proto era) (GovState era)
Consensus.GetGovState)
  QueryInShelleyBasedEra era result
QueryRatifyState ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      (Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$ String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryRatifyState is only available in the Conway era")
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (RatifyState (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (RatifyState (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (RatifyState (ShelleyLedgerEra era)))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (RatifyState (ShelleyLedgerEra era))
forall era proto.
ConwayEraGov era =>
BlockQuery (ShelleyBlock proto era) (RatifyState era)
Consensus.GetRatifyState))
      ShelleyBasedEra era
sbe
  QueryInShelleyBasedEra era result
QueryFuturePParams ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryFuturePParams is only available in the Conway era onwards"
      )
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Maybe (PParams (ShelleyLedgerEra era))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Maybe (PParams (ShelleyLedgerEra era)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Maybe (PParams (ShelleyLedgerEra era))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (Maybe (PParams (ShelleyLedgerEra era)))
forall proto era.
BlockQuery (ShelleyBlock proto era) (Maybe (PParams era))
Consensus.GetFuturePParams))
      ShelleyBasedEra era
sbe
  QueryDRepState Set (Credential 'DRepRole)
creds ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      (Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$ String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryDRepState is only available in the Conway era")
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Map (Credential 'DRepRole) DRepState))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'DRepRole) DRepState)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Map (Credential 'DRepRole) DRepState))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set (Credential 'DRepRole)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'DRepRole) DRepState)
forall era proto.
ConwayEraGov era =>
Set (Credential 'DRepRole)
-> BlockQuery
     (ShelleyBlock proto era) (Map (Credential 'DRepRole) DRepState)
Consensus.GetDRepState Set (Credential 'DRepRole)
creds)))
      ShelleyBasedEra era
sbe
  QueryDRepStakeDistr Set DRep
dreps ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryDRepStakeDistr is only available in the Conway era"
      )
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult (CardanoEras StandardCrypto) (Map DRep Coin))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) (Map DRep Coin)
-> Query
     block
     (HardForkQueryResult (CardanoEras StandardCrypto) (Map DRep Coin))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set DRep
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) (Map DRep Coin)
forall era proto.
ConwayEraGov era =>
Set DRep -> BlockQuery (ShelleyBlock proto era) (Map DRep Coin)
Consensus.GetDRepStakeDistr Set DRep
dreps)))
      ShelleyBasedEra era
sbe
  QuerySPOStakeDistr Set (KeyHash 'StakePool)
spos ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QuerySPOStakeDistr is only available in the Conway era"
      )
      (Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$ Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Map (KeyHash 'StakePool) Coin))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (KeyHash 'StakePool) Coin)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Map (KeyHash 'StakePool) Coin))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set (KeyHash 'StakePool)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (KeyHash 'StakePool) Coin)
forall era proto.
ConwayEraGov era =>
Set (KeyHash 'StakePool)
-> BlockQuery
     (ShelleyBlock proto era) (Map (KeyHash 'StakePool) Coin)
Consensus.GetSPOStakeDistr Set (KeyHash 'StakePool)
spos)))
      ShelleyBasedEra era
sbe
  QueryCommitteeMembersState Set (Credential 'ColdCommitteeRole)
coldCreds Set (Credential 'HotCommitteeRole)
hotCreds Set MemberStatus
statuses ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryCommitteeMembersState is only available in the Conway era"
      )
      ( Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) CommitteeMembersState)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     CommitteeMembersState
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) CommitteeMembersState)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set (Credential 'ColdCommitteeRole)
-> Set (Credential 'HotCommitteeRole)
-> Set MemberStatus
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     CommitteeMembersState
forall era proto.
ConwayEraGov era =>
Set (Credential 'ColdCommitteeRole)
-> Set (Credential 'HotCommitteeRole)
-> Set MemberStatus
-> BlockQuery (ShelleyBlock proto era) CommitteeMembersState
Consensus.GetCommitteeMembersState Set (Credential 'ColdCommitteeRole)
coldCreds Set (Credential 'HotCommitteeRole)
hotCreds Set MemberStatus
statuses))
      )
      ShelleyBasedEra era
sbe
  QueryStakeVoteDelegatees Set StakeCredential
creds ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryStakeVoteDelegatees is only available in the Conway era"
      )
      ( Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Map (Credential 'Staking) DRep))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) DRep)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Map (Credential 'Staking) DRep))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode
                CardanoEra era
era
                (Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking) DRep)
forall era proto.
ConwayEraGov era =>
Set (Credential 'Staking)
-> BlockQuery
     (ShelleyBlock proto era) (Map (Credential 'Staking) DRep)
Consensus.GetFilteredVoteDelegatees Set (Credential 'Staking)
creds')
            )
      )
      ShelleyBasedEra era
sbe
   where
    creds' :: Set (Shelley.Credential Shelley.Staking)
    creds' :: Set (Credential 'Staking)
creds' = (StakeCredential -> Credential 'Staking)
-> Set StakeCredential -> Set (Credential 'Staking)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking
toShelleyStakeCredential Set StakeCredential
creds
  QueryProposals Set GovActionId
govActs ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryProposals is only available in the Conway era"
      )
      ( Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto)
     (Seq (GovActionState (ShelleyLedgerEra era))))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Seq (GovActionState (ShelleyLedgerEra era)))
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto)
        (Seq (GovActionState (ShelleyLedgerEra era))))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (Set GovActionId
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Seq (GovActionState (ShelleyLedgerEra era)))
forall era proto.
ConwayEraGov era =>
Set GovActionId
-> BlockQuery (ShelleyBlock proto era) (Seq (GovActionState era))
Consensus.GetProposals Set GovActionId
govActs))
      )
      ShelleyBasedEra era
sbe
  QueryInShelleyBasedEra era result
QueryLedgerPeerSnapshot ->
    Query
  block
  (HardForkQueryResult
     (CardanoEras StandardCrypto) (Serialised LedgerPeerSnapshot))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised LedgerPeerSnapshot)
-> Query
     block
     (HardForkQueryResult
        (CardanoEras StandardCrypto) (Serialised LedgerPeerSnapshot))
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era)) LedgerPeerSnapshot
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised LedgerPeerSnapshot)
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era)) LedgerPeerSnapshot
forall proto era.
BlockQuery (ShelleyBlock proto era) LedgerPeerSnapshot
Consensus.GetBigLedgerPeerSnapshot))
  QueryStakePoolDefaultVote KeyHash 'StakePool
govActs ->
    (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Some (Query block))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Some (Query block))
-> ShelleyBasedEra era
-> Some (Query block)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
      ( Some (Query block) -> ShelleyToBabbageEra era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block)
 -> ShelleyToBabbageEra era -> Some (Query block))
-> Some (Query block)
-> ShelleyToBabbageEra era
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          String -> Some (Query block)
forall a. HasCallStack => String -> a
error String
"toConsensusQueryShelleyBased: QueryStakePoolDefaultVote is only available in the Conway era"
      )
      ( Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. a -> b -> a
const (Some (Query block) -> ConwayEraOnwards era -> Some (Query block))
-> Some (Query block) -> ConwayEraOnwards era -> Some (Query block)
forall a b. (a -> b) -> a -> b
$
          Query
  block
  (HardForkQueryResult (CardanoEras StandardCrypto) DefaultVote)
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) DefaultVote
-> Query
     block
     (HardForkQueryResult (CardanoEras StandardCrypto) DefaultVote)
forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era (KeyHash 'StakePool
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era)) DefaultVote
forall era proto.
ConwayEraGov era =>
KeyHash 'StakePool
-> BlockQuery (ShelleyBlock proto era) DefaultVote
Consensus.QueryStakePoolDefaultVote KeyHash 'StakePool
govActs))
      )
      ShelleyBasedEra era
sbe
 where
  era :: CardanoEra era
era = ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyBasedEra era
sbe

consensusQueryInEraInMode
  :: forall era erablock modeblock result result' xs
   . ConsensusBlockForEra era ~ erablock
  => Consensus.CardanoBlock StandardCrypto ~ modeblock
  => modeblock ~ Consensus.HardForkBlock xs
  => Consensus.HardForkQueryResult xs result ~ result'
  => CardanoEra era
  -> Consensus.BlockQuery erablock result
  -> Consensus.Query modeblock result'
consensusQueryInEraInMode :: forall era erablock modeblock result result' (xs :: [*]).
(ConsensusBlockForEra era ~ erablock,
 CardanoBlock StandardCrypto ~ modeblock,
 modeblock ~ HardForkBlock xs,
 HardForkQueryResult xs result ~ result') =>
CardanoEra era
-> BlockQuery erablock result -> Query modeblock result'
consensusQueryInEraInMode CardanoEra era
era =
  BlockQuery modeblock result' -> Query modeblock result'
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery
    (BlockQuery modeblock result' -> Query modeblock result')
-> (BlockQuery erablock result -> BlockQuery modeblock result')
-> BlockQuery erablock result
-> Query modeblock result'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. case CardanoEra era
era of
      CardanoEra era
ByronEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery ByronBlock result -> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery ByronBlock result -> CardanoQuery c a
Consensus.QueryIfCurrentByron
      CardanoEra era
ShelleyEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) ShelleyEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentShelley
      CardanoEra era
AllegraEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (TPraos StandardCrypto) AllegraEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AllegraEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentAllegra
      CardanoEra era
MaryEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) MaryEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentMary
      CardanoEra era
AlonzoEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) AlonzoEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentAlonzo
      CardanoEra era
BabbageEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (Praos StandardCrypto) BabbageEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) BabbageEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentBabbage
      CardanoEra era
ConwayEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery (ShelleyBlock (Praos StandardCrypto) ConwayEra) result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) ConwayEra) result
-> CardanoQuery c a
Consensus.QueryIfCurrentConway

-- ----------------------------------------------------------------------------
-- Conversions of query results from the consensus types.
--

fromConsensusQueryResult
  :: forall block result result'
   . ()
  => HasCallStack
  => Consensus.CardanoBlock StandardCrypto ~ block
  => QueryInMode result
  -> Consensus.Query block result'
  -> result'
  -> result
fromConsensusQueryResult :: forall block result result'.
(HasCallStack, CardanoBlock StandardCrypto ~ block) =>
QueryInMode result -> Query block result' -> result' -> result
fromConsensusQueryResult QueryInMode result
QueryEraHistory Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryHardFork QueryHardFork (x : xs1) result'
Consensus.GetInterpreter) ->
      Interpreter (CardanoEras StandardCrypto) -> EraHistory
forall (xs :: [*]).
(CardanoBlock StandardCrypto ~ HardForkBlock xs) =>
Interpreter xs -> EraHistory
EraHistory result'
Interpreter (CardanoEras StandardCrypto)
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult QueryInMode result
QuerySystemStart Query block result'
q' result'
r' =
  case Query block result'
q' of
    Query block result'
Consensus.GetSystemStart ->
      result
result'
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult QueryInMode result
QueryChainBlockNo Query block result'
q' result'
r' =
  case Query block result'
q' of
    Query block result'
Consensus.GetChainBlockNo ->
      result
result'
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult QueryInMode result
QueryChainPoint Query block result'
q' result'
r' =
  case Query block result'
q' of
    Query block result'
Consensus.GetChainPoint ->
      Point (CardanoBlock StandardCrypto) -> ChainPoint
forall block (xs :: [*]).
(HeaderHash block ~ OneEraHash xs) =>
Point block -> ChainPoint
fromConsensusPointHF result'
Point (CardanoBlock StandardCrypto)
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult QueryInMode result
QueryCurrentEra Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryHardFork QueryHardFork (x : xs1) result'
Consensus.GetCurrentEra) ->
      EraIndex (CardanoEras StandardCrypto) -> AnyCardanoEra
fromConsensusEraIndex result'
EraIndex (CardanoEras StandardCrypto)
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult QueryInMode result
QueryLedgerConfig Query block result'
q' result'
r' =
  case Query block result'
q' of
    Query block result'
Consensus.GetLedgerConfig ->
      result
result'
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra QueryInEra era result
QueryByronUpdateState) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery
      (Consensus.QueryIfCurrentByron BlockQuery ByronBlock result
R:BlockQueryByronBlock result
Consensus.GetUpdateInterfaceState) ->
        (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (State -> ByronUpdateState)
-> CardanoQueryResult StandardCrypto State
-> Either EraMismatch ByronUpdateState
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch State -> ByronUpdateState
ByronUpdateState result'
CardanoQueryResult StandardCrypto State
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraShelley QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentShelley BlockQuery (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra ShelleyEra
-> QueryInShelleyBasedEra ShelleyEra result
-> BlockQuery
     (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra ShelleyEra result
q
            BlockQuery (ShelleyBlock (TPraos StandardCrypto) ShelleyEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraAllegra QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentAllegra BlockQuery (ShelleyBlock (TPraos StandardCrypto) AllegraEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra AllegraEra
-> QueryInShelleyBasedEra AllegraEra result
-> BlockQuery
     (ShelleyBlock (TPraos StandardCrypto) AllegraEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra AllegraEra result
q
            BlockQuery (ShelleyBlock (TPraos StandardCrypto) AllegraEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraMary QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentMary BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra MaryEra
-> QueryInShelleyBasedEra MaryEra result
-> BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra MaryEra
ShelleyBasedEraMary
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra MaryEra result
q
            BlockQuery (ShelleyBlock (TPraos StandardCrypto) MaryEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraAlonzo QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentAlonzo BlockQuery (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra AlonzoEra
-> QueryInShelleyBasedEra AlonzoEra result
-> BlockQuery
     (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra AlonzoEra result
q
            BlockQuery (ShelleyBlock (TPraos StandardCrypto) AlonzoEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraBabbage QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentBabbage BlockQuery (ShelleyBlock (Praos StandardCrypto) BabbageEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra BabbageEra
-> QueryInShelleyBasedEra BabbageEra result
-> BlockQuery
     (ShelleyBlock (Praos StandardCrypto) BabbageEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra BabbageEra result
q
            BlockQuery (ShelleyBlock (Praos StandardCrypto) BabbageEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
fromConsensusQueryResult (QueryInEra (QueryInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraConway QueryInShelleyBasedEra era result
q)) Query block result'
q' result'
r' =
  case Query block result'
q' of
    Consensus.BlockQuery (Consensus.QueryIfCurrentConway BlockQuery (ShelleyBlock (Praos StandardCrypto) ConwayEra) result
q'') ->
      (MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch)
-> (result -> result)
-> CardanoQueryResult StandardCrypto result
-> Either EraMismatch result
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
        MismatchEraInfo (CardanoEras StandardCrypto) -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra ConwayEra
-> QueryInShelleyBasedEra ConwayEra result
-> BlockQuery
     (ShelleyBlock (Praos StandardCrypto) ConwayEra) result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra ConwayEra
ShelleyBasedEraConway
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra ConwayEra result
q
            BlockQuery (ShelleyBlock (Praos StandardCrypto) ConwayEra) result
q''
        )
        result'
CardanoQueryResult StandardCrypto result
r'
    Query block result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch

-- This function is written like this so that we have exhaustive pattern checking
-- on the @QueryInShelleyBasedEra era result@ value. Don't change the top-level
-- @case sbeQuery of ...@!
fromConsensusQueryResultShelleyBased
  :: forall era ledgerera protocol result result'
   . HasCallStack
  => ShelleyLedgerEra era ~ ledgerera
  => ConsensusProtocol era ~ protocol
  => ProtoCrypto protocol ~ StandardCrypto
  => ShelleyBasedEra era
  -> QueryInShelleyBasedEra era result
  -> Consensus.BlockQuery (Consensus.ShelleyBlock protocol ledgerera) result'
  -> result'
  -> result
fromConsensusQueryResultShelleyBased :: forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 ConsensusProtocol era ~ protocol,
 ProtoCrypto protocol ~ StandardCrypto) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased ShelleyBasedEra era
sbe QueryInShelleyBasedEra era result
sbeQuery BlockQuery (ShelleyBlock protocol ledgerera) result'
q' result'
r' =
  case QueryInShelleyBasedEra era result
sbeQuery of
    QueryInShelleyBasedEra era result
QueryEpoch ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetEpochNo -> result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryConstitution ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetConstitution -> result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryGenesisParameters ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetGenesisConfig -> ShelleyGenesis -> GenesisParameters ShelleyEra
fromShelleyGenesis (CompactGenesis -> ShelleyGenesis
Consensus.getCompactGenesis result'
CompactGenesis
r')
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryProtocolParameters ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetCurrentPParams -> result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryStakeDistribution ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetStakeDistribution -> PoolDistr StandardCrypto -> Map (Hash StakePoolKey) Rational
fromShelleyPoolDistr result'
PoolDistr StandardCrypto
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryUTxO QueryUTxOFilter
QueryUTxOWhole ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetUTxOWhole -> ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
forall era.
ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
fromLedgerUTxO ShelleyBasedEra era
sbe result'
UTxO (ShelleyLedgerEra era)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryUTxO QueryUTxOByAddress{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetUTxOByAddress{} -> ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
forall era.
ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
fromLedgerUTxO ShelleyBasedEra era
sbe result'
UTxO (ShelleyLedgerEra era)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryUTxO QueryUTxOByTxIn{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetUTxOByTxIn{} -> ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
forall era.
ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
fromLedgerUTxO ShelleyBasedEra era
sbe result'
UTxO (ShelleyLedgerEra era)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakeAddresses Set StakeCredential
_ NetworkId
nId ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetFilteredDelegationsAndRewardAccounts{} ->
          let (Map (Credential 'Staking) (KeyHash 'StakePool)
delegs, Map (Credential 'Staking) Coin
rwaccs) = result'
r'
           in ( (StakeCredential -> StakeAddress)
-> Map StakeCredential Coin -> Map StakeAddress Coin
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys (NetworkId -> StakeCredential -> StakeAddress
makeStakeAddress NetworkId
nId) (Map StakeCredential Coin -> Map StakeAddress Coin)
-> Map StakeCredential Coin -> Map StakeAddress Coin
forall a b. (a -> b) -> a -> b
$ Map (Credential 'Staking) Coin -> Map StakeCredential Coin
fromShelleyRewardAccounts Map (Credential 'Staking) Coin
rwaccs
              , (StakeCredential -> StakeAddress)
-> Map StakeCredential (Hash StakePoolKey)
-> Map StakeAddress (Hash StakePoolKey)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys (NetworkId -> StakeCredential -> StakeAddress
makeStakeAddress NetworkId
nId) (Map StakeCredential (Hash StakePoolKey)
 -> Map StakeAddress (Hash StakePoolKey))
-> Map StakeCredential (Hash StakePoolKey)
-> Map StakeAddress (Hash StakePoolKey)
forall a b. (a -> b) -> a -> b
$ Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map StakeCredential (Hash StakePoolKey)
fromShelleyDelegations Map (Credential 'Staking) (KeyHash 'StakePool)
delegs
              )
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryStakePools ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetStakePools -> (KeyHash 'StakePool -> Hash StakePoolKey)
-> Set (KeyHash 'StakePool) -> Set (Hash StakePoolKey)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map KeyHash 'StakePool -> Hash StakePoolKey
StakePoolKeyHash result'
Set (KeyHash 'StakePool)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakePoolParameters{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetStakePoolParams{} ->
          (PoolParams -> StakePoolParameters)
-> Map (Hash StakePoolKey) PoolParams
-> Map (Hash StakePoolKey) StakePoolParameters
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map PoolParams -> StakePoolParameters
fromShelleyPoolParams
            (Map (Hash StakePoolKey) PoolParams -> result)
-> (result' -> Map (Hash StakePoolKey) PoolParams)
-> result'
-> result
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (KeyHash 'StakePool -> Hash StakePoolKey)
-> Map (KeyHash 'StakePool) PoolParams
-> Map (Hash StakePoolKey) PoolParams
forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic KeyHash 'StakePool -> Hash StakePoolKey
StakePoolKeyHash
            (result' -> result) -> result' -> result
forall a b. (a -> b) -> a -> b
$ result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryDebugLedgerState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR BlockQuery (ShelleyBlock protocol ledgerera) result
R:BlockQueryShelleyBlock protocol ledgerera result
Consensus.DebugNewEpochState ->
          Serialised (NewEpochState (ShelleyLedgerEra era))
-> SerialisedDebugLedgerState era
forall era.
Serialised (NewEpochState (ShelleyLedgerEra era))
-> SerialisedDebugLedgerState era
SerialisedDebugLedgerState result'
Serialised (NewEpochState (ShelleyLedgerEra era))
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryProtocolState ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR BlockQuery (ShelleyBlock protocol ledgerera) result
R:BlockQueryShelleyBlock protocol ledgerera result
Consensus.DebugChainDepState ->
          Serialised (ChainDepState (ConsensusProtocol era))
-> ProtocolState era
forall era.
Serialised (ChainDepState (ConsensusProtocol era))
-> ProtocolState era
ProtocolState result'
Serialised (ChainDepState (ConsensusProtocol era))
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryInShelleyBasedEra era result
QueryCurrentEpochState ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR BlockQuery (ShelleyBlock protocol ledgerera) result
R:BlockQueryShelleyBlock protocol ledgerera result
Consensus.DebugEpochState ->
          Serialised (EpochState (ShelleyLedgerEra era))
-> SerialisedCurrentEpochState era
forall era.
Serialised (EpochState (ShelleyLedgerEra era))
-> SerialisedCurrentEpochState era
SerialisedCurrentEpochState result'
Serialised (EpochState (ShelleyLedgerEra era))
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryPoolState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR Consensus.GetPoolState{} ->
          Serialised (PState (ShelleyLedgerEra era))
-> SerialisedPoolState era
forall era.
Serialised (PState (ShelleyLedgerEra era))
-> SerialisedPoolState era
SerialisedPoolState result'
Serialised (PState (ShelleyLedgerEra era))
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryPoolDistribution{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR Consensus.GetPoolDistr{} ->
          Serialised (PoolDistr StandardCrypto)
-> SerialisedPoolDistribution era
forall era.
Serialised (PoolDistr StandardCrypto)
-> SerialisedPoolDistribution era
SerialisedPoolDistribution result'
Serialised (PoolDistr StandardCrypto)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakeSnapshot{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR Consensus.GetStakeSnapshots{} ->
          Serialised StakeSnapshots -> SerialisedStakeSnapshots era
forall era.
Serialised StakeSnapshots -> SerialisedStakeSnapshots era
SerialisedStakeSnapshots result'
Serialised StakeSnapshots
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakeDelegDeposits{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetStakeDelegDeposits{} ->
          (Credential 'Staking -> StakeCredential)
-> Map (Credential 'Staking) Coin -> Map StakeCredential Coin
forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic Credential 'Staking -> StakeCredential
fromShelleyStakeCredential result'
Map (Credential 'Staking) Coin
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryAccountState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetAccountState{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryGovState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetGovState{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryRatifyState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetRatifyState{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryFuturePParams{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetFuturePParams{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryDRepState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetDRepState{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryDRepStakeDistr{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetDRepStakeDistr{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QuerySPOStakeDistr{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetSPOStakeDistr{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryCommitteeMembersState{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCommitteeMembersState{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakeVoteDelegatees{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetFilteredVoteDelegatees{} ->
          (Credential 'Staking -> StakeCredential)
-> Map (Credential 'Staking) DRep -> Map StakeCredential DRep
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Credential 'Staking -> StakeCredential
fromShelleyStakeCredential result'
Map (Credential 'Staking) DRep
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryProposals{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetProposals{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryLedgerPeerSnapshot{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetCBOR BlockQuery (ShelleyBlock protocol ledgerera) result
R:BlockQueryShelleyBlock protocol ledgerera result
Consensus.GetBigLedgerPeerSnapshot ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakePoolDefaultVote{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.QueryStakePoolDefaultVote{} ->
          result
result'
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch

-- | This should /only/ happen if we messed up the mapping in 'toConsensusQuery'
-- and 'fromConsensusQueryResult' so they are inconsistent with each other.
--
-- If we do encounter this error it means that 'toConsensusQuery' maps a
-- API query constructor to a certain consensus query constructor but that
-- 'fromConsensusQueryResult' apparently expects a different pairing.
--
-- For example, imagine if 'toConsensusQuery would (incorrectly) map
-- 'QueryChainPoint' to 'Consensus.GetEpochNo' but 'fromConsensusQueryResult'
-- (correctly) expected to find 'Consensus.GetLedgerTip'. This mismatch would
-- trigger this error.
--
-- Such mismatches should be preventable with an appropriate property test.
fromConsensusQueryResultMismatch :: HasCallStack => a
fromConsensusQueryResultMismatch :: forall a. HasCallStack => a
fromConsensusQueryResultMismatch =
  (HasCallStack => a) -> a
forall a. HasCallStack => (HasCallStack => a) -> a
withFrozenCallStack ((HasCallStack => a) -> a) -> (HasCallStack => a) -> a
forall a b. (a -> b) -> a -> b
$
    String -> a
forall a. HasCallStack => String -> a
error String
"fromConsensusQueryResult: internal query mismatch"

fromConsensusEraMismatch
  :: SListI xs
  => Consensus.MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch :: forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch = MismatchEraInfo xs -> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
Consensus.mkEraMismatch