{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.CanonicalState.Namespace.EntitiesStakePools.V0 (
  EntitiesStakePoolsIn (..),
  EntitiesStakePoolsOut (..),
  CanonicalStakePool (..),
  CanonicalStakePoolState (..),
  CanonicalStakePoolParams (..),
  mkCanonicalStakePoolState,
  fromCanonicalStakePoolState,
  mkCanonicalStakePoolParams,
  fromCanonicalStakePoolParams,
) where

import Cardano.Ledger.BaseTypes (EpochNo, StrictMaybe, UnitInterval)
import Cardano.Ledger.CanonicalState.BasicTypes (
  CanonicalCoin (..),
  decodeNamespacedField,
 )
import Cardano.Ledger.CanonicalState.Namespace (Era, NamespaceEra)
import Cardano.Ledger.Compactible (Compactible (fromCompact), toCompactPartial)
import Cardano.Ledger.Core (
  AccountAddress,
  AccountId,
  KeyHash,
  KeyRole (StakePool),
  KeyRoleVRF (StakePoolVRF),
  Staking,
  VRFVerKeyHash,
 )
import Cardano.Ledger.Credential (Credential)
import Cardano.Ledger.State (
  PoolMetadata,
  StakePoolParams (..),
  StakePoolRelay,
  StakePoolState (..),
 )
import Cardano.SCLS.CBOR.Canonical.Decoder (FromCanonicalCBOR (..), decodeMapLenCanonicalOf)
import Cardano.SCLS.CBOR.Canonical.Encoder (ToCanonicalCBOR (..), encodeAsMap, mkEncodablePair)
import Cardano.SCLS.Entry.IsKey (IsKey (..))
import Cardano.SCLS.NamespaceCodec (
  CanonicalCBOREntryDecoder (..),
  CanonicalCBOREntryEncoder (..),
  KnownNamespace (..),
  NamespaceKeySize,
  namespaceKeySize,
 )
import Cardano.SCLS.Versioned (Versioned (..))
import Data.MemPack (MemPack (packM, unpackM))
import Data.Proxy (Proxy (..))
import Data.Sequence.Strict (StrictSeq)
import Data.Set (Set)
import Data.Text (Text)
import GHC.Generics (Generic)

instance
  ( Era era
  , NamespaceEra "entities/stake_pools/v0" ~ era
  , ToCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool
  , FromCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool
  ) =>
  KnownNamespace "entities/stake_pools/v0"
  where
  type NamespaceKey "entities/stake_pools/v0" = EntitiesStakePoolsIn
  type NamespaceEntry "entities/stake_pools/v0" = EntitiesStakePoolsOut

instance
  ( Era era
  , NamespaceEra "entities/stake_pools/v0" ~ era
  , ToCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool
  ) =>
  CanonicalCBOREntryEncoder "entities/stake_pools/v0" EntitiesStakePoolsOut
  where
  encodeEntry :: EntitiesStakePoolsOut -> CanonicalEncoding
encodeEntry (EntitiesStakePoolsOut CanonicalStakePool
n) = Proxy "entities/stake_pools/v0"
-> CanonicalStakePool -> CanonicalEncoding
forall (v :: Symbol) a (proxy :: Symbol -> *).
ToCanonicalCBOR v a =>
proxy v -> a -> CanonicalEncoding
forall (proxy :: Symbol -> *).
proxy "entities/stake_pools/v0"
-> CanonicalStakePool -> CanonicalEncoding
toCanonicalCBOR (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
Proxy @"entities/stake_pools/v0") CanonicalStakePool
n

instance
  ( Era era
  , NamespaceEra "entities/stake_pools/v0" ~ era
  , FromCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool
  ) =>
  CanonicalCBOREntryDecoder "entities/stake_pools/v0" EntitiesStakePoolsOut
  where
  decodeEntry :: forall s.
CanonicalDecoder
  s (Versioned "entities/stake_pools/v0" EntitiesStakePoolsOut)
decodeEntry = (CanonicalStakePool -> EntitiesStakePoolsOut)
-> Versioned "entities/stake_pools/v0" CanonicalStakePool
-> Versioned "entities/stake_pools/v0" EntitiesStakePoolsOut
forall a b.
(a -> b)
-> Versioned "entities/stake_pools/v0" a
-> Versioned "entities/stake_pools/v0" b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CanonicalStakePool -> EntitiesStakePoolsOut
EntitiesStakePoolsOut (Versioned "entities/stake_pools/v0" CanonicalStakePool
 -> Versioned "entities/stake_pools/v0" EntitiesStakePoolsOut)
-> CanonicalDecoder
     s (Versioned "entities/stake_pools/v0" CanonicalStakePool)
-> CanonicalDecoder
     s (Versioned "entities/stake_pools/v0" EntitiesStakePoolsOut)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CanonicalDecoder
  s (Versioned "entities/stake_pools/v0" CanonicalStakePool)
forall s.
CanonicalDecoder
  s (Versioned "entities/stake_pools/v0" CanonicalStakePool)
forall (v :: Symbol) a s.
FromCanonicalCBOR v a =>
CanonicalDecoder s (Versioned v a)
fromCanonicalCBOR

newtype EntitiesStakePoolsIn = EntitiesStakePoolsIn (KeyHash StakePool)
  deriving (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
(EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> Eq EntitiesStakePoolsIn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
== :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
$c/= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
/= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
Eq, Eq EntitiesStakePoolsIn
Eq EntitiesStakePoolsIn =>
(EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Ordering)
-> (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> (EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool)
-> (EntitiesStakePoolsIn
    -> EntitiesStakePoolsIn -> EntitiesStakePoolsIn)
-> (EntitiesStakePoolsIn
    -> EntitiesStakePoolsIn -> EntitiesStakePoolsIn)
-> Ord EntitiesStakePoolsIn
EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Ordering
EntitiesStakePoolsIn
-> EntitiesStakePoolsIn -> EntitiesStakePoolsIn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Ordering
compare :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Ordering
$c< :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
< :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
$c<= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
<= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
$c> :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
> :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
$c>= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
>= :: EntitiesStakePoolsIn -> EntitiesStakePoolsIn -> Bool
$cmax :: EntitiesStakePoolsIn
-> EntitiesStakePoolsIn -> EntitiesStakePoolsIn
max :: EntitiesStakePoolsIn
-> EntitiesStakePoolsIn -> EntitiesStakePoolsIn
$cmin :: EntitiesStakePoolsIn
-> EntitiesStakePoolsIn -> EntitiesStakePoolsIn
min :: EntitiesStakePoolsIn
-> EntitiesStakePoolsIn -> EntitiesStakePoolsIn
Ord, Int -> EntitiesStakePoolsIn -> ShowS
[EntitiesStakePoolsIn] -> ShowS
EntitiesStakePoolsIn -> String
(Int -> EntitiesStakePoolsIn -> ShowS)
-> (EntitiesStakePoolsIn -> String)
-> ([EntitiesStakePoolsIn] -> ShowS)
-> Show EntitiesStakePoolsIn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EntitiesStakePoolsIn -> ShowS
showsPrec :: Int -> EntitiesStakePoolsIn -> ShowS
$cshow :: EntitiesStakePoolsIn -> String
show :: EntitiesStakePoolsIn -> String
$cshowList :: [EntitiesStakePoolsIn] -> ShowS
showList :: [EntitiesStakePoolsIn] -> ShowS
Show)

type instance NamespaceKeySize "entities/stake_pools/v0" = 28

instance IsKey EntitiesStakePoolsIn where
  keySize :: Int
keySize = forall (ns :: Symbol). KnownNat (NamespaceKeySize ns) => Int
namespaceKeySize @"entities/stake_pools/v0"
  packKeyM :: forall b. EntitiesStakePoolsIn -> Pack b ()
packKeyM (EntitiesStakePoolsIn KeyHash StakePool
stakePoolKey) =
    KeyHash StakePool -> Pack b ()
forall s. KeyHash StakePool -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM KeyHash StakePool
stakePoolKey
  unpackKeyM :: forall b s. Buffer b => Unpack' s b EntitiesStakePoolsIn
unpackKeyM =
    KeyHash StakePool -> EntitiesStakePoolsIn
EntitiesStakePoolsIn (KeyHash StakePool -> EntitiesStakePoolsIn)
-> Unpack s b (KeyHash StakePool)
-> Unpack s b EntitiesStakePoolsIn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Unpack s b (KeyHash StakePool)
forall a b s. (MemPack a, Buffer b) => Unpack s b a
forall b s. Buffer b => Unpack s b (KeyHash StakePool)
unpackM

newtype EntitiesStakePoolsOut
  = EntitiesStakePoolsOut CanonicalStakePool
  deriving (EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool
(EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool)
-> (EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool)
-> Eq EntitiesStakePoolsOut
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool
== :: EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool
$c/= :: EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool
/= :: EntitiesStakePoolsOut -> EntitiesStakePoolsOut -> Bool
Eq, Int -> EntitiesStakePoolsOut -> ShowS
[EntitiesStakePoolsOut] -> ShowS
EntitiesStakePoolsOut -> String
(Int -> EntitiesStakePoolsOut -> ShowS)
-> (EntitiesStakePoolsOut -> String)
-> ([EntitiesStakePoolsOut] -> ShowS)
-> Show EntitiesStakePoolsOut
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EntitiesStakePoolsOut -> ShowS
showsPrec :: Int -> EntitiesStakePoolsOut -> ShowS
$cshow :: EntitiesStakePoolsOut -> String
show :: EntitiesStakePoolsOut -> String
$cshowList :: [EntitiesStakePoolsOut] -> ShowS
showList :: [EntitiesStakePoolsOut] -> ShowS
Show, (forall x. EntitiesStakePoolsOut -> Rep EntitiesStakePoolsOut x)
-> (forall x. Rep EntitiesStakePoolsOut x -> EntitiesStakePoolsOut)
-> Generic EntitiesStakePoolsOut
forall x. Rep EntitiesStakePoolsOut x -> EntitiesStakePoolsOut
forall x. EntitiesStakePoolsOut -> Rep EntitiesStakePoolsOut x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EntitiesStakePoolsOut -> Rep EntitiesStakePoolsOut x
from :: forall x. EntitiesStakePoolsOut -> Rep EntitiesStakePoolsOut x
$cto :: forall x. Rep EntitiesStakePoolsOut x -> EntitiesStakePoolsOut
to :: forall x. Rep EntitiesStakePoolsOut x -> EntitiesStakePoolsOut
Generic)

deriving newtype instance
  ToCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool =>
  ToCanonicalCBOR "entities/stake_pools/v0" EntitiesStakePoolsOut

deriving newtype instance
  FromCanonicalCBOR "entities/stake_pools/v0" CanonicalStakePool =>
  FromCanonicalCBOR "entities/stake_pools/v0" EntitiesStakePoolsOut

data CanonicalStakePool = CanonicalStakePool
  { CanonicalStakePool -> StrictMaybe CanonicalStakePoolState
cspStakePoolState :: !(StrictMaybe CanonicalStakePoolState)
  , CanonicalStakePool -> StrictMaybe CanonicalStakePoolParams
cspFutureStakePoolParams :: !(StrictMaybe CanonicalStakePoolParams)
  , CanonicalStakePool -> StrictMaybe EpochNo
cspRetiringEpochNo :: !(StrictMaybe EpochNo)
  }
  deriving (Int -> CanonicalStakePool -> ShowS
[CanonicalStakePool] -> ShowS
CanonicalStakePool -> String
(Int -> CanonicalStakePool -> ShowS)
-> (CanonicalStakePool -> String)
-> ([CanonicalStakePool] -> ShowS)
-> Show CanonicalStakePool
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CanonicalStakePool -> ShowS
showsPrec :: Int -> CanonicalStakePool -> ShowS
$cshow :: CanonicalStakePool -> String
show :: CanonicalStakePool -> String
$cshowList :: [CanonicalStakePool] -> ShowS
showList :: [CanonicalStakePool] -> ShowS
Show, CanonicalStakePool -> CanonicalStakePool -> Bool
(CanonicalStakePool -> CanonicalStakePool -> Bool)
-> (CanonicalStakePool -> CanonicalStakePool -> Bool)
-> Eq CanonicalStakePool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CanonicalStakePool -> CanonicalStakePool -> Bool
== :: CanonicalStakePool -> CanonicalStakePool -> Bool
$c/= :: CanonicalStakePool -> CanonicalStakePool -> Bool
/= :: CanonicalStakePool -> CanonicalStakePool -> Bool
Eq, (forall x. CanonicalStakePool -> Rep CanonicalStakePool x)
-> (forall x. Rep CanonicalStakePool x -> CanonicalStakePool)
-> Generic CanonicalStakePool
forall x. Rep CanonicalStakePool x -> CanonicalStakePool
forall x. CanonicalStakePool -> Rep CanonicalStakePool x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CanonicalStakePool -> Rep CanonicalStakePool x
from :: forall x. CanonicalStakePool -> Rep CanonicalStakePool x
$cto :: forall x. Rep CanonicalStakePool x -> CanonicalStakePool
to :: forall x. Rep CanonicalStakePool x -> CanonicalStakePool
Generic)

instance (Era era, NamespaceEra v ~ era) => ToCanonicalCBOR v CanonicalStakePool where
  toCanonicalCBOR :: forall (proxy :: Symbol -> *).
proxy v -> CanonicalStakePool -> CanonicalEncoding
toCanonicalCBOR proxy v
v CanonicalStakePool {StrictMaybe EpochNo
StrictMaybe CanonicalStakePoolParams
StrictMaybe CanonicalStakePoolState
cspStakePoolState :: CanonicalStakePool -> StrictMaybe CanonicalStakePoolState
cspFutureStakePoolParams :: CanonicalStakePool -> StrictMaybe CanonicalStakePoolParams
cspRetiringEpochNo :: CanonicalStakePool -> StrictMaybe EpochNo
cspStakePoolState :: StrictMaybe CanonicalStakePoolState
cspFutureStakePoolParams :: StrictMaybe CanonicalStakePoolParams
cspRetiringEpochNo :: StrictMaybe EpochNo
..} =
    [SomeEncodablePair v] -> CanonicalEncoding
forall (v :: Symbol) (t :: * -> *).
Traversable t =>
t (SomeEncodablePair v) -> CanonicalEncoding
encodeAsMap
      [ proxy v
-> Text
-> StrictMaybe CanonicalStakePoolState
-> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"stake_pool_state" :: Text) StrictMaybe CanonicalStakePoolState
cspStakePoolState
      , proxy v -> Text -> StrictMaybe EpochNo -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"retiring_epoch_no" :: Text) StrictMaybe EpochNo
cspRetiringEpochNo
      , proxy v
-> Text
-> StrictMaybe CanonicalStakePoolParams
-> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"future_stake_pool_params" :: Text) StrictMaybe CanonicalStakePoolParams
cspFutureStakePoolParams
      ]

instance (Era era, NamespaceEra v ~ era) => FromCanonicalCBOR v CanonicalStakePool where
  fromCanonicalCBOR :: forall s. CanonicalDecoder s (Versioned v CanonicalStakePool)
fromCanonicalCBOR = do
    Int -> CanonicalDecoder s ()
forall s. Int -> CanonicalDecoder s ()
decodeMapLenCanonicalOf Int
3
    Versioned cspStakePoolState <- forall (v :: Symbol) s a.
FromCanonicalCBOR v a =>
Text -> CanonicalDecoder s (Versioned v a)
decodeNamespacedField @v Text
"stake_pool_state"
    Versioned cspRetiringEpochNo <- decodeNamespacedField @v "retiring_epoch_no"
    Versioned cspFutureStakePoolParams <- decodeNamespacedField @v "future_stake_pool_params"
    pure $ Versioned CanonicalStakePool {..}

data CanonicalStakePoolState = CanonicalStakePoolState
  { CanonicalStakePoolState -> VRFVerKeyHash StakePoolVRF
cspsVrf :: !(VRFVerKeyHash StakePoolVRF)
  , CanonicalStakePoolState -> CanonicalCoin
cspsPledge :: !CanonicalCoin
  , CanonicalStakePoolState -> CanonicalCoin
cspsCost :: !CanonicalCoin
  , CanonicalStakePoolState -> UnitInterval
cspsMargin :: !UnitInterval
  , CanonicalStakePoolState -> AccountId
cspsAccountId :: !AccountId
  , CanonicalStakePoolState -> Set (KeyHash Staking)
cspsOwners :: !(Set (KeyHash Staking))
  , CanonicalStakePoolState -> StrictSeq StakePoolRelay
cspsRelays :: !(StrictSeq StakePoolRelay)
  , CanonicalStakePoolState -> StrictMaybe PoolMetadata
cspsMetadata :: !(StrictMaybe PoolMetadata)
  , CanonicalStakePoolState -> CanonicalCoin
cspsDeposit :: !CanonicalCoin
  , CanonicalStakePoolState -> Set (Credential Staking)
cspsDelegators :: !(Set (Credential Staking))
  }
  deriving (Int -> CanonicalStakePoolState -> ShowS
[CanonicalStakePoolState] -> ShowS
CanonicalStakePoolState -> String
(Int -> CanonicalStakePoolState -> ShowS)
-> (CanonicalStakePoolState -> String)
-> ([CanonicalStakePoolState] -> ShowS)
-> Show CanonicalStakePoolState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CanonicalStakePoolState -> ShowS
showsPrec :: Int -> CanonicalStakePoolState -> ShowS
$cshow :: CanonicalStakePoolState -> String
show :: CanonicalStakePoolState -> String
$cshowList :: [CanonicalStakePoolState] -> ShowS
showList :: [CanonicalStakePoolState] -> ShowS
Show, CanonicalStakePoolState -> CanonicalStakePoolState -> Bool
(CanonicalStakePoolState -> CanonicalStakePoolState -> Bool)
-> (CanonicalStakePoolState -> CanonicalStakePoolState -> Bool)
-> Eq CanonicalStakePoolState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CanonicalStakePoolState -> CanonicalStakePoolState -> Bool
== :: CanonicalStakePoolState -> CanonicalStakePoolState -> Bool
$c/= :: CanonicalStakePoolState -> CanonicalStakePoolState -> Bool
/= :: CanonicalStakePoolState -> CanonicalStakePoolState -> Bool
Eq, (forall x.
 CanonicalStakePoolState -> Rep CanonicalStakePoolState x)
-> (forall x.
    Rep CanonicalStakePoolState x -> CanonicalStakePoolState)
-> Generic CanonicalStakePoolState
forall x. Rep CanonicalStakePoolState x -> CanonicalStakePoolState
forall x. CanonicalStakePoolState -> Rep CanonicalStakePoolState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CanonicalStakePoolState -> Rep CanonicalStakePoolState x
from :: forall x. CanonicalStakePoolState -> Rep CanonicalStakePoolState x
$cto :: forall x. Rep CanonicalStakePoolState x -> CanonicalStakePoolState
to :: forall x. Rep CanonicalStakePoolState x -> CanonicalStakePoolState
Generic)

instance (Era era, NamespaceEra v ~ era) => ToCanonicalCBOR v CanonicalStakePoolState where
  toCanonicalCBOR :: forall (proxy :: Symbol -> *).
proxy v -> CanonicalStakePoolState -> CanonicalEncoding
toCanonicalCBOR proxy v
v CanonicalStakePoolState {Set (KeyHash Staking)
Set (Credential Staking)
StrictMaybe PoolMetadata
VRFVerKeyHash StakePoolVRF
UnitInterval
AccountId
StrictSeq StakePoolRelay
CanonicalCoin
cspsVrf :: CanonicalStakePoolState -> VRFVerKeyHash StakePoolVRF
cspsPledge :: CanonicalStakePoolState -> CanonicalCoin
cspsCost :: CanonicalStakePoolState -> CanonicalCoin
cspsMargin :: CanonicalStakePoolState -> UnitInterval
cspsAccountId :: CanonicalStakePoolState -> AccountId
cspsOwners :: CanonicalStakePoolState -> Set (KeyHash Staking)
cspsRelays :: CanonicalStakePoolState -> StrictSeq StakePoolRelay
cspsMetadata :: CanonicalStakePoolState -> StrictMaybe PoolMetadata
cspsDeposit :: CanonicalStakePoolState -> CanonicalCoin
cspsDelegators :: CanonicalStakePoolState -> Set (Credential Staking)
cspsVrf :: VRFVerKeyHash StakePoolVRF
cspsPledge :: CanonicalCoin
cspsCost :: CanonicalCoin
cspsMargin :: UnitInterval
cspsAccountId :: AccountId
cspsOwners :: Set (KeyHash Staking)
cspsRelays :: StrictSeq StakePoolRelay
cspsMetadata :: StrictMaybe PoolMetadata
cspsDeposit :: CanonicalCoin
cspsDelegators :: Set (Credential Staking)
..} =
    [SomeEncodablePair v] -> CanonicalEncoding
forall (v :: Symbol) (t :: * -> *).
Traversable t =>
t (SomeEncodablePair v) -> CanonicalEncoding
encodeAsMap
      [ proxy v
-> Text -> VRFVerKeyHash StakePoolVRF -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"vrf" :: Text) VRFVerKeyHash StakePoolVRF
cspsVrf
      , proxy v -> Text -> CanonicalCoin -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"cost" :: Text) CanonicalCoin
cspsCost
      , proxy v -> Text -> UnitInterval -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"margin" :: Text) UnitInterval
cspsMargin
      , proxy v -> Text -> Set (KeyHash Staking) -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"owners" :: Text) Set (KeyHash Staking)
cspsOwners
      , proxy v -> Text -> CanonicalCoin -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"pledge" :: Text) CanonicalCoin
cspsPledge
      , proxy v -> Text -> StrictSeq StakePoolRelay -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"relays" :: Text) StrictSeq StakePoolRelay
cspsRelays
      , proxy v -> Text -> CanonicalCoin -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"deposit" :: Text) CanonicalCoin
cspsDeposit
      , proxy v -> Text -> StrictMaybe PoolMetadata -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"metadata" :: Text) StrictMaybe PoolMetadata
cspsMetadata
      , proxy v -> Text -> AccountId -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"account_id" :: Text) AccountId
cspsAccountId
      , proxy v -> Text -> Set (Credential Staking) -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"delegators" :: Text) Set (Credential Staking)
cspsDelegators
      ]

instance (Era era, NamespaceEra v ~ era) => FromCanonicalCBOR v CanonicalStakePoolState where
  fromCanonicalCBOR :: forall s. CanonicalDecoder s (Versioned v CanonicalStakePoolState)
fromCanonicalCBOR = do
    Int -> CanonicalDecoder s ()
forall s. Int -> CanonicalDecoder s ()
decodeMapLenCanonicalOf Int
10
    Versioned cspsVrf <- forall (v :: Symbol) s a.
FromCanonicalCBOR v a =>
Text -> CanonicalDecoder s (Versioned v a)
decodeNamespacedField @v Text
"vrf"
    Versioned cspsCost <- decodeNamespacedField @v "cost"
    Versioned cspsMargin <- decodeNamespacedField @v "margin"
    Versioned cspsOwners <- decodeNamespacedField @v "owners"
    Versioned cspsPledge <- decodeNamespacedField @v "pledge"
    Versioned cspsRelays <- decodeNamespacedField @v "relays"
    Versioned cspsDeposit <- decodeNamespacedField @v "deposit"
    Versioned cspsMetadata <- decodeNamespacedField @v "metadata"
    Versioned cspsAccountId <- decodeNamespacedField @v "account_id"
    Versioned cspsDelegators <- decodeNamespacedField @v "delegators"
    pure $ Versioned CanonicalStakePoolState {..}

mkCanonicalStakePoolState :: StakePoolState -> CanonicalStakePoolState
mkCanonicalStakePoolState :: StakePoolState -> CanonicalStakePoolState
mkCanonicalStakePoolState (StakePoolState {Set (KeyHash Staking)
Set (Credential Staking)
StrictMaybe PoolMetadata
CompactForm Coin
VRFVerKeyHash StakePoolVRF
UnitInterval
Coin
AccountId
StrictSeq StakePoolRelay
spsVrf :: VRFVerKeyHash StakePoolVRF
spsPledge :: Coin
spsCost :: Coin
spsMargin :: UnitInterval
spsAccountId :: AccountId
spsOwners :: Set (KeyHash Staking)
spsRelays :: StrictSeq StakePoolRelay
spsMetadata :: StrictMaybe PoolMetadata
spsDeposit :: CompactForm Coin
spsDelegators :: Set (Credential Staking)
spsDelegators :: StakePoolState -> Set (Credential Staking)
spsDeposit :: StakePoolState -> CompactForm Coin
spsMetadata :: StakePoolState -> StrictMaybe PoolMetadata
spsRelays :: StakePoolState -> StrictSeq StakePoolRelay
spsOwners :: StakePoolState -> Set (KeyHash Staking)
spsAccountId :: StakePoolState -> AccountId
spsMargin :: StakePoolState -> UnitInterval
spsCost :: StakePoolState -> Coin
spsPledge :: StakePoolState -> Coin
spsVrf :: StakePoolState -> VRFVerKeyHash StakePoolVRF
..}) =
  CanonicalStakePoolState
    { cspsVrf :: VRFVerKeyHash StakePoolVRF
cspsVrf = VRFVerKeyHash StakePoolVRF
spsVrf
    , cspsPledge :: CanonicalCoin
cspsPledge = CompactForm Coin -> CanonicalCoin
CanonicalCoin (Coin -> CompactForm Coin
forall a. (HasCallStack, Compactible a) => a -> CompactForm a
toCompactPartial Coin
spsPledge)
    , cspsCost :: CanonicalCoin
cspsCost = CompactForm Coin -> CanonicalCoin
CanonicalCoin (Coin -> CompactForm Coin
forall a. (HasCallStack, Compactible a) => a -> CompactForm a
toCompactPartial Coin
spsCost)
    , cspsMargin :: UnitInterval
cspsMargin = UnitInterval
spsMargin
    , cspsAccountId :: AccountId
cspsAccountId = AccountId
spsAccountId
    , cspsOwners :: Set (KeyHash Staking)
cspsOwners = Set (KeyHash Staking)
spsOwners
    , cspsRelays :: StrictSeq StakePoolRelay
cspsRelays = StrictSeq StakePoolRelay
spsRelays
    , cspsMetadata :: StrictMaybe PoolMetadata
cspsMetadata = StrictMaybe PoolMetadata
spsMetadata
    , cspsDeposit :: CanonicalCoin
cspsDeposit = CompactForm Coin -> CanonicalCoin
CanonicalCoin CompactForm Coin
spsDeposit
    , cspsDelegators :: Set (Credential Staking)
cspsDelegators = Set (Credential Staking)
spsDelegators
    }

fromCanonicalStakePoolState :: CanonicalStakePoolState -> StakePoolState
fromCanonicalStakePoolState :: CanonicalStakePoolState -> StakePoolState
fromCanonicalStakePoolState (CanonicalStakePoolState {Set (KeyHash Staking)
Set (Credential Staking)
StrictMaybe PoolMetadata
VRFVerKeyHash StakePoolVRF
UnitInterval
AccountId
StrictSeq StakePoolRelay
CanonicalCoin
cspsVrf :: CanonicalStakePoolState -> VRFVerKeyHash StakePoolVRF
cspsPledge :: CanonicalStakePoolState -> CanonicalCoin
cspsCost :: CanonicalStakePoolState -> CanonicalCoin
cspsMargin :: CanonicalStakePoolState -> UnitInterval
cspsAccountId :: CanonicalStakePoolState -> AccountId
cspsOwners :: CanonicalStakePoolState -> Set (KeyHash Staking)
cspsRelays :: CanonicalStakePoolState -> StrictSeq StakePoolRelay
cspsMetadata :: CanonicalStakePoolState -> StrictMaybe PoolMetadata
cspsDeposit :: CanonicalStakePoolState -> CanonicalCoin
cspsDelegators :: CanonicalStakePoolState -> Set (Credential Staking)
cspsVrf :: VRFVerKeyHash StakePoolVRF
cspsPledge :: CanonicalCoin
cspsCost :: CanonicalCoin
cspsMargin :: UnitInterval
cspsAccountId :: AccountId
cspsOwners :: Set (KeyHash Staking)
cspsRelays :: StrictSeq StakePoolRelay
cspsMetadata :: StrictMaybe PoolMetadata
cspsDeposit :: CanonicalCoin
cspsDelegators :: Set (Credential Staking)
..}) =
  StakePoolState
    { spsVrf :: VRFVerKeyHash StakePoolVRF
spsVrf = VRFVerKeyHash StakePoolVRF
cspsVrf
    , spsPledge :: Coin
spsPledge = CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin) -> CompactForm Coin -> Coin
forall a b. (a -> b) -> a -> b
$ CanonicalCoin -> CompactForm Coin
unCoin CanonicalCoin
cspsPledge
    , spsCost :: Coin
spsCost = CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin) -> CompactForm Coin -> Coin
forall a b. (a -> b) -> a -> b
$ CanonicalCoin -> CompactForm Coin
unCoin CanonicalCoin
cspsCost
    , spsMargin :: UnitInterval
spsMargin = UnitInterval
cspsMargin
    , spsAccountId :: AccountId
spsAccountId = AccountId
cspsAccountId
    , spsOwners :: Set (KeyHash Staking)
spsOwners = Set (KeyHash Staking)
cspsOwners
    , spsRelays :: StrictSeq StakePoolRelay
spsRelays = StrictSeq StakePoolRelay
cspsRelays
    , spsMetadata :: StrictMaybe PoolMetadata
spsMetadata = StrictMaybe PoolMetadata
cspsMetadata
    , spsDeposit :: CompactForm Coin
spsDeposit = CanonicalCoin -> CompactForm Coin
unCoin CanonicalCoin
cspsDeposit
    , spsDelegators :: Set (Credential Staking)
spsDelegators = Set (Credential Staking)
cspsDelegators
    }

data CanonicalStakePoolParams = CanonicalStakePoolParams
  { CanonicalStakePoolParams -> KeyHash StakePool
csppId :: !(KeyHash StakePool)
  , CanonicalStakePoolParams -> VRFVerKeyHash StakePoolVRF
csppVrf :: !(VRFVerKeyHash StakePoolVRF)
  , CanonicalStakePoolParams -> CanonicalCoin
csppPledge :: !CanonicalCoin
  , CanonicalStakePoolParams -> CanonicalCoin
csppCost :: !CanonicalCoin
  , CanonicalStakePoolParams -> UnitInterval
csppMargin :: !UnitInterval
  , CanonicalStakePoolParams -> AccountAddress
csppAccountAddress :: !AccountAddress
  , CanonicalStakePoolParams -> Set (KeyHash Staking)
csppOwners :: !(Set (KeyHash Staking))
  , CanonicalStakePoolParams -> StrictSeq StakePoolRelay
csppRelays :: !(StrictSeq StakePoolRelay)
  , CanonicalStakePoolParams -> StrictMaybe PoolMetadata
csppMetadata :: !(StrictMaybe PoolMetadata)
  }
  deriving (Int -> CanonicalStakePoolParams -> ShowS
[CanonicalStakePoolParams] -> ShowS
CanonicalStakePoolParams -> String
(Int -> CanonicalStakePoolParams -> ShowS)
-> (CanonicalStakePoolParams -> String)
-> ([CanonicalStakePoolParams] -> ShowS)
-> Show CanonicalStakePoolParams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CanonicalStakePoolParams -> ShowS
showsPrec :: Int -> CanonicalStakePoolParams -> ShowS
$cshow :: CanonicalStakePoolParams -> String
show :: CanonicalStakePoolParams -> String
$cshowList :: [CanonicalStakePoolParams] -> ShowS
showList :: [CanonicalStakePoolParams] -> ShowS
Show, CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool
(CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool)
-> (CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool)
-> Eq CanonicalStakePoolParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool
== :: CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool
$c/= :: CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool
/= :: CanonicalStakePoolParams -> CanonicalStakePoolParams -> Bool
Eq, (forall x.
 CanonicalStakePoolParams -> Rep CanonicalStakePoolParams x)
-> (forall x.
    Rep CanonicalStakePoolParams x -> CanonicalStakePoolParams)
-> Generic CanonicalStakePoolParams
forall x.
Rep CanonicalStakePoolParams x -> CanonicalStakePoolParams
forall x.
CanonicalStakePoolParams -> Rep CanonicalStakePoolParams x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
CanonicalStakePoolParams -> Rep CanonicalStakePoolParams x
from :: forall x.
CanonicalStakePoolParams -> Rep CanonicalStakePoolParams x
$cto :: forall x.
Rep CanonicalStakePoolParams x -> CanonicalStakePoolParams
to :: forall x.
Rep CanonicalStakePoolParams x -> CanonicalStakePoolParams
Generic)

instance (Era era, NamespaceEra v ~ era) => ToCanonicalCBOR v CanonicalStakePoolParams where
  toCanonicalCBOR :: forall (proxy :: Symbol -> *).
proxy v -> CanonicalStakePoolParams -> CanonicalEncoding
toCanonicalCBOR proxy v
v CanonicalStakePoolParams {Set (KeyHash Staking)
StrictMaybe PoolMetadata
VRFVerKeyHash StakePoolVRF
KeyHash StakePool
UnitInterval
AccountAddress
StrictSeq StakePoolRelay
CanonicalCoin
csppId :: CanonicalStakePoolParams -> KeyHash StakePool
csppVrf :: CanonicalStakePoolParams -> VRFVerKeyHash StakePoolVRF
csppPledge :: CanonicalStakePoolParams -> CanonicalCoin
csppCost :: CanonicalStakePoolParams -> CanonicalCoin
csppMargin :: CanonicalStakePoolParams -> UnitInterval
csppAccountAddress :: CanonicalStakePoolParams -> AccountAddress
csppOwners :: CanonicalStakePoolParams -> Set (KeyHash Staking)
csppRelays :: CanonicalStakePoolParams -> StrictSeq StakePoolRelay
csppMetadata :: CanonicalStakePoolParams -> StrictMaybe PoolMetadata
csppId :: KeyHash StakePool
csppVrf :: VRFVerKeyHash StakePoolVRF
csppPledge :: CanonicalCoin
csppCost :: CanonicalCoin
csppMargin :: UnitInterval
csppAccountAddress :: AccountAddress
csppOwners :: Set (KeyHash Staking)
csppRelays :: StrictSeq StakePoolRelay
csppMetadata :: StrictMaybe PoolMetadata
..} =
    [SomeEncodablePair v] -> CanonicalEncoding
forall (v :: Symbol) (t :: * -> *).
Traversable t =>
t (SomeEncodablePair v) -> CanonicalEncoding
encodeAsMap
      [ proxy v -> Text -> KeyHash StakePool -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"id" :: Text) KeyHash StakePool
csppId
      , proxy v
-> Text -> VRFVerKeyHash StakePoolVRF -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"vrf" :: Text) VRFVerKeyHash StakePoolVRF
csppVrf
      , proxy v -> Text -> CanonicalCoin -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"cost" :: Text) CanonicalCoin
csppCost
      , proxy v -> Text -> UnitInterval -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"margin" :: Text) UnitInterval
csppMargin
      , proxy v -> Text -> Set (KeyHash Staking) -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"owners" :: Text) Set (KeyHash Staking)
csppOwners
      , proxy v -> Text -> CanonicalCoin -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"pledge" :: Text) CanonicalCoin
csppPledge
      , proxy v -> Text -> StrictSeq StakePoolRelay -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"relays" :: Text) StrictSeq StakePoolRelay
csppRelays
      , proxy v -> Text -> StrictMaybe PoolMetadata -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"metadata" :: Text) StrictMaybe PoolMetadata
csppMetadata
      , proxy v -> Text -> AccountAddress -> SomeEncodablePair v
forall (v :: Symbol) k val (proxy :: Symbol -> *).
(ToCanonicalCBOR v k, ToCanonicalCBOR v val) =>
proxy v -> k -> val -> SomeEncodablePair v
mkEncodablePair proxy v
v (Text
"account_address" :: Text) AccountAddress
csppAccountAddress
      ]

instance (Era era, NamespaceEra v ~ era) => FromCanonicalCBOR v CanonicalStakePoolParams where
  fromCanonicalCBOR :: forall s. CanonicalDecoder s (Versioned v CanonicalStakePoolParams)
fromCanonicalCBOR = do
    Int -> CanonicalDecoder s ()
forall s. Int -> CanonicalDecoder s ()
decodeMapLenCanonicalOf Int
9
    Versioned csppId <- forall (v :: Symbol) s a.
FromCanonicalCBOR v a =>
Text -> CanonicalDecoder s (Versioned v a)
decodeNamespacedField @v Text
"id"
    Versioned csppVrf <- decodeNamespacedField @v "vrf"
    Versioned csppCost <- decodeNamespacedField @v "cost"
    Versioned csppMargin <- decodeNamespacedField @v "margin"
    Versioned csppOwners <- decodeNamespacedField @v "owners"
    Versioned csppPledge <- decodeNamespacedField @v "pledge"
    Versioned csppRelays <- decodeNamespacedField @v "relays"
    Versioned csppMetadata <- decodeNamespacedField @v "metadata"
    Versioned csppAccountAddress <- decodeNamespacedField @v "account_address"
    pure $ Versioned CanonicalStakePoolParams {..}

mkCanonicalStakePoolParams :: StakePoolParams -> CanonicalStakePoolParams
mkCanonicalStakePoolParams :: StakePoolParams -> CanonicalStakePoolParams
mkCanonicalStakePoolParams (StakePoolParams {Set (KeyHash Staking)
StrictMaybe PoolMetadata
VRFVerKeyHash StakePoolVRF
KeyHash StakePool
UnitInterval
Coin
AccountAddress
StrictSeq StakePoolRelay
sppId :: KeyHash StakePool
sppVrf :: VRFVerKeyHash StakePoolVRF
sppPledge :: Coin
sppCost :: Coin
sppMargin :: UnitInterval
sppAccountAddress :: AccountAddress
sppOwners :: Set (KeyHash Staking)
sppRelays :: StrictSeq StakePoolRelay
sppMetadata :: StrictMaybe PoolMetadata
sppMetadata :: StakePoolParams -> StrictMaybe PoolMetadata
sppRelays :: StakePoolParams -> StrictSeq StakePoolRelay
sppOwners :: StakePoolParams -> Set (KeyHash Staking)
sppAccountAddress :: StakePoolParams -> AccountAddress
sppMargin :: StakePoolParams -> UnitInterval
sppCost :: StakePoolParams -> Coin
sppPledge :: StakePoolParams -> Coin
sppVrf :: StakePoolParams -> VRFVerKeyHash StakePoolVRF
sppId :: StakePoolParams -> KeyHash StakePool
..}) =
  CanonicalStakePoolParams
    { csppId :: KeyHash StakePool
csppId = KeyHash StakePool
sppId
    , csppVrf :: VRFVerKeyHash StakePoolVRF
csppVrf = VRFVerKeyHash StakePoolVRF
sppVrf
    , csppCost :: CanonicalCoin
csppCost = CompactForm Coin -> CanonicalCoin
CanonicalCoin (Coin -> CompactForm Coin
forall a. (HasCallStack, Compactible a) => a -> CompactForm a
toCompactPartial Coin
sppCost)
    , csppMargin :: UnitInterval
csppMargin = UnitInterval
sppMargin
    , csppPledge :: CanonicalCoin
csppPledge = CompactForm Coin -> CanonicalCoin
CanonicalCoin (Coin -> CompactForm Coin
forall a. (HasCallStack, Compactible a) => a -> CompactForm a
toCompactPartial Coin
sppPledge)
    , csppOwners :: Set (KeyHash Staking)
csppOwners = Set (KeyHash Staking)
sppOwners
    , csppRelays :: StrictSeq StakePoolRelay
csppRelays = StrictSeq StakePoolRelay
sppRelays
    , csppMetadata :: StrictMaybe PoolMetadata
csppMetadata = StrictMaybe PoolMetadata
sppMetadata
    , csppAccountAddress :: AccountAddress
csppAccountAddress = AccountAddress
sppAccountAddress
    }

fromCanonicalStakePoolParams :: CanonicalStakePoolParams -> StakePoolParams
fromCanonicalStakePoolParams :: CanonicalStakePoolParams -> StakePoolParams
fromCanonicalStakePoolParams (CanonicalStakePoolParams {Set (KeyHash Staking)
StrictMaybe PoolMetadata
VRFVerKeyHash StakePoolVRF
KeyHash StakePool
UnitInterval
AccountAddress
StrictSeq StakePoolRelay
CanonicalCoin
csppId :: CanonicalStakePoolParams -> KeyHash StakePool
csppVrf :: CanonicalStakePoolParams -> VRFVerKeyHash StakePoolVRF
csppPledge :: CanonicalStakePoolParams -> CanonicalCoin
csppCost :: CanonicalStakePoolParams -> CanonicalCoin
csppMargin :: CanonicalStakePoolParams -> UnitInterval
csppAccountAddress :: CanonicalStakePoolParams -> AccountAddress
csppOwners :: CanonicalStakePoolParams -> Set (KeyHash Staking)
csppRelays :: CanonicalStakePoolParams -> StrictSeq StakePoolRelay
csppMetadata :: CanonicalStakePoolParams -> StrictMaybe PoolMetadata
csppId :: KeyHash StakePool
csppVrf :: VRFVerKeyHash StakePoolVRF
csppPledge :: CanonicalCoin
csppCost :: CanonicalCoin
csppMargin :: UnitInterval
csppAccountAddress :: AccountAddress
csppOwners :: Set (KeyHash Staking)
csppRelays :: StrictSeq StakePoolRelay
csppMetadata :: StrictMaybe PoolMetadata
..}) =
  StakePoolParams
    { sppId :: KeyHash StakePool
sppId = KeyHash StakePool
csppId
    , sppVrf :: VRFVerKeyHash StakePoolVRF
sppVrf = VRFVerKeyHash StakePoolVRF
csppVrf
    , sppCost :: Coin
sppCost = CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin) -> CompactForm Coin -> Coin
forall a b. (a -> b) -> a -> b
$ CanonicalCoin -> CompactForm Coin
unCoin CanonicalCoin
csppCost
    , sppMargin :: UnitInterval
sppMargin = UnitInterval
csppMargin
    , sppPledge :: Coin
sppPledge = CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin) -> CompactForm Coin -> Coin
forall a b. (a -> b) -> a -> b
$ CanonicalCoin -> CompactForm Coin
unCoin CanonicalCoin
csppPledge
    , sppOwners :: Set (KeyHash Staking)
sppOwners = Set (KeyHash Staking)
csppOwners
    , sppRelays :: StrictSeq StakePoolRelay
sppRelays = StrictSeq StakePoolRelay
csppRelays
    , sppMetadata :: StrictMaybe PoolMetadata
sppMetadata = StrictMaybe PoolMetadata
csppMetadata
    , sppAccountAddress :: AccountAddress
sppAccountAddress = AccountAddress
csppAccountAddress
    }