{-# LANGUAGE NamedFieldPuns #-}

-- | Stake pool parameters, relays, and metadata references used by transaction
-- certificates and queries. The era-parameterized certificate type itself lives
-- in "Cardano.Api.Experimental.Tx.Internal.Certificate".
module Cardano.Api.Certificate.Internal
  ( PoolId

    -- * Registering stake pools
  , StakePoolParameters (..)
  , StakePoolRelay (..)
  , StakePoolMetadataReference (..)

    -- * Internal conversion functions
  , toShelleyPoolParams
  , fromShelleyPoolParams
  , fromShelleyStakePoolState
  )
where

import Cardano.Api.Address
import Cardano.Api.Certificate.Internal.StakePoolMetadata
import Cardano.Api.Key.Internal
import Cardano.Api.Key.Internal.Praos
import Cardano.Api.Ledger.Internal.Reexport qualified as Ledger

import Cardano.Ledger.Coin qualified as L
import Cardano.Ledger.State qualified as Ledger

import Data.ByteString (ByteString)
import Data.ByteString qualified as BS
import Data.ByteString.Short qualified as SBS
import Data.IP (IPv4, IPv6)
import Data.Maybe
import Data.MemPack.Buffer (byteArrayFromShortByteString, byteArrayToShortByteString)
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.Encoding qualified as Text
import GHC.Exts (IsList (..))
import Network.Socket (PortNumber)

-- ----------------------------------------------------------------------------
-- Stake pool parameters
--

type PoolId = Hash StakePoolKey

data StakePoolParameters
  = StakePoolParameters
  { StakePoolParameters -> PoolId
stakePoolId :: PoolId
  , StakePoolParameters -> Hash VrfKey
stakePoolVRF :: Hash VrfKey
  , StakePoolParameters -> Coin
stakePoolCost :: L.Coin
  , StakePoolParameters -> Rational
stakePoolMargin :: Rational
  , StakePoolParameters -> StakeAddress
stakePoolRewardAccount :: StakeAddress
  , StakePoolParameters -> Coin
stakePoolPledge :: L.Coin
  , StakePoolParameters -> [Hash StakeKey]
stakePoolOwners :: [Hash StakeKey]
  , StakePoolParameters -> [StakePoolRelay]
stakePoolRelays :: [StakePoolRelay]
  , StakePoolParameters -> Maybe StakePoolMetadataReference
stakePoolMetadata :: Maybe StakePoolMetadataReference
  }
  deriving (StakePoolParameters -> StakePoolParameters -> Bool
(StakePoolParameters -> StakePoolParameters -> Bool)
-> (StakePoolParameters -> StakePoolParameters -> Bool)
-> Eq StakePoolParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StakePoolParameters -> StakePoolParameters -> Bool
== :: StakePoolParameters -> StakePoolParameters -> Bool
$c/= :: StakePoolParameters -> StakePoolParameters -> Bool
/= :: StakePoolParameters -> StakePoolParameters -> Bool
Eq, Int -> StakePoolParameters -> ShowS
[StakePoolParameters] -> ShowS
StakePoolParameters -> String
(Int -> StakePoolParameters -> ShowS)
-> (StakePoolParameters -> String)
-> ([StakePoolParameters] -> ShowS)
-> Show StakePoolParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StakePoolParameters -> ShowS
showsPrec :: Int -> StakePoolParameters -> ShowS
$cshow :: StakePoolParameters -> String
show :: StakePoolParameters -> String
$cshowList :: [StakePoolParameters] -> ShowS
showList :: [StakePoolParameters] -> ShowS
Show)

data StakePoolRelay
  = -- | One or both of IPv4 & IPv6
    StakePoolRelayIp
      (Maybe IPv4)
      (Maybe IPv6)
      (Maybe PortNumber)
  | -- | An DNS name pointing to a @A@ or @AAAA@ record.
    StakePoolRelayDnsARecord
      ByteString
      (Maybe PortNumber)
  | -- | A DNS name pointing to a @SRV@ record.
    StakePoolRelayDnsSrvRecord
      ByteString
  deriving (StakePoolRelay -> StakePoolRelay -> Bool
(StakePoolRelay -> StakePoolRelay -> Bool)
-> (StakePoolRelay -> StakePoolRelay -> Bool) -> Eq StakePoolRelay
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StakePoolRelay -> StakePoolRelay -> Bool
== :: StakePoolRelay -> StakePoolRelay -> Bool
$c/= :: StakePoolRelay -> StakePoolRelay -> Bool
/= :: StakePoolRelay -> StakePoolRelay -> Bool
Eq, Int -> StakePoolRelay -> ShowS
[StakePoolRelay] -> ShowS
StakePoolRelay -> String
(Int -> StakePoolRelay -> ShowS)
-> (StakePoolRelay -> String)
-> ([StakePoolRelay] -> ShowS)
-> Show StakePoolRelay
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StakePoolRelay -> ShowS
showsPrec :: Int -> StakePoolRelay -> ShowS
$cshow :: StakePoolRelay -> String
show :: StakePoolRelay -> String
$cshowList :: [StakePoolRelay] -> ShowS
showList :: [StakePoolRelay] -> ShowS
Show)

data StakePoolMetadataReference
  = StakePoolMetadataReference
  { StakePoolMetadataReference -> Text
stakePoolMetadataURL :: Text
  , StakePoolMetadataReference -> Hash StakePoolMetadata
stakePoolMetadataHash :: Hash StakePoolMetadata
  }
  deriving (StakePoolMetadataReference -> StakePoolMetadataReference -> Bool
(StakePoolMetadataReference -> StakePoolMetadataReference -> Bool)
-> (StakePoolMetadataReference
    -> StakePoolMetadataReference -> Bool)
-> Eq StakePoolMetadataReference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StakePoolMetadataReference -> StakePoolMetadataReference -> Bool
== :: StakePoolMetadataReference -> StakePoolMetadataReference -> Bool
$c/= :: StakePoolMetadataReference -> StakePoolMetadataReference -> Bool
/= :: StakePoolMetadataReference -> StakePoolMetadataReference -> Bool
Eq, Int -> StakePoolMetadataReference -> ShowS
[StakePoolMetadataReference] -> ShowS
StakePoolMetadataReference -> String
(Int -> StakePoolMetadataReference -> ShowS)
-> (StakePoolMetadataReference -> String)
-> ([StakePoolMetadataReference] -> ShowS)
-> Show StakePoolMetadataReference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StakePoolMetadataReference -> ShowS
showsPrec :: Int -> StakePoolMetadataReference -> ShowS
$cshow :: StakePoolMetadataReference -> String
show :: StakePoolMetadataReference -> String
$cshowList :: [StakePoolMetadataReference] -> ShowS
showList :: [StakePoolMetadataReference] -> ShowS
Show)

-- ----------------------------------------------------------------------------
-- Internal conversion functions
--

toShelleyPoolParams :: StakePoolParameters -> Ledger.StakePoolParams
toShelleyPoolParams :: StakePoolParameters -> StakePoolParams
toShelleyPoolParams
  StakePoolParameters
    { stakePoolId :: StakePoolParameters -> PoolId
stakePoolId = StakePoolKeyHash KeyHash StakePool
poolkh
    , stakePoolVRF :: StakePoolParameters -> Hash VrfKey
stakePoolVRF = VrfKeyHash Hash HASH (VerKeyVRF (VRF StandardCrypto))
vrfkh
    , Coin
stakePoolCost :: StakePoolParameters -> Coin
stakePoolCost :: Coin
stakePoolCost
    , Rational
stakePoolMargin :: StakePoolParameters -> Rational
stakePoolMargin :: Rational
stakePoolMargin
    , StakeAddress
stakePoolRewardAccount :: StakePoolParameters -> StakeAddress
stakePoolRewardAccount :: StakeAddress
stakePoolRewardAccount
    , Coin
stakePoolPledge :: StakePoolParameters -> Coin
stakePoolPledge :: Coin
stakePoolPledge
    , [Hash StakeKey]
stakePoolOwners :: StakePoolParameters -> [Hash StakeKey]
stakePoolOwners :: [Hash StakeKey]
stakePoolOwners
    , [StakePoolRelay]
stakePoolRelays :: StakePoolParameters -> [StakePoolRelay]
stakePoolRelays :: [StakePoolRelay]
stakePoolRelays
    , Maybe StakePoolMetadataReference
stakePoolMetadata :: StakePoolParameters -> Maybe StakePoolMetadataReference
stakePoolMetadata :: Maybe StakePoolMetadataReference
stakePoolMetadata
    } =
    -- TODO: validate pool parameters such as the PoolMargin below, but also
    -- do simple client-side sanity checks, e.g. on the pool metadata url
    Ledger.StakePoolParams
      { sppId :: KeyHash StakePool
Ledger.sppId = KeyHash StakePool
poolkh
      , sppVrf :: VRFVerKeyHash StakePoolVRF
Ledger.sppVrf = Hash HASH (VerKeyVRF PraosVRF) -> VRFVerKeyHash StakePoolVRF
forall v (r :: KeyRoleVRF).
Hash HASH (VerKeyVRF v) -> VRFVerKeyHash r
Ledger.toVRFVerKeyHash Hash HASH (VerKeyVRF PraosVRF)
Hash HASH (VerKeyVRF (VRF StandardCrypto))
vrfkh
      , sppPledge :: Coin
Ledger.sppPledge = Coin
stakePoolPledge
      , sppCost :: Coin
Ledger.sppCost = Coin
stakePoolCost
      , sppMargin :: UnitInterval
Ledger.sppMargin =
          UnitInterval -> Maybe UnitInterval -> UnitInterval
forall a. a -> Maybe a -> a
fromMaybe
            (String -> UnitInterval
forall a. HasCallStack => String -> a
error String
"toShelleyPoolParams: invalid PoolMargin")
            (Rational -> Maybe UnitInterval
forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
stakePoolMargin)
      , sppAccountAddress :: AccountAddress
Ledger.sppAccountAddress = StakeAddress -> AccountAddress
toShelleyStakeAddr StakeAddress
stakePoolRewardAccount
      , sppOwners :: Set (KeyHash Staking)
Ledger.sppOwners =
          [Item (Set (KeyHash Staking))] -> Set (KeyHash Staking)
forall l. IsList l => [Item l] -> l
fromList
            [Item (Set (KeyHash Staking))
KeyHash Staking
kh | StakeKeyHash KeyHash Staking
kh <- [Hash StakeKey]
stakePoolOwners]
      , sppRelays :: StrictSeq StakePoolRelay
Ledger.sppRelays =
          [Item (StrictSeq StakePoolRelay)] -> StrictSeq StakePoolRelay
forall l. IsList l => [Item l] -> l
fromList
            ((StakePoolRelay -> StakePoolRelay)
-> [StakePoolRelay] -> [StakePoolRelay]
forall a b. (a -> b) -> [a] -> [b]
map StakePoolRelay -> StakePoolRelay
toShelleyStakePoolRelay [StakePoolRelay]
stakePoolRelays)
      , sppMetadata :: StrictMaybe PoolMetadata
Ledger.sppMetadata =
          StakePoolMetadataReference -> PoolMetadata
toShelleyPoolMetadata
            (StakePoolMetadataReference -> PoolMetadata)
-> StrictMaybe StakePoolMetadataReference
-> StrictMaybe PoolMetadata
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe StakePoolMetadataReference
-> StrictMaybe StakePoolMetadataReference
forall a. Maybe a -> StrictMaybe a
Ledger.maybeToStrictMaybe Maybe StakePoolMetadataReference
stakePoolMetadata
      }
   where
    toShelleyStakePoolRelay :: StakePoolRelay -> Ledger.StakePoolRelay
    toShelleyStakePoolRelay :: StakePoolRelay -> StakePoolRelay
toShelleyStakePoolRelay (StakePoolRelayIp Maybe IPv4
mipv4 Maybe IPv6
mipv6 Maybe PortNumber
mport) =
      StrictMaybe Port
-> StrictMaybe IPv4 -> StrictMaybe IPv6 -> StakePoolRelay
Ledger.SingleHostAddr
        (PortNumber -> Port
forall a b. (Integral a, Num b) => a -> b
fromIntegral (PortNumber -> Port) -> StrictMaybe PortNumber -> StrictMaybe Port
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PortNumber -> StrictMaybe PortNumber
forall a. Maybe a -> StrictMaybe a
Ledger.maybeToStrictMaybe Maybe PortNumber
mport)
        (Maybe IPv4 -> StrictMaybe IPv4
forall a. Maybe a -> StrictMaybe a
Ledger.maybeToStrictMaybe Maybe IPv4
mipv4)
        (Maybe IPv6 -> StrictMaybe IPv6
forall a. Maybe a -> StrictMaybe a
Ledger.maybeToStrictMaybe Maybe IPv6
mipv6)
    toShelleyStakePoolRelay (StakePoolRelayDnsARecord ByteString
dnsname Maybe PortNumber
mport) =
      StrictMaybe Port -> DnsName -> StakePoolRelay
Ledger.SingleHostName
        (PortNumber -> Port
forall a b. (Integral a, Num b) => a -> b
fromIntegral (PortNumber -> Port) -> StrictMaybe PortNumber -> StrictMaybe Port
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PortNumber -> StrictMaybe PortNumber
forall a. Maybe a -> StrictMaybe a
Ledger.maybeToStrictMaybe Maybe PortNumber
mport)
        (ByteString -> DnsName
toShelleyDnsName ByteString
dnsname)
    toShelleyStakePoolRelay (StakePoolRelayDnsSrvRecord ByteString
dnsname) =
      DnsName -> StakePoolRelay
Ledger.MultiHostName
        (ByteString -> DnsName
toShelleyDnsName ByteString
dnsname)

    toShelleyPoolMetadata :: StakePoolMetadataReference -> Ledger.PoolMetadata
    toShelleyPoolMetadata :: StakePoolMetadataReference -> PoolMetadata
toShelleyPoolMetadata
      StakePoolMetadataReference
        { Text
stakePoolMetadataURL :: StakePoolMetadataReference -> Text
stakePoolMetadataURL :: Text
stakePoolMetadataURL
        , stakePoolMetadataHash :: StakePoolMetadataReference -> Hash StakePoolMetadata
stakePoolMetadataHash = StakePoolMetadataHash Hash HASH ByteString
mdh
        } =
        Ledger.PoolMetadata
          { pmUrl :: Url
Ledger.pmUrl = Text -> Url
toShelleyUrl Text
stakePoolMetadataURL
          , pmHash :: ByteArray
Ledger.pmHash = ShortByteString -> ByteArray
byteArrayFromShortByteString (ShortByteString -> ByteArray)
-> (ByteString -> ShortByteString) -> ByteString -> ByteArray
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ShortByteString
SBS.toShort (ByteString -> ByteArray) -> ByteString -> ByteArray
forall a b. (a -> b) -> a -> b
$ Hash HASH ByteString -> ByteString
forall h a. Hash h a -> ByteString
Ledger.hashToBytes Hash HASH ByteString
mdh
          }

    toShelleyDnsName :: ByteString -> Ledger.DnsName
    toShelleyDnsName :: ByteString -> DnsName
toShelleyDnsName ByteString
name =
      DnsName -> Maybe DnsName -> DnsName
forall a. a -> Maybe a -> a
fromMaybe (String -> DnsName
forall a. HasCallStack => String -> a
error String
"toShelleyDnsName: invalid dns name. TODO: proper validation")
        (Maybe DnsName -> DnsName)
-> (Text -> Maybe DnsName) -> Text -> DnsName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Maybe DnsName
forall (m :: * -> *). MonadFail m => Int -> Text -> m DnsName
Ledger.textToDns (ByteString -> Int
BS.length ByteString
name)
        (Text -> DnsName) -> Text -> DnsName
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
Text.decodeLatin1 ByteString
name

    toShelleyUrl :: Text -> Ledger.Url
    toShelleyUrl :: Text -> Url
toShelleyUrl Text
url =
      Url -> Maybe Url -> Url
forall a. a -> Maybe a -> a
fromMaybe (String -> Url
forall a. HasCallStack => String -> a
error String
"toShelleyUrl: invalid url. TODO: proper validation") (Maybe Url -> Url) -> Maybe Url -> Url
forall a b. (a -> b) -> a -> b
$
        Int -> Text -> Maybe Url
forall (m :: * -> *). MonadFail m => Int -> Text -> m Url
Ledger.textToUrl (Text -> Int
Text.length Text
url) Text
url

fromShelleyPoolParams
  :: Ledger.StakePoolParams
  -> StakePoolParameters
fromShelleyPoolParams :: StakePoolParams -> StakePoolParameters
fromShelleyPoolParams
  Ledger.StakePoolParams
    { KeyHash StakePool
sppId :: StakePoolParams -> KeyHash StakePool
sppId :: KeyHash StakePool
Ledger.sppId
    , VRFVerKeyHash StakePoolVRF
sppVrf :: StakePoolParams -> VRFVerKeyHash StakePoolVRF
sppVrf :: VRFVerKeyHash StakePoolVRF
Ledger.sppVrf
    , Coin
sppPledge :: StakePoolParams -> Coin
sppPledge :: Coin
Ledger.sppPledge
    , Coin
sppCost :: StakePoolParams -> Coin
sppCost :: Coin
Ledger.sppCost
    , UnitInterval
sppMargin :: StakePoolParams -> UnitInterval
sppMargin :: UnitInterval
Ledger.sppMargin
    , AccountAddress
sppAccountAddress :: StakePoolParams -> AccountAddress
sppAccountAddress :: AccountAddress
Ledger.sppAccountAddress
    , Set (KeyHash Staking)
sppOwners :: StakePoolParams -> Set (KeyHash Staking)
sppOwners :: Set (KeyHash Staking)
Ledger.sppOwners
    , StrictSeq StakePoolRelay
sppRelays :: StakePoolParams -> StrictSeq StakePoolRelay
sppRelays :: StrictSeq StakePoolRelay
Ledger.sppRelays
    , StrictMaybe PoolMetadata
sppMetadata :: StakePoolParams -> StrictMaybe PoolMetadata
sppMetadata :: StrictMaybe PoolMetadata
Ledger.sppMetadata
    } =
    StakePoolParameters
      { stakePoolId :: PoolId
stakePoolId = KeyHash StakePool -> PoolId
StakePoolKeyHash KeyHash StakePool
sppId
      , stakePoolVRF :: Hash VrfKey
stakePoolVRF = Hash HASH (VerKeyVRF (VRF StandardCrypto)) -> Hash VrfKey
VrfKeyHash (VRFVerKeyHash StakePoolVRF -> Hash HASH (VerKeyVRF PraosVRF)
forall (r :: KeyRoleVRF) v.
VRFVerKeyHash r -> Hash HASH (VerKeyVRF v)
Ledger.fromVRFVerKeyHash VRFVerKeyHash StakePoolVRF
sppVrf)
      , stakePoolCost :: Coin
stakePoolCost = Coin
sppCost
      , stakePoolMargin :: Rational
stakePoolMargin = UnitInterval -> Rational
forall r. BoundedRational r => r -> Rational
Ledger.unboundRational UnitInterval
sppMargin
      , stakePoolRewardAccount :: StakeAddress
stakePoolRewardAccount = AccountAddress -> StakeAddress
fromShelleyStakeAddr AccountAddress
sppAccountAddress
      , stakePoolPledge :: Coin
stakePoolPledge = Coin
sppPledge
      , stakePoolOwners :: [Hash StakeKey]
stakePoolOwners = (KeyHash Staking -> Hash StakeKey)
-> [KeyHash Staking] -> [Hash StakeKey]
forall a b. (a -> b) -> [a] -> [b]
map KeyHash Staking -> Hash StakeKey
StakeKeyHash (Set (KeyHash Staking) -> [Item (Set (KeyHash Staking))]
forall l. IsList l => l -> [Item l]
toList Set (KeyHash Staking)
sppOwners)
      , stakePoolRelays :: [StakePoolRelay]
stakePoolRelays =
          (StakePoolRelay -> StakePoolRelay)
-> [StakePoolRelay] -> [StakePoolRelay]
forall a b. (a -> b) -> [a] -> [b]
map
            StakePoolRelay -> StakePoolRelay
fromShelleyStakePoolRelay
            (StrictSeq StakePoolRelay -> [Item (StrictSeq StakePoolRelay)]
forall l. IsList l => l -> [Item l]
toList StrictSeq StakePoolRelay
sppRelays)
      , stakePoolMetadata :: Maybe StakePoolMetadataReference
stakePoolMetadata =
          PoolMetadata -> StakePoolMetadataReference
fromShelleyPoolMetadata
            (PoolMetadata -> StakePoolMetadataReference)
-> Maybe PoolMetadata -> Maybe StakePoolMetadataReference
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StrictMaybe PoolMetadata -> Maybe PoolMetadata
forall a. StrictMaybe a -> Maybe a
Ledger.strictMaybeToMaybe StrictMaybe PoolMetadata
sppMetadata
      }
   where
    fromShelleyStakePoolRelay :: Ledger.StakePoolRelay -> StakePoolRelay
    fromShelleyStakePoolRelay :: StakePoolRelay -> StakePoolRelay
fromShelleyStakePoolRelay (Ledger.SingleHostAddr StrictMaybe Port
mport StrictMaybe IPv4
mipv4 StrictMaybe IPv6
mipv6) =
      Maybe IPv4 -> Maybe IPv6 -> Maybe PortNumber -> StakePoolRelay
StakePoolRelayIp
        (StrictMaybe IPv4 -> Maybe IPv4
forall a. StrictMaybe a -> Maybe a
Ledger.strictMaybeToMaybe StrictMaybe IPv4
mipv4)
        (StrictMaybe IPv6 -> Maybe IPv6
forall a. StrictMaybe a -> Maybe a
Ledger.strictMaybeToMaybe StrictMaybe IPv6
mipv6)
        (Word16 -> PortNumber
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> PortNumber) -> (Port -> Word16) -> Port -> PortNumber
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Port -> Word16
Ledger.portToWord16 (Port -> PortNumber) -> Maybe Port -> Maybe PortNumber
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StrictMaybe Port -> Maybe Port
forall a. StrictMaybe a -> Maybe a
Ledger.strictMaybeToMaybe StrictMaybe Port
mport)
    fromShelleyStakePoolRelay (Ledger.SingleHostName StrictMaybe Port
mport DnsName
dnsname) =
      ByteString -> Maybe PortNumber -> StakePoolRelay
StakePoolRelayDnsARecord
        (DnsName -> ByteString
fromShelleyDnsName DnsName
dnsname)
        (Word16 -> PortNumber
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> PortNumber) -> (Port -> Word16) -> Port -> PortNumber
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Port -> Word16
Ledger.portToWord16 (Port -> PortNumber) -> Maybe Port -> Maybe PortNumber
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StrictMaybe Port -> Maybe Port
forall a. StrictMaybe a -> Maybe a
Ledger.strictMaybeToMaybe StrictMaybe Port
mport)
    fromShelleyStakePoolRelay (Ledger.MultiHostName DnsName
dnsname) =
      ByteString -> StakePoolRelay
StakePoolRelayDnsSrvRecord
        (DnsName -> ByteString
fromShelleyDnsName DnsName
dnsname)

    fromShelleyPoolMetadata :: Ledger.PoolMetadata -> StakePoolMetadataReference
    fromShelleyPoolMetadata :: PoolMetadata -> StakePoolMetadataReference
fromShelleyPoolMetadata
      Ledger.PoolMetadata
        { Url
pmUrl :: PoolMetadata -> Url
pmUrl :: Url
Ledger.pmUrl
        , ByteArray
pmHash :: PoolMetadata -> ByteArray
pmHash :: ByteArray
Ledger.pmHash
        } =
        StakePoolMetadataReference
          { stakePoolMetadataURL :: Text
stakePoolMetadataURL = Url -> Text
Ledger.urlToText Url
pmUrl
          , stakePoolMetadataHash :: Hash StakePoolMetadata
stakePoolMetadataHash =
              Hash HASH ByteString -> Hash StakePoolMetadata
StakePoolMetadataHash
                (Hash HASH ByteString -> Hash StakePoolMetadata)
-> (ByteArray -> Hash HASH ByteString)
-> ByteArray
-> Hash StakePoolMetadata
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash HASH ByteString
-> Maybe (Hash HASH ByteString) -> Hash HASH ByteString
forall a. a -> Maybe a -> a
fromMaybe (String -> Hash HASH ByteString
forall a. HasCallStack => String -> a
error String
"fromShelleyPoolMetadata: invalid hash. TODO: proper validation")
                (Maybe (Hash HASH ByteString) -> Hash HASH ByteString)
-> (ByteArray -> Maybe (Hash HASH ByteString))
-> ByteArray
-> Hash HASH ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Maybe (Hash HASH ByteString)
forall h a. HashAlgorithm h => ByteString -> Maybe (Hash h a)
Ledger.hashFromBytes
                (ByteString -> Maybe (Hash HASH ByteString))
-> (ByteArray -> ByteString)
-> ByteArray
-> Maybe (Hash HASH ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ByteString
SBS.fromShort
                (ShortByteString -> ByteString)
-> (ByteArray -> ShortByteString) -> ByteArray -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteArray -> ShortByteString
byteArrayToShortByteString
                (ByteArray -> Hash StakePoolMetadata)
-> ByteArray -> Hash StakePoolMetadata
forall a b. (a -> b) -> a -> b
$ ByteArray
pmHash
          }

    -- TODO: change the ledger rep of the DNS name to use ShortByteString
    fromShelleyDnsName :: Ledger.DnsName -> ByteString
    fromShelleyDnsName :: DnsName -> ByteString
fromShelleyDnsName =
      Text -> ByteString
Text.encodeUtf8
        (Text -> ByteString) -> (DnsName -> Text) -> DnsName -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DnsName -> Text
Ledger.dnsToText

fromShelleyStakePoolState
  :: Ledger.Network
  -> Ledger.KeyHash Ledger.StakePool
  -> Ledger.StakePoolState
  -> StakePoolParameters
fromShelleyStakePoolState :: Network
-> KeyHash StakePool -> StakePoolState -> StakePoolParameters
fromShelleyStakePoolState Network
networkId KeyHash StakePool
poolId =
  StakePoolParams -> StakePoolParameters
fromShelleyPoolParams (StakePoolParams -> StakePoolParameters)
-> (StakePoolState -> StakePoolParams)
-> StakePoolState
-> StakePoolParameters
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Network -> KeyHash StakePool -> StakePoolState -> StakePoolParams
Ledger.stakePoolStateToStakePoolParams Network
networkId KeyHash StakePool
poolId