{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# 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.Query
  ( -- * Queries
    QueryInMode (..)
  , QueryInEra (..)
  , QueryInShelleyBasedEra (..)
  , QueryUTxOFilter (..)
  , UTxO (..)
  , 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

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

import           Cardano.Api.Address
import           Cardano.Api.Block
import           Cardano.Api.Certificate
import           Cardano.Api.Eon.ShelleyBasedEra
import           Cardano.Api.Eras.Case
import           Cardano.Api.Eras.Core
import           Cardano.Api.GenesisParameters
import           Cardano.Api.IPC.Version
import           Cardano.Api.Keys.Shelley
import           Cardano.Api.Modes
import           Cardano.Api.NetworkId
import           Cardano.Api.ProtocolParameters
import           Cardano.Api.Query.Types
import qualified Cardano.Api.ReexposeLedger as Ledger
import           Cardano.Api.Tx.Body

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

import           Control.Monad.Trans.Except
import           Data.Aeson (FromJSON (..), ToJSON (..), withObject)
import qualified Data.Aeson as Aeson
import qualified Data.Aeson.KeyMap as KeyMap
import           Data.Aeson.Types (Parser)
import           Data.Bifunctor (bimap, first)
import qualified Data.ByteString.Lazy as LBS
import           Data.Either.Combinators (rightToMaybe)
import           Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import           Data.Maybe (mapMaybe)
import           Data.Set (Set)
import qualified Data.Set as Set
import           Data.SOP.Constraint (SListI)
import           Data.Text (Text)
import qualified Data.Text 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

instance NodeToClientVersionOf (QueryInMode result) where
  nodeToClientVersionOf :: QueryInMode result -> NodeToClientVersion
nodeToClientVersionOf = \case
    QueryInMode result
QueryCurrentEra -> NodeToClientVersion
NodeToClientV_9
    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_9
    QueryInMode result
QuerySystemStart -> NodeToClientVersion
NodeToClientV_9
    QueryInMode result
QueryChainBlockNo -> NodeToClientVersion
NodeToClientV_10
    QueryInMode result
QueryChainPoint -> NodeToClientVersion
NodeToClientV_10

data EraHistory where
  EraHistory
    :: Consensus.CardanoBlock L.StandardCrypto ~ Consensus.HardForkBlock xs
    => History.Interpreter xs
    -> 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_9
  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))
  QueryProtocolParametersUpdate
    :: QueryInShelleyBasedEra
        era
        (Map (Hash GenesisKey) ProtocolParametersUpdate)
  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))
  QueryDRepState
    :: Set (Shelley.Credential Shelley.DRepRole StandardCrypto)
    -> QueryInShelleyBasedEra
        era
        (Map (Shelley.Credential Shelley.DRepRole StandardCrypto) (L.DRepState StandardCrypto))
  QueryDRepStakeDistr
    :: Set (Ledger.DRep StandardCrypto)
    -> QueryInShelleyBasedEra era (Map (Ledger.DRep StandardCrypto) L.Coin)
  QuerySPOStakeDistr
    :: Set (Ledger.KeyHash 'Ledger.StakePool StandardCrypto)
    -> QueryInShelleyBasedEra era (Map (Ledger.KeyHash 'Ledger.StakePool Ledger.StandardCrypto) L.Coin)
  QueryCommitteeMembersState
    :: Set (Shelley.Credential Shelley.ColdCommitteeRole StandardCrypto)
    -> Set (Shelley.Credential Shelley.HotCommitteeRole StandardCrypto)
    -> Set L.MemberStatus
    -> QueryInShelleyBasedEra era (L.CommitteeMembersState StandardCrypto)
  QueryStakeVoteDelegatees
    :: Set StakeCredential
    -> QueryInShelleyBasedEra era (Map StakeCredential (Ledger.DRep StandardCrypto))

-- | 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_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryGenesisParameters = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryProtocolParameters = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryProtocolParametersUpdate = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryStakeDistribution = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf (QueryUTxO QueryUTxOFilter
f) = QueryUTxOFilter -> NodeToClientVersion
forall a. NodeToClientVersionOf a => a -> NodeToClientVersion
nodeToClientVersionOf QueryUTxOFilter
f
  nodeToClientVersionOf (QueryStakeAddresses Set StakeCredential
_ NetworkId
_) = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryStakePools = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf (QueryStakePoolParameters Set (Hash StakePoolKey)
_) = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryDebugLedgerState = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryProtocolState = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf QueryInShelleyBasedEra era result
QueryCurrentEpochState = NodeToClientVersion
NodeToClientV_9
  -- Babbage >= v13
  nodeToClientVersionOf (QueryPoolState Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_14
  nodeToClientVersionOf (QueryPoolDistribution Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_14
  nodeToClientVersionOf (QueryStakeSnapshot Maybe (Set (Hash StakePoolKey))
_) = NodeToClientVersion
NodeToClientV_14
  nodeToClientVersionOf (QueryStakeDelegDeposits Set StakeCredential
_) = NodeToClientVersion
NodeToClientV_15
  -- 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

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_9
  nodeToClientVersionOf (QueryUTxOByAddress Set AddressAny
_) = NodeToClientVersion
NodeToClientV_9
  nodeToClientVersionOf (QueryUTxOByTxIn Set TxIn
_) = NodeToClientVersion
NodeToClientV_9

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

newtype UTxO era = UTxO {forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO :: Map TxIn (TxOut CtxUTxO era)}
  deriving (UTxO era -> UTxO era -> Bool
(UTxO era -> UTxO era -> Bool)
-> (UTxO era -> UTxO era -> Bool) -> Eq (UTxO era)
forall era. UTxO era -> UTxO era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. UTxO era -> UTxO era -> Bool
== :: UTxO era -> UTxO era -> Bool
$c/= :: forall era. UTxO era -> UTxO era -> Bool
/= :: UTxO era -> UTxO era -> Bool
Eq, Int -> UTxO era -> ShowS
[UTxO era] -> ShowS
UTxO era -> String
(Int -> UTxO era -> ShowS)
-> (UTxO era -> String) -> ([UTxO era] -> ShowS) -> Show (UTxO era)
forall era. Int -> UTxO era -> ShowS
forall era. [UTxO era] -> ShowS
forall era. UTxO era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> UTxO era -> ShowS
showsPrec :: Int -> UTxO era -> ShowS
$cshow :: forall era. UTxO era -> String
show :: UTxO era -> String
$cshowList :: forall era. [UTxO era] -> ShowS
showList :: [UTxO era] -> ShowS
Show)

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

deriving instance Show UTxOInAnyEra

instance IsCardanoEra era => ToJSON (UTxO era) where
  toJSON :: UTxO era -> Value
toJSON (UTxO Map TxIn (TxOut CtxUTxO era)
m) = Map TxIn (TxOut CtxUTxO era) -> Value
forall a. ToJSON a => a -> Value
toJSON Map TxIn (TxOut CtxUTxO era)
m
  toEncoding :: UTxO era -> Encoding
toEncoding (UTxO Map TxIn (TxOut CtxUTxO era)
m) = Map TxIn (TxOut CtxUTxO era) -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Map TxIn (TxOut CtxUTxO era)
m

instance
  (IsShelleyBasedEra era, FromJSON (TxOut CtxUTxO era))
  => FromJSON (UTxO era)
  where
  parseJSON :: Value -> Parser (UTxO era)
parseJSON = String
-> (Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UTxO" ((Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era))
-> (Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era)
forall a b. (a -> b) -> a -> b
$ \Object
hm -> do
    let l :: [Item (HashMap Text Value)]
l = HashMap Text Value -> [Item (HashMap Text Value)]
forall l. IsList l => l -> [Item l]
toList (HashMap Text Value -> [Item (HashMap Text Value)])
-> HashMap Text Value -> [Item (HashMap Text Value)]
forall a b. (a -> b) -> a -> b
$ Object -> HashMap Text Value
forall v. KeyMap v -> HashMap Text v
KeyMap.toHashMapText Object
hm
    [(TxIn, TxOut CtxUTxO era)]
res <- ((Text, Value) -> Parser (TxIn, TxOut CtxUTxO era))
-> [(Text, Value)] -> Parser [(TxIn, TxOut CtxUTxO era)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Text, Value) -> Parser (TxIn, TxOut CtxUTxO era)
toTxIn [(Text, Value)]
[Item (HashMap Text Value)]
l
    UTxO era -> Parser (UTxO era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (UTxO era -> Parser (UTxO era))
-> (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era)
-> Parser (UTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> Parser (UTxO era))
-> Map TxIn (TxOut CtxUTxO era) -> Parser (UTxO era)
forall a b. (a -> b) -> a -> b
$ [Item (Map TxIn (TxOut CtxUTxO era))]
-> Map TxIn (TxOut CtxUTxO era)
forall l. IsList l => [Item l] -> l
fromList [(TxIn, TxOut CtxUTxO era)]
[Item (Map TxIn (TxOut CtxUTxO era))]
res
   where
    toTxIn :: (Text, Aeson.Value) -> Parser (TxIn, TxOut CtxUTxO era)
    toTxIn :: (Text, Value) -> Parser (TxIn, TxOut CtxUTxO era)
toTxIn (Text
txinText, Value
txOutVal) = do
      (,)
        (TxIn -> TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> Parser TxIn
-> Parser (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser TxIn
forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
Aeson.String Text
txinText)
        Parser (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> Parser (TxOut CtxUTxO era) -> Parser (TxIn, TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser (TxOut CtxUTxO era)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
txOutVal

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 (Core.EraCrypto (ShelleyLedgerEra era))))

newtype PoolDistribution era = PoolDistribution
  { forall era.
PoolDistribution era
-> PoolDistr (EraCrypto (ShelleyLedgerEra era))
unPoolDistr :: Consensus.PoolDistr (Core.EraCrypto (ShelleyLedgerEra era))
  }

decodePoolDistribution
  :: forall era
   . Crypto (Core.EraCrypto (ShelleyLedgerEra era))
  => ShelleyBasedEra era
  -> SerialisedPoolDistribution era
  -> Either DecoderError (PoolDistribution era)
decodePoolDistribution :: forall era.
Crypto (EraCrypto (ShelleyLedgerEra era)) =>
ShelleyBasedEra era
-> SerialisedPoolDistribution era
-> Either DecoderError (PoolDistribution era)
decodePoolDistribution ShelleyBasedEra era
sbe (SerialisedPoolDistribution (Serialised ByteString
ls)) =
  PoolDistr (EraCrypto (ShelleyLedgerEra era))
-> PoolDistribution era
forall era.
PoolDistr (EraCrypto (ShelleyLedgerEra era))
-> PoolDistribution era
PoolDistribution (PoolDistr (EraCrypto (ShelleyLedgerEra era))
 -> PoolDistribution era)
-> Either
     DecoderError (PoolDistr (EraCrypto (ShelleyLedgerEra era)))
-> Either DecoderError (PoolDistribution era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Version
-> ByteString
-> Either
     DecoderError (PoolDistr (EraCrypto (ShelleyLedgerEra era)))
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 (Core.EraCrypto (ShelleyLedgerEra era))))

newtype StakeSnapshot era = StakeSnapshot (Consensus.StakeSnapshots (Core.EraCrypto (ShelleyLedgerEra era)))

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

toShelleyAddrSet
  :: CardanoEra era
  -> Set AddressAny
  -> Set (Shelley.Addr Consensus.StandardCrypto)
toShelleyAddrSet :: forall era.
CardanoEra era -> Set AddressAny -> Set (Addr StandardCrypto)
toShelleyAddrSet CardanoEra era
era =
  [Item (Set (Addr StandardCrypto))] -> Set (Addr StandardCrypto)
[Addr StandardCrypto] -> Set (Addr StandardCrypto)
forall l. IsList l => [Item l] -> l
fromList
    ([Addr StandardCrypto] -> Set (Addr StandardCrypto))
-> (Set AddressAny -> [Addr StandardCrypto])
-> Set AddressAny
-> Set (Addr StandardCrypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AddressInEra era -> Addr StandardCrypto)
-> [AddressInEra era] -> [Addr StandardCrypto]
forall a b. (a -> b) -> [a] -> [b]
map AddressInEra era -> Addr StandardCrypto
forall era. AddressInEra era -> Addr StandardCrypto
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 StandardCrypto])
-> (Set AddressAny -> [AddressInEra era])
-> Set AddressAny
-> [Addr StandardCrypto]
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 (EraCrypto (ShelleyLedgerEra era)))
  (TxOut (ShelleyLedgerEra era))
-> UTxO (ShelleyLedgerEra era)
forall era. Map (TxIn (EraCrypto era)) (TxOut era) -> UTxO era
Shelley.UTxO
      (Map
   (TxIn (EraCrypto (ShelleyLedgerEra era)))
   (TxOut (ShelleyLedgerEra era))
 -> UTxO (ShelleyLedgerEra era))
-> (Map TxIn (TxOut CtxUTxO era)
    -> Map
         (TxIn (EraCrypto (ShelleyLedgerEra era)))
         (TxOut (ShelleyLedgerEra era)))
-> Map TxIn (TxOut CtxUTxO era)
-> UTxO (ShelleyLedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))]
-> Map
     (TxIn (EraCrypto (ShelleyLedgerEra era)))
     (TxOut (ShelleyLedgerEra era))
[Item
   (Map
      (TxIn (EraCrypto (ShelleyLedgerEra era)))
      (TxOut (ShelleyLedgerEra era)))]
-> Map
     (TxIn (EraCrypto (ShelleyLedgerEra era)))
     (TxOut (ShelleyLedgerEra era))
forall l. IsList l => [Item l] -> l
fromList
      ([(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))]
 -> Map
      (TxIn (EraCrypto (ShelleyLedgerEra era)))
      (TxOut (ShelleyLedgerEra era)))
-> (Map TxIn (TxOut CtxUTxO era)
    -> [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))])
-> Map TxIn (TxOut CtxUTxO era)
-> Map
     (TxIn (EraCrypto (ShelleyLedgerEra era)))
     (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxIn, TxOut CtxUTxO era)
 -> (TxIn StandardCrypto, TxOut (ShelleyLedgerEra era)))
-> [(TxIn, TxOut CtxUTxO era)]
-> [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))]
forall a b. (a -> b) -> [a] -> [b]
map ((TxIn -> TxIn StandardCrypto)
-> (TxOut CtxUTxO era -> TxOut (ShelleyLedgerEra era))
-> (TxIn, TxOut CtxUTxO era)
-> (TxIn StandardCrypto, 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 StandardCrypto
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 StandardCrypto, TxOut (ShelleyLedgerEra era))])
-> (Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)])
-> Map TxIn (TxOut CtxUTxO era)
-> [(TxIn StandardCrypto, 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 (EraCrypto (ShelleyLedgerEra era)))
  (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 (EraCrypto (ShelleyLedgerEra era)))
      (TxOut (ShelleyLedgerEra era))
    -> Map TxIn (TxOut CtxUTxO era))
-> Map
     (TxIn (EraCrypto (ShelleyLedgerEra era)))
     (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 StandardCrypto) (TxOut (ShelleyLedgerEra era))
    -> [(TxIn, TxOut CtxUTxO era)])
-> Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era))
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))
 -> (TxIn, TxOut CtxUTxO era))
-> [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))]
-> [(TxIn, TxOut CtxUTxO era)]
forall a b. (a -> b) -> [a] -> [b]
map ((TxIn StandardCrypto -> TxIn)
-> (TxOut (ShelleyLedgerEra era) -> TxOut CtxUTxO era)
-> (TxIn StandardCrypto, 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 StandardCrypto -> 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 StandardCrypto, TxOut (ShelleyLedgerEra era))]
 -> [(TxIn, TxOut CtxUTxO era)])
-> (Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era))
    -> [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))])
-> Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era))
-> [(TxIn, TxOut CtxUTxO era)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era))
-> [(TxIn StandardCrypto, TxOut (ShelleyLedgerEra era))]
Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era))
-> [Item
      (Map (TxIn StandardCrypto) (TxOut (ShelleyLedgerEra era)))]
forall l. IsList l => l -> [Item l]
toList
    (Map
   (TxIn (EraCrypto (ShelleyLedgerEra era)))
   (TxOut (ShelleyLedgerEra era))
 -> UTxO era)
-> Map
     (TxIn (EraCrypto (ShelleyLedgerEra era)))
     (TxOut (ShelleyLedgerEra era))
-> UTxO era
forall a b. (a -> b) -> a -> b
$ Map
  (TxIn (EraCrypto (ShelleyLedgerEra era)))
  (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 StandardCrypto,
  IndividualPoolStake StandardCrypto)
 -> (Hash StakePoolKey, Rational))
-> [(KeyHash 'StakePool StandardCrypto,
     IndividualPoolStake StandardCrypto)]
-> [(Hash StakePoolKey, Rational)]
forall a b. (a -> b) -> [a] -> [b]
map ((KeyHash 'StakePool StandardCrypto -> Hash StakePoolKey)
-> (IndividualPoolStake StandardCrypto -> Rational)
-> (KeyHash 'StakePool StandardCrypto,
    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 StandardCrypto -> Hash StakePoolKey
StakePoolKeyHash IndividualPoolStake StandardCrypto -> Rational
forall c. IndividualPoolStake c -> Rational
Consensus.individualPoolStake)
    ([(KeyHash 'StakePool StandardCrypto,
   IndividualPoolStake StandardCrypto)]
 -> [(Hash StakePoolKey, Rational)])
-> (PoolDistr StandardCrypto
    -> [(KeyHash 'StakePool StandardCrypto,
         IndividualPoolStake StandardCrypto)])
-> PoolDistr StandardCrypto
-> [(Hash StakePoolKey, Rational)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map
  (KeyHash 'StakePool StandardCrypto)
  (IndividualPoolStake StandardCrypto)
-> [(KeyHash 'StakePool StandardCrypto,
     IndividualPoolStake StandardCrypto)]
Map
  (KeyHash 'StakePool StandardCrypto)
  (IndividualPoolStake StandardCrypto)
-> [Item
      (Map
         (KeyHash 'StakePool StandardCrypto)
         (IndividualPoolStake StandardCrypto))]
forall l. IsList l => l -> [Item l]
toList
    (Map
   (KeyHash 'StakePool StandardCrypto)
   (IndividualPoolStake StandardCrypto)
 -> [(KeyHash 'StakePool StandardCrypto,
      IndividualPoolStake StandardCrypto)])
-> (PoolDistr StandardCrypto
    -> Map
         (KeyHash 'StakePool StandardCrypto)
         (IndividualPoolStake StandardCrypto))
-> PoolDistr StandardCrypto
-> [(KeyHash 'StakePool StandardCrypto,
     IndividualPoolStake StandardCrypto)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoolDistr StandardCrypto
-> Map
     (KeyHash 'StakePool StandardCrypto)
     (IndividualPoolStake StandardCrypto)
forall c.
PoolDistr c -> Map (KeyHash 'StakePool c) (IndividualPoolStake c)
Consensus.unPoolDistr

fromShelleyDelegations
  :: Map
      (Shelley.Credential Shelley.Staking StandardCrypto)
      (Shelley.KeyHash Shelley.StakePool StandardCrypto)
  -> Map StakeCredential PoolId
fromShelleyDelegations :: Map
  (Credential 'Staking StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
-> 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 StandardCrypto)
      (KeyHash 'StakePool StandardCrypto)
    -> [(StakeCredential, Hash StakePoolKey)])
-> Map
     (Credential 'Staking StandardCrypto)
     (KeyHash 'StakePool StandardCrypto)
-> Map StakeCredential (Hash StakePoolKey)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Credential 'Staking StandardCrypto,
  KeyHash 'StakePool StandardCrypto)
 -> (StakeCredential, Hash StakePoolKey))
-> [(Credential 'Staking StandardCrypto,
     KeyHash 'StakePool StandardCrypto)]
-> [(StakeCredential, Hash StakePoolKey)]
forall a b. (a -> b) -> [a] -> [b]
map ((Credential 'Staking StandardCrypto -> StakeCredential)
-> (KeyHash 'StakePool StandardCrypto -> Hash StakePoolKey)
-> (Credential 'Staking StandardCrypto,
    KeyHash 'StakePool StandardCrypto)
-> (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 StandardCrypto -> StakeCredential
fromShelleyStakeCredential KeyHash 'StakePool StandardCrypto -> Hash StakePoolKey
StakePoolKeyHash)
    ([(Credential 'Staking StandardCrypto,
   KeyHash 'StakePool StandardCrypto)]
 -> [(StakeCredential, Hash StakePoolKey)])
-> (Map
      (Credential 'Staking StandardCrypto)
      (KeyHash 'StakePool StandardCrypto)
    -> [(Credential 'Staking StandardCrypto,
         KeyHash 'StakePool StandardCrypto)])
-> Map
     (Credential 'Staking StandardCrypto)
     (KeyHash 'StakePool StandardCrypto)
-> [(StakeCredential, Hash StakePoolKey)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map
  (Credential 'Staking StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
-> [(Credential 'Staking StandardCrypto,
     KeyHash 'StakePool StandardCrypto)]
Map
  (Credential 'Staking StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
-> [Item
      (Map
         (Credential 'Staking StandardCrypto)
         (KeyHash 'StakePool StandardCrypto))]
forall l. IsList l => l -> [Item l]
toList

fromShelleyRewardAccounts
  :: Shelley.RewardAccounts Consensus.StandardCrypto
  -> Map StakeCredential L.Coin
fromShelleyRewardAccounts :: RewardAccounts StandardCrypto -> 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)
-> (RewardAccounts StandardCrypto -> [(StakeCredential, Coin)])
-> RewardAccounts StandardCrypto
-> Map StakeCredential Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Credential 'Staking StandardCrypto, Coin)
 -> (StakeCredential, Coin))
-> [(Credential 'Staking StandardCrypto, Coin)]
-> [(StakeCredential, Coin)]
forall a b. (a -> b) -> [a] -> [b]
map ((Credential 'Staking StandardCrypto -> StakeCredential)
-> (Credential 'Staking StandardCrypto, 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 StandardCrypto -> StakeCredential
fromShelleyStakeCredential)
    ([(Credential 'Staking StandardCrypto, Coin)]
 -> [(StakeCredential, Coin)])
-> (RewardAccounts StandardCrypto
    -> [(Credential 'Staking StandardCrypto, Coin)])
-> RewardAccounts StandardCrypto
-> [(StakeCredential, Coin)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RewardAccounts StandardCrypto
-> [(Credential 'Staking StandardCrypto, Coin)]
RewardAccounts StandardCrypto
-> [Item (RewardAccounts StandardCrypto)]
forall l. IsList l => l -> [Item l]
toList

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

toConsensusQuery
  :: forall block result
   . ()
  => Consensus.CardanoBlock L.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 (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (Query
   block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
 -> Some (Query block))
-> Query
     block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
    BlockQuery
  block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Query
     block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery (BlockQuery
   block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
 -> Query
      block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto)))
-> BlockQuery
     block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Query
     block (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
forall a b. (a -> b) -> a -> b
$
      QueryHardFork
  (ByronBlock : CardanoShelleyEras StandardCrypto)
  (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
-> BlockQuery
     (CardanoBlock StandardCrypto)
     (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
forall (xs1 :: [*]) x a.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) a -> BlockQuery (HardForkBlock (x : xs1)) a
Consensus.QueryHardFork
        QueryHardFork
  (ByronBlock : CardanoShelleyEras StandardCrypto)
  (EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto))
forall (xs :: [*]). QueryHardFork xs (EraIndex xs)
Consensus.GetCurrentEra
toConsensusQuery QueryInMode result
QueryEraHistory =
  Query
  block
  (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (Query
   block
   (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
 -> Some (Query block))
-> Query
     block
     (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Some (Query block)
forall a b. (a -> b) -> a -> b
$
    BlockQuery
  block
  (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Query
     block
     (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
forall blk result. BlockQuery blk result -> Query blk result
Consensus.BlockQuery (BlockQuery
   block
   (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
 -> Query
      block
      (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto)))
-> BlockQuery
     block
     (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
-> Query
     block
     (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
forall a b. (a -> b) -> a -> b
$
      QueryHardFork
  (ByronBlock : CardanoShelleyEras StandardCrypto)
  (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
-> BlockQuery
     (CardanoBlock StandardCrypto)
     (Interpreter (ByronBlock : CardanoShelleyEras StandardCrypto))
forall (xs1 :: [*]) x a.
IsNonEmpty xs1 =>
QueryHardFork (x : xs1) a -> BlockQuery (HardForkBlock (x : xs1)) a
Consensus.QueryHardFork
        QueryHardFork
  (ByronBlock : CardanoShelleyEras StandardCrypto)
  (Interpreter (ByronBlock : CardanoShelleyEras 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),
 EraCrypto (ShelleyLedgerEra era) ~ StandardCrypto,
 CardanoBlock StandardCrypto ~ block) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result -> Some (Query block)
toConsensusQueryShelleyBased ShelleyBasedEra era
sbe QueryInShelleyBasedEra era result
q

toConsensusQueryShelleyBased
  :: forall era protocol block result
   . ()
  => ConsensusBlockForEra era ~ Consensus.ShelleyBlock protocol (ShelleyLedgerEra era)
  => Core.EraCrypto (ShelleyLedgerEra era) ~ Consensus.StandardCrypto
  => Consensus.CardanoBlock L.StandardCrypto ~ block
  => ShelleyBasedEra era
  -> QueryInShelleyBasedEra era result
  -> Some (Consensus.Query block)
toConsensusQueryShelleyBased :: forall era protocol block result.
(ConsensusBlockForEra era
 ~ ShelleyBlock protocol (ShelleyLedgerEra era),
 EraCrypto (ShelleyLedgerEra era) ~ StandardCrypto,
 CardanoBlock StandardCrypto ~ block) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result -> Some (Query block)
toConsensusQueryShelleyBased ShelleyBasedEra era
sbe = \case
  QueryInShelleyBasedEra era result
QueryEpoch ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (CompactGenesis StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (CompactGenesis StandardCrypto)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (CompactGenesis StandardCrypto))
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 (EraCrypto (ShelleyLedgerEra era)))
BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (CompactGenesis StandardCrypto)
forall proto era.
BlockQuery
  (ShelleyBlock proto era) (CompactGenesis (EraCrypto era))
Consensus.GetGenesisConfig)
  QueryInShelleyBasedEra era result
QueryProtocolParameters ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
QueryProtocolParametersUpdate ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (ProposedPPUpdates (ShelleyLedgerEra era)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (ProposedPPUpdates (ShelleyLedgerEra era))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (ProposedPPUpdates (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))
  (ProposedPPUpdates (ShelleyLedgerEra era))
forall proto era.
BlockQuery (ShelleyBlock proto era) (ProposedPPUpdates era)
Consensus.GetProposedPParamsUpdates)
  QueryInShelleyBasedEra era result
QueryStakeDistribution ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (PoolDistr StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PoolDistr StandardCrypto)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (PoolDistr StandardCrypto))
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 (EraCrypto (ShelleyLedgerEra era)))
BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (PoolDistr StandardCrypto)
forall proto era.
BlockQuery (ShelleyBlock proto era) (PoolDistr (EraCrypto era))
Consensus.GetStakeDistribution)
  QueryUTxO QueryUTxOFilter
QueryUTxOWhole ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
forall era proto.
Set (Addr (EraCrypto era))
-> BlockQuery (ShelleyBlock proto era) (UTxO era)
Consensus.GetUTxOByAddress Set (Addr (EraCrypto (ShelleyLedgerEra era)))
Set (Addr StandardCrypto)
addrs'))
   where
    addrs' :: Set (Shelley.Addr Consensus.StandardCrypto)
    addrs' :: Set (Addr StandardCrypto)
addrs' = CardanoEra era -> Set AddressAny -> Set (Addr StandardCrypto)
forall era.
CardanoEra era -> Set AddressAny -> Set (Addr StandardCrypto)
toShelleyAddrSet CardanoEra era
era Set AddressAny
addrs
  QueryUTxO (QueryUTxOByTxIn Set TxIn
txins) ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (UTxO (ShelleyLedgerEra era))
forall era proto.
Set (TxIn (EraCrypto era))
-> BlockQuery (ShelleyBlock proto era) (UTxO era)
Consensus.GetUTxOByTxIn Set (TxIn (EraCrypto (ShelleyLedgerEra era)))
Set (TxIn StandardCrypto)
txins'))
   where
    txins' :: Set (Shelley.TxIn Consensus.StandardCrypto)
    txins' :: Set (TxIn StandardCrypto)
txins' = (TxIn -> TxIn StandardCrypto)
-> Set TxIn -> Set (TxIn StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map TxIn -> TxIn StandardCrypto
toShelleyTxIn Set TxIn
txins
  QueryStakeAddresses Set StakeCredential
creds NetworkId
_nId ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map
        (Credential 'Staking StandardCrypto)
        (KeyHash 'StakePool StandardCrypto),
      RewardAccounts StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (Credential 'Staking StandardCrypto)
        (KeyHash 'StakePool StandardCrypto),
      RewardAccounts StandardCrypto)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map
           (Credential 'Staking StandardCrypto)
           (KeyHash 'StakePool StandardCrypto),
         RewardAccounts StandardCrypto))
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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Delegations (EraCrypto (ShelleyLedgerEra era)),
      RewardAccounts (EraCrypto (ShelleyLedgerEra era)))
forall era proto.
Set (Credential 'Staking (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era)
     (Delegations (EraCrypto era), RewardAccounts (EraCrypto era))
Consensus.GetFilteredDelegationsAndRewardAccounts Set (Credential 'Staking (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'Staking StandardCrypto)
creds')
      )
   where
    creds' :: Set (Shelley.Credential Shelley.Staking StandardCrypto)
    creds' :: Set (Credential 'Staking StandardCrypto)
creds' = (StakeCredential -> Credential 'Staking StandardCrypto)
-> Set StakeCredential -> Set (Credential 'Staking StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking StandardCrypto
toShelleyStakeCredential Set StakeCredential
creds
  QueryInShelleyBasedEra era result
QueryStakePools ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Set (KeyHash 'StakePool StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Set (KeyHash 'StakePool StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Set (KeyHash 'StakePool StandardCrypto)))
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 (EraCrypto (ShelleyLedgerEra era))))
BlockQuery
  (ShelleyBlock protocol (ShelleyLedgerEra era))
  (Set (KeyHash 'StakePool StandardCrypto))
forall proto era.
BlockQuery
  (ShelleyBlock proto era) (Set (KeyHash 'StakePool (EraCrypto era)))
Consensus.GetStakePools)
  QueryStakePoolParameters Set (Hash StakePoolKey)
poolids ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map
        (KeyHash 'StakePool StandardCrypto) (PoolParams StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (KeyHash 'StakePool StandardCrypto) (PoolParams StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map
           (KeyHash 'StakePool StandardCrypto) (PoolParams StandardCrypto)))
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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era)))
        (PoolParams (EraCrypto (ShelleyLedgerEra era))))
forall era proto.
Set (KeyHash 'StakePool (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era)
     (Map
        (KeyHash 'StakePool (EraCrypto era)) (PoolParams (EraCrypto era)))
Consensus.GetStakePoolParams Set (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era)))
Set (KeyHash 'StakePool StandardCrypto)
poolids'))
   where
    poolids' :: Set (Shelley.KeyHash Shelley.StakePool Consensus.StandardCrypto)
    poolids' :: Set (KeyHash 'StakePool StandardCrypto)
poolids' = (Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto)
-> Set (Hash StakePoolKey)
-> Set (KeyHash 'StakePool StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto
unStakePoolKeyHash Set (Hash StakePoolKey)
poolids
  QueryInShelleyBasedEra era result
QueryDebugLedgerState ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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 (EraCrypto (ShelleyLedgerEra era))))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PState (ShelleyLedgerEra era))
forall era proto.
Maybe (Set (KeyHash 'StakePool (EraCrypto era)))
-> BlockQuery (ShelleyBlock proto era) (PState era)
Consensus.GetPoolState ((Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto)
-> Set (Hash StakePoolKey)
-> Set (KeyHash 'StakePool StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto
unStakePoolKeyHash (Set (Hash StakePoolKey)
 -> Set (KeyHash 'StakePool StandardCrypto))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool StandardCrypto))
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Serialised (StakeSnapshots StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (StakeSnapshots StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Serialised (StakeSnapshots StandardCrypto)))
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 StandardCrypto)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (StakeSnapshots StandardCrypto))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR (Maybe (Set (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era))))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (StakeSnapshots (EraCrypto (ShelleyLedgerEra era)))
forall era proto.
Maybe (Set (KeyHash 'StakePool (EraCrypto era)))
-> BlockQuery
     (ShelleyBlock proto era) (StakeSnapshots (EraCrypto era))
Consensus.GetStakeSnapshots ((Set (Hash StakePoolKey)
 -> Set (KeyHash 'StakePool StandardCrypto))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool StandardCrypto))
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 StandardCrypto)
-> Set (Hash StakePoolKey)
-> Set (KeyHash 'StakePool StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto
unStakePoolKeyHash) Maybe (Set (Hash StakePoolKey))
mPoolIds)))
      )
  QueryPoolDistribution Maybe (Set (Hash StakePoolKey))
poolIds ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Serialised (PoolDistr StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
      (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PoolDistr StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Serialised (PoolDistr StandardCrypto)))
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 StandardCrypto)
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Serialised (PoolDistr StandardCrypto))
forall proto era result.
BlockQuery (ShelleyBlock proto era) result
-> BlockQuery (ShelleyBlock proto era) (Serialised result)
Consensus.GetCBOR (Maybe (Set (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era))))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (PoolDistr (EraCrypto (ShelleyLedgerEra era)))
forall era proto.
Maybe (Set (KeyHash 'StakePool (EraCrypto era)))
-> BlockQuery (ShelleyBlock proto era) (PoolDistr (EraCrypto era))
Consensus.GetPoolDistr (Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool StandardCrypto)
getPoolIds (Set (Hash StakePoolKey)
 -> Set (KeyHash 'StakePool StandardCrypto))
-> Maybe (Set (Hash StakePoolKey))
-> Maybe (Set (KeyHash 'StakePool StandardCrypto))
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 Consensus.StandardCrypto)
    getPoolIds :: Set (Hash StakePoolKey) -> Set (KeyHash 'StakePool StandardCrypto)
getPoolIds = (Hash StakePoolKey -> KeyHash 'StakePool StandardCrypto)
-> Set (Hash StakePoolKey)
-> Set (KeyHash 'StakePool StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\(StakePoolKeyHash KeyHash 'StakePool StandardCrypto
kh) -> KeyHash 'StakePool StandardCrypto
kh)
  QueryStakeDelegDeposits Set StakeCredential
creds ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (RewardAccounts StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (RewardAccounts StandardCrypto)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (RewardAccounts StandardCrypto))
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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (RewardAccounts (EraCrypto (ShelleyLedgerEra era)))
forall era proto.
Set (Credential 'Staking (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era) (RewardAccounts (EraCrypto era))
Consensus.GetStakeDelegDeposits Set (Credential 'Staking (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'Staking StandardCrypto)
creds'))
   where
    creds' :: Set (Credential 'Staking StandardCrypto)
creds' = (StakeCredential -> Credential 'Staking StandardCrypto)
-> Set StakeCredential -> Set (Credential 'Staking StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking StandardCrypto
toShelleyStakeCredential Set StakeCredential
creds
  QueryInShelleyBasedEra era result
QueryAccountState ->
    Query
  block
  (HardForkQueryResult
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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
     (ByronBlock : CardanoShelleyEras 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
        (ByronBlock : CardanoShelleyEras 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)
  QueryDRepState Set (Credential 'DRepRole StandardCrypto)
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map
        (Credential 'DRepRole StandardCrypto) (DRepState StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (Credential 'DRepRole StandardCrypto) (DRepState StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map
           (Credential 'DRepRole StandardCrypto) (DRepState StandardCrypto)))
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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era)))
        (DRepState (EraCrypto (ShelleyLedgerEra era))))
forall era proto.
ConwayEraGov era =>
Set (Credential 'DRepRole (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era)
     (Map
        (Credential 'DRepRole (EraCrypto era)) (DRepState (EraCrypto era)))
Consensus.GetDRepState Set (Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'DRepRole StandardCrypto)
creds)))
      ShelleyBasedEra era
sbe
  QueryDRepStakeDistr Set (DRep StandardCrypto)
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map (DRep StandardCrypto) Coin))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (DRep StandardCrypto) Coin)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map (DRep StandardCrypto) 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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (DRep (EraCrypto (ShelleyLedgerEra era))) Coin)
forall era proto.
ConwayEraGov era =>
Set (DRep (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era) (Map (DRep (EraCrypto era)) Coin)
Consensus.GetDRepStakeDistr Set (DRep (EraCrypto (ShelleyLedgerEra era)))
Set (DRep StandardCrypto)
dreps)))
      ShelleyBasedEra era
sbe
  QuerySPOStakeDistr Set (KeyHash 'StakePool StandardCrypto)
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map (KeyHash 'StakePool StandardCrypto) 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 StandardCrypto) Coin)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map (KeyHash 'StakePool StandardCrypto) 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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era))) Coin)
forall era proto.
ConwayEraGov era =>
Set (KeyHash 'StakePool (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era)
     (Map (KeyHash 'StakePool (EraCrypto era)) Coin)
Consensus.GetSPOStakeDistr Set (KeyHash 'StakePool (EraCrypto (ShelleyLedgerEra era)))
Set (KeyHash 'StakePool StandardCrypto)
spos)))
      ShelleyBasedEra era
sbe
  QueryCommitteeMembersState Set (Credential 'ColdCommitteeRole StandardCrypto)
coldCreds Set (Credential 'HotCommitteeRole StandardCrypto)
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (CommitteeMembersState StandardCrypto))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            (CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (CommitteeMembersState StandardCrypto)
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (CommitteeMembersState StandardCrypto))
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 (EraCrypto (ShelleyLedgerEra era)))
-> Set
     (Credential 'HotCommitteeRole (EraCrypto (ShelleyLedgerEra era)))
-> Set MemberStatus
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (CommitteeMembersState (EraCrypto (ShelleyLedgerEra era)))
forall era proto.
ConwayEraGov era =>
Set (Credential 'ColdCommitteeRole (EraCrypto era))
-> Set (Credential 'HotCommitteeRole (EraCrypto era))
-> Set MemberStatus
-> BlockQuery
     (ShelleyBlock proto era) (CommitteeMembersState (EraCrypto era))
Consensus.GetCommitteeMembersState Set
  (Credential 'ColdCommitteeRole (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'ColdCommitteeRole StandardCrypto)
coldCreds Set
  (Credential 'HotCommitteeRole (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'HotCommitteeRole StandardCrypto)
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
     (ByronBlock : CardanoShelleyEras StandardCrypto)
     (Map (Credential 'Staking StandardCrypto) (DRep StandardCrypto)))
-> Some (Query block)
forall {k} (f :: k -> *) (a :: k). f a -> Some f
Some
            ( CardanoEra era
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map (Credential 'Staking StandardCrypto) (DRep StandardCrypto))
-> Query
     block
     (HardForkQueryResult
        (ByronBlock : CardanoShelleyEras StandardCrypto)
        (Map (Credential 'Staking StandardCrypto) (DRep StandardCrypto)))
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 (EraCrypto (ShelleyLedgerEra era)))
-> BlockQuery
     (ShelleyBlock protocol (ShelleyLedgerEra era))
     (Map
        (Credential 'Staking (EraCrypto (ShelleyLedgerEra era)))
        (DRep (EraCrypto (ShelleyLedgerEra era))))
forall era proto.
ConwayEraGov era =>
Set (Credential 'Staking (EraCrypto era))
-> BlockQuery
     (ShelleyBlock proto era)
     (Map (Credential 'Staking (EraCrypto era)) (DRep (EraCrypto era)))
Consensus.GetFilteredVoteDelegatees Set (Credential 'Staking (EraCrypto (ShelleyLedgerEra era)))
Set (Credential 'Staking StandardCrypto)
creds')
            )
      )
      ShelleyBasedEra era
sbe
   where
    creds' :: Set (Shelley.Credential Shelley.Staking StandardCrypto)
    creds' :: Set (Credential 'Staking StandardCrypto)
creds' = (StakeCredential -> Credential 'Staking StandardCrypto)
-> Set StakeCredential -> Set (Credential 'Staking StandardCrypto)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map StakeCredential -> Credential 'Staking StandardCrypto
toShelleyStakeCredential Set StakeCredential
creds
 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 L.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 StandardShelleyBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) (ShelleyEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentShelley
      CardanoEra era
AllegraEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery StandardAllegraBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) (AllegraEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentAllegra
      CardanoEra era
MaryEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery StandardMaryBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) (MaryEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentMary
      CardanoEra era
AlonzoEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery StandardAlonzoBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (TPraos c) (AlonzoEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentAlonzo
      CardanoEra era
BabbageEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery StandardBabbageBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) (BabbageEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentBabbage
      CardanoEra era
ConwayEra -> BlockQuery erablock result -> BlockQuery modeblock result'
BlockQuery StandardConwayBlock result
-> CardanoQuery StandardCrypto result'
forall c a result.
(CardanoQueryResult c result ~ a) =>
BlockQuery (ShelleyBlock (Praos c) (ConwayEra c)) result
-> CardanoQuery c a
Consensus.QueryIfCurrentConway

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

fromConsensusQueryResult
  :: forall block result result'
   . ()
  => HasCallStack
  => Consensus.CardanoBlock L.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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraHistory
forall (xs :: [*]).
(CardanoBlock StandardCrypto ~ HardForkBlock xs) =>
Interpreter xs -> EraHistory
EraHistory result'
Interpreter (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> AnyCardanoEra
fromConsensusEraIndex result'
EraIndex (ByronBlock : CardanoShelleyEras StandardCrypto)
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 (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras 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 StandardShelleyBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra ShelleyEra
-> QueryInShelleyBasedEra ShelleyEra result
-> BlockQuery StandardShelleyBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra ShelleyEra result
q
            BlockQuery StandardShelleyBlock 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 StandardAllegraBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra AllegraEra
-> QueryInShelleyBasedEra AllegraEra result
-> BlockQuery StandardAllegraBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra AllegraEra result
q
            BlockQuery StandardAllegraBlock 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 StandardMaryBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra MaryEra
-> QueryInShelleyBasedEra MaryEra result
-> BlockQuery StandardMaryBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra MaryEra
ShelleyBasedEraMary
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra MaryEra result
q
            BlockQuery StandardMaryBlock 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 StandardAlonzoBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra AlonzoEra
-> QueryInShelleyBasedEra AlonzoEra result
-> BlockQuery StandardAlonzoBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra AlonzoEra result
q
            BlockQuery StandardAlonzoBlock 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 StandardBabbageBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra BabbageEra
-> QueryInShelleyBasedEra BabbageEra result
-> BlockQuery StandardBabbageBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra BabbageEra result
q
            BlockQuery StandardBabbageBlock 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 StandardConwayBlock result
q'') ->
      (MismatchEraInfo (ByronBlock : CardanoShelleyEras 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 (ByronBlock : CardanoShelleyEras StandardCrypto)
-> EraMismatch
forall (xs :: [*]). SListI xs => MismatchEraInfo xs -> EraMismatch
fromConsensusEraMismatch
        ( ShelleyBasedEra ConwayEra
-> QueryInShelleyBasedEra ConwayEra result
-> BlockQuery StandardConwayBlock result
-> result
-> result
forall era ledgerera protocol result result'.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
ShelleyBasedEra era
-> QueryInShelleyBasedEra era result
-> BlockQuery (ShelleyBlock protocol ledgerera) result'
-> result'
-> result
fromConsensusQueryResultShelleyBased
            ShelleyBasedEra ConwayEra
ShelleyBasedEraConway
            QueryInShelleyBasedEra era result
QueryInShelleyBasedEra ConwayEra result
q
            BlockQuery StandardConwayBlock 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
  => Core.EraCrypto ledgerera ~ Consensus.StandardCrypto
  => ConsensusProtocol era ~ protocol
  => 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,
 EraCrypto ledgerera ~ StandardCrypto,
 ConsensusProtocol era ~ protocol) =>
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 StandardCrypto -> GenesisParameters ShelleyEra
fromShelleyGenesis (CompactGenesis StandardCrypto -> ShelleyGenesis StandardCrypto
forall c. CompactGenesis c -> ShelleyGenesis c
Consensus.getCompactGenesis result'
CompactGenesis StandardCrypto
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
QueryProtocolParametersUpdate ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        BlockQuery (ShelleyBlock protocol ledgerera) result'
R:BlockQueryShelleyBlock protocol ledgerera result'
Consensus.GetProposedPParamsUpdates -> ShelleyBasedEra era
-> ProposedPPUpdates ledgerera
-> Map (Hash GenesisKey) ProtocolParametersUpdate
forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 EraCrypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era
-> ProposedPPUpdates ledgerera
-> Map (Hash GenesisKey) ProtocolParametersUpdate
fromLedgerProposedPPUpdates ShelleyBasedEra era
sbe result'
ProposedPPUpdates ledgerera
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 StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
delegs, RewardAccounts StandardCrypto
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
$ RewardAccounts StandardCrypto -> Map StakeCredential Coin
fromShelleyRewardAccounts RewardAccounts StandardCrypto
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 StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
-> Map StakeCredential (Hash StakePoolKey)
fromShelleyDelegations Map
  (Credential 'Staking StandardCrypto)
  (KeyHash 'StakePool StandardCrypto)
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 StandardCrypto -> Hash StakePoolKey)
-> Set (KeyHash 'StakePool StandardCrypto)
-> Set (Hash StakePoolKey)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map KeyHash 'StakePool StandardCrypto -> Hash StakePoolKey
StakePoolKeyHash result'
Set (KeyHash 'StakePool StandardCrypto)
r'
        BlockQuery (ShelleyBlock protocol ledgerera) result'
_ -> result
forall a. HasCallStack => a
fromConsensusQueryResultMismatch
    QueryStakePoolParameters{} ->
      case BlockQuery (ShelleyBlock protocol ledgerera) result'
q' of
        Consensus.GetStakePoolParams{} ->
          (PoolParams StandardCrypto -> StakePoolParameters)
-> Map (Hash StakePoolKey) (PoolParams StandardCrypto)
-> Map (Hash StakePoolKey) StakePoolParameters
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map PoolParams StandardCrypto -> StakePoolParameters
fromShelleyPoolParams
            (Map (Hash StakePoolKey) (PoolParams StandardCrypto) -> result)
-> (result' -> Map (Hash StakePoolKey) (PoolParams StandardCrypto))
-> result'
-> result
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (KeyHash 'StakePool StandardCrypto -> Hash StakePoolKey)
-> Map
     (KeyHash 'StakePool StandardCrypto) (PoolParams StandardCrypto)
-> Map (Hash StakePoolKey) (PoolParams StandardCrypto)
forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic KeyHash 'StakePool StandardCrypto -> 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 (EraCrypto (ShelleyLedgerEra era)))
-> SerialisedPoolDistribution era
forall era.
Serialised (PoolDistr (EraCrypto (ShelleyLedgerEra era)))
-> SerialisedPoolDistribution era
SerialisedPoolDistribution result'
Serialised (PoolDistr (EraCrypto (ShelleyLedgerEra era)))
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 (EraCrypto (ShelleyLedgerEra era)))
-> SerialisedStakeSnapshots era
forall era.
Serialised (StakeSnapshots (EraCrypto (ShelleyLedgerEra era)))
-> SerialisedStakeSnapshots era
SerialisedStakeSnapshots result'
Serialised (StakeSnapshots (EraCrypto (ShelleyLedgerEra era)))
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 StandardCrypto -> StakeCredential)
-> RewardAccounts StandardCrypto -> Map StakeCredential Coin
forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic Credential 'Staking StandardCrypto -> StakeCredential
fromShelleyStakeCredential result'
RewardAccounts StandardCrypto
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
    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 StandardCrypto -> StakeCredential)
-> Map (Credential 'Staking StandardCrypto) (DRep StandardCrypto)
-> Map StakeCredential (DRep StandardCrypto)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Credential 'Staking StandardCrypto -> StakeCredential
fromShelleyStakeCredential result'
Map (Credential 'Staking StandardCrypto) (DRep StandardCrypto)
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