{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Conway.HuddleSpec (
  module Cardano.Ledger.Babbage.HuddleSpec,
  ConwayEra,
  conwayCDDL,
  conwayMintRule,
  conwayWithdrawalsRule,
  conwayRedeemer,
  conwayRedeemerTag,
  anchorRule,
  drepRule,
  voterRule,
  dnsNameRule,
  urlRule,
  voteRule,
  drepCredentialRule,
  committeeHotCredentialRule,
  committeeColdCredentialRule,
  accountRegistrationDepositCertGroup,
  accountUnregistrationDepositCertGroup,
  delegationToDrepCertGroup,
  delegationToStakePoolAndDrepCertGroup,
  accountRegistrationDelegationToStakePoolCertGroup,
  accountRegistrationDelegationToDrepCertGroup,
  accountRegistrationDelegationToStakePoolAndDrepCertGroup,
  committeeAuthorizationCertGroup,
  committeeResignationCertGroup,
  drepRegistrationCertGroup,
  drepUnregistrationCertGroup,
  drepUpdateCertGroup,
  votingProcedureRule,
  votingProceduresRule,
  constitutionRule,
  parameterChangeActionGroup,
  hardForkInitiationActionGroup,
  treasuryWithdrawalsActionGroup,
  noConfidenceGroup,
  updateCommitteeGroup,
  newConstitutionGroup,
  infoActionRule,
  govActionRule,
  proposalProcedureRule,
  proposalProceduresRule,
  poolVotingThresholdsRule,
  drepVotingThresholdsRule,
  guardrailsScriptHashRule,
  potentialLanguagesRule,
  conwayCertificateRule,
  certificatesRule,
  mkMaybeTaggedSet,
  maybeTaggedSet,
  maybeTaggedNonemptySet,
  maybeTaggedNonemptyOset,
) where

import Cardano.Ledger.Babbage.HuddleSpec hiding (
  alonzoRedeemer,
  alonzoRedeemerTag,
  dnsNameRule,
  maryMintRule,
  maryMultiasset,
  maryValueRule,
  shelleyWithdrawalsRule,
  urlRule,
 )
import Cardano.Ledger.Conway (ConwayEra)
import Data.Proxy (Proxy (..))
import Data.Word (Word64)
import GHC.TypeLits (KnownSymbol)
import Text.Heredoc
import Prelude hiding ((/))

conwayCDDL :: Huddle
conwayCDDL :: Huddle
conwayCDDL =
  [HuddleItem] -> Huddle
collectFromInit
    [ Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"block" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"kes_signature" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"language" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"potential_languages" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"signkey_kes" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"certificate" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"policy_id" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"asset_name" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    , Rule -> HuddleItem
HIRule (Rule -> HuddleItem) -> Rule -> HuddleItem
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"redeemer" (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ConwayEra)
    ]

anchorRule ::
  forall era.
  (HuddleRule "url" era, HuddleRule "hash32" era) => Proxy "anchor" -> Proxy era -> Rule
anchorRule :: forall era.
(HuddleRule "url" era, HuddleRule "hash32" era) =>
Proxy "anchor" -> Proxy era -> Rule
anchorRule Proxy "anchor"
pname Proxy era
p =
  Proxy "anchor"
pname
    Proxy "anchor" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Key
"anchor_url" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"url" Proxy era
p
      , Key
"anchor_data_hash" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"hash32" Proxy era
p
      ]

drepRule ::
  forall era.
  (HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
  Proxy "drep" -> Proxy era -> Rule
drepRule :: forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
Proxy "drep" -> Proxy era -> Rule
drepRule Proxy "drep"
pname Proxy era
p =
  Proxy "drep"
pname
    Proxy "drep" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
0, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy era
p)]
    ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
1, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_hash" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
2]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
3]

voterRule ::
  forall era.
  (HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
  Proxy "voter" -> Proxy era -> Rule
voterRule :: forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
Proxy "voter" -> Proxy era -> Rule
voterRule Proxy "voter"
pname Proxy era
p =
  Proxy "voter"
pname
    Proxy "voter" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
0, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy era
p)]
    ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
1, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_hash" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
2, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
3, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_hash" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
4, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy era
p)]

dnsNameRule :: Proxy "dns_name" -> Rule
dnsNameRule :: Proxy "dns_name" -> Rule
dnsNameRule Proxy "dns_name"
pname = Proxy "dns_name"
pname Proxy "dns_name" -> Constrained -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Value Text
VText Value Text -> (Word64, Word64) -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
0 :: Word64, Word64
128 :: Word64)

urlRule :: Proxy "url" -> Rule
urlRule :: Proxy "url" -> Rule
urlRule Proxy "url"
pname = Proxy "url"
pname Proxy "url" -> Constrained -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Value Text
VText Value Text -> (Word64, Word64) -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
0 :: Word64, Word64
128 :: Word64)

voteRule :: Proxy "vote" -> Rule
voteRule :: Proxy "vote" -> Rule
voteRule Proxy "vote"
pname = Proxy "vote"
pname Proxy "vote" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer
0 :: Integer) Integer -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (Integer
2 :: Integer)

drepCredentialRule ::
  forall era. HuddleRule "credential" era => Proxy "drep_credential" -> Proxy era -> Rule
drepCredentialRule :: forall era.
HuddleRule "credential" era =>
Proxy "drep_credential" -> Proxy era -> Rule
drepCredentialRule Proxy "drep_credential"
pname Proxy era
p = Proxy "drep_credential"
pname Proxy "drep_credential" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"credential" Proxy era
p

committeeHotCredentialRule ::
  forall era. HuddleRule "credential" era => Proxy "committee_hot_credential" -> Proxy era -> Rule
committeeHotCredentialRule :: forall era.
HuddleRule "credential" era =>
Proxy "committee_hot_credential" -> Proxy era -> Rule
committeeHotCredentialRule Proxy "committee_hot_credential"
pname Proxy era
p = Proxy "committee_hot_credential"
pname Proxy "committee_hot_credential" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"credential" Proxy era
p

committeeColdCredentialRule ::
  forall era. HuddleRule "credential" era => Proxy "committee_cold_credential" -> Proxy era -> Rule
committeeColdCredentialRule :: forall era.
HuddleRule "credential" era =>
Proxy "committee_cold_credential" -> Proxy era -> Rule
committeeColdCredentialRule Proxy "committee_cold_credential"
pname Proxy era
p = Proxy "committee_cold_credential"
pname Proxy "committee_cold_credential" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"credential" Proxy era
p

guardrailsScriptHashRule ::
  forall era. HuddleRule "script_hash" era => Proxy "guardrails_script_hash" -> Proxy era -> Rule
guardrailsScriptHashRule :: forall era.
HuddleRule "script_hash" era =>
Proxy "guardrails_script_hash" -> Proxy era -> Rule
guardrailsScriptHashRule Proxy "guardrails_script_hash"
pname Proxy era
p = Proxy "guardrails_script_hash"
pname Proxy "guardrails_script_hash" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_hash" Proxy era
p

potentialLanguagesRule :: Proxy "potential_languages" -> Rule
potentialLanguagesRule :: Proxy "potential_languages" -> Rule
potentialLanguagesRule Proxy "potential_languages"
pname = Proxy "potential_languages"
pname Proxy "potential_languages" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer
0 :: Integer) Integer -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (Integer
255 :: Integer)

conwayCertificateRule ::
  forall era.
  ( HuddleGroup "account_registration_cert" era
  , HuddleGroup "account_unregistration_cert" era
  , HuddleGroup "delegation_to_stake_pool_cert" era
  , HuddleGroup "pool_registration_cert" era
  , HuddleGroup "pool_retirement_cert" era
  , HuddleGroup "account_registration_deposit_cert" era
  , HuddleGroup "account_unregistration_deposit_cert" era
  , HuddleGroup "delegation_to_drep_cert" era
  , HuddleGroup "delegation_to_stake_pool_and_drep_cert" era
  , HuddleGroup "account_registration_delegation_to_stake_pool_cert" era
  , HuddleGroup "account_registration_delegation_to_drep_cert" era
  , HuddleGroup "account_registration_delegation_to_stake_pool_and_drep_cert" era
  , HuddleGroup "committee_authorization_cert" era
  , HuddleGroup "committee_resignation_cert" era
  , HuddleGroup "drep_registration_cert" era
  , HuddleGroup "drep_unregistration_cert" era
  , HuddleGroup "drep_update_cert" era
  ) =>
  Proxy "certificate" ->
  Proxy era ->
  Rule
conwayCertificateRule :: forall era.
(HuddleGroup "account_registration_cert" era,
 HuddleGroup "account_unregistration_cert" era,
 HuddleGroup "delegation_to_stake_pool_cert" era,
 HuddleGroup "pool_registration_cert" era,
 HuddleGroup "pool_retirement_cert" era,
 HuddleGroup "account_registration_deposit_cert" era,
 HuddleGroup "account_unregistration_deposit_cert" era,
 HuddleGroup "delegation_to_drep_cert" era,
 HuddleGroup "delegation_to_stake_pool_and_drep_cert" era,
 HuddleGroup
   "account_registration_delegation_to_stake_pool_cert" era,
 HuddleGroup "account_registration_delegation_to_drep_cert" era,
 HuddleGroup
   "account_registration_delegation_to_stake_pool_and_drep_cert" era,
 HuddleGroup "committee_authorization_cert" era,
 HuddleGroup "committee_resignation_cert" era,
 HuddleGroup "drep_registration_cert" era,
 HuddleGroup "drep_unregistration_cert" era,
 HuddleGroup "drep_update_cert" era) =>
Proxy "certificate" -> Proxy era -> Rule
conwayCertificateRule Proxy "certificate"
pname Proxy era
p =
  Proxy "certificate"
pname
    Proxy "certificate" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_registration_cert" Proxy era
p]
    ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_unregistration_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"delegation_to_stake_pool_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"pool_registration_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"pool_retirement_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_registration_deposit_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_unregistration_deposit_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"delegation_to_drep_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"delegation_to_stake_pool_and_drep_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_registration_delegation_to_stake_pool_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_registration_delegation_to_drep_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"account_registration_delegation_to_stake_pool_and_drep_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"committee_authorization_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"committee_resignation_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"drep_registration_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"drep_unregistration_cert" Proxy era
p]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GroupDef -> Item ArrayChoice) -> GroupDef -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"drep_update_cert" Proxy era
p]

certificatesRule ::
  forall era.
  (HuddleRule "certificate" era, HuddleRule1 "nonempty_oset" era) =>
  Proxy "certificates" -> Proxy era -> Rule
certificatesRule :: forall era.
(HuddleRule "certificate" era, HuddleRule1 "nonempty_oset" era) =>
Proxy "certificates" -> Proxy era -> Rule
certificatesRule Proxy "certificates"
pname Proxy era
p =
  Proxy "certificates"
pname
    Proxy "certificates" -> GRuleCall -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_oset" Proxy era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"certificate" Proxy era
p)

accountRegistrationDepositCertGroup ::
  forall era.
  (HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
  Proxy "account_registration_deposit_cert" ->
  Proxy era ->
  GroupDef
accountRegistrationDepositCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
Proxy "account_registration_deposit_cert" -> Proxy era -> GroupDef
accountRegistrationDepositCertGroup Proxy "account_registration_deposit_cert"
pname Proxy era
p =
  Proxy "account_registration_deposit_cert"
pname
    Proxy "account_registration_deposit_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
7, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p), Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)]

accountUnregistrationDepositCertGroup ::
  forall era.
  (HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
  Proxy "account_unregistration_deposit_cert" ->
  Proxy era ->
  GroupDef
accountUnregistrationDepositCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
Proxy "account_unregistration_deposit_cert"
-> Proxy era -> GroupDef
accountUnregistrationDepositCertGroup Proxy "account_unregistration_deposit_cert"
pname Proxy era
p =
  Proxy "account_unregistration_deposit_cert"
pname
    Proxy "account_unregistration_deposit_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
8, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p), Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)]

delegationToDrepCertGroup ::
  forall era.
  (HuddleRule "stake_credential" era, HuddleRule "drep" era) =>
  Proxy "delegation_to_drep_cert" ->
  Proxy era ->
  GroupDef
delegationToDrepCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "drep" era) =>
Proxy "delegation_to_drep_cert" -> Proxy era -> GroupDef
delegationToDrepCertGroup Proxy "delegation_to_drep_cert"
pname Proxy era
p =
  Proxy "delegation_to_drep_cert"
pname
    Proxy "delegation_to_drep_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
9, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p), Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep" Proxy era
p)]

delegationToStakePoolAndDrepCertGroup ::
  forall era.
  ( HuddleRule "stake_credential" era
  , HuddleRule "pool_keyhash" era
  , HuddleRule "drep" era
  ) =>
  Proxy "delegation_to_stake_pool_and_drep_cert" ->
  Proxy era ->
  GroupDef
delegationToStakePoolAndDrepCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "drep" era) =>
Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy era -> GroupDef
delegationToStakePoolAndDrepCertGroup Proxy "delegation_to_stake_pool_and_drep_cert"
pname Proxy era
p =
  Proxy "delegation_to_stake_pool_and_drep_cert"
pname
    Proxy "delegation_to_stake_pool_and_drep_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
10
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"pool_keyhash" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep" Proxy era
p)
      ]

accountRegistrationDelegationToStakePoolCertGroup ::
  forall era.
  ( HuddleRule "stake_credential" era
  , HuddleRule "pool_keyhash" era
  , HuddleRule "coin" era
  ) =>
  Proxy "account_registration_delegation_to_stake_pool_cert" ->
  Proxy era ->
  GroupDef
accountRegistrationDelegationToStakePoolCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToStakePoolCertGroup Proxy "account_registration_delegation_to_stake_pool_cert"
pname Proxy era
p =
  Proxy "account_registration_delegation_to_stake_pool_cert"
pname
    Proxy "account_registration_delegation_to_stake_pool_cert"
-> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
11
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"pool_keyhash" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)
      ]

accountRegistrationDelegationToDrepCertGroup ::
  forall era.
  (HuddleRule "stake_credential" era, HuddleRule "drep" era, HuddleRule "coin" era) =>
  Proxy "account_registration_delegation_to_drep_cert" ->
  Proxy era ->
  GroupDef
accountRegistrationDelegationToDrepCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "drep" era,
 HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_drep_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToDrepCertGroup Proxy "account_registration_delegation_to_drep_cert"
pname Proxy era
p =
  Proxy "account_registration_delegation_to_drep_cert"
pname
    Proxy "account_registration_delegation_to_drep_cert"
-> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
12
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)
      ]

accountRegistrationDelegationToStakePoolAndDrepCertGroup ::
  forall era.
  ( HuddleRule "stake_credential" era
  , HuddleRule "pool_keyhash" era
  , HuddleRule "drep" era
  , HuddleRule "coin" era
  ) =>
  Proxy "account_registration_delegation_to_stake_pool_and_drep_cert" ->
  Proxy era ->
  GroupDef
accountRegistrationDelegationToStakePoolAndDrepCertGroup :: forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "drep" era, HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToStakePoolAndDrepCertGroup Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
pname Proxy era
p =
  Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
pname
    Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
13
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"stake_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"pool_keyhash" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)
      ]

committeeAuthorizationCertGroup ::
  forall era.
  ( HuddleRule "committee_cold_credential" era
  , HuddleRule "committee_hot_credential" era
  ) =>
  Proxy "committee_authorization_cert" ->
  Proxy era ->
  GroupDef
committeeAuthorizationCertGroup :: forall era.
(HuddleRule "committee_cold_credential" era,
 HuddleRule "committee_hot_credential" era) =>
Proxy "committee_authorization_cert" -> Proxy era -> GroupDef
committeeAuthorizationCertGroup Proxy "committee_authorization_cert"
pname Proxy era
p =
  Proxy "committee_authorization_cert"
pname
    Proxy "committee_authorization_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
14
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"committee_cold_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"committee_hot_credential" Proxy era
p)
      ]

committeeResignationCertGroup ::
  forall era.
  (HuddleRule "committee_cold_credential" era, HuddleRule "anchor" era) =>
  Proxy "committee_resignation_cert" ->
  Proxy era ->
  GroupDef
committeeResignationCertGroup :: forall era.
(HuddleRule "committee_cold_credential" era,
 HuddleRule "anchor" era) =>
Proxy "committee_resignation_cert" -> Proxy era -> GroupDef
committeeResignationCertGroup Proxy "committee_resignation_cert"
pname Proxy era
p =
  Proxy "committee_resignation_cert"
pname
    Proxy "committee_resignation_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
15, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"committee_cold_credential" Proxy era
p), Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)]

drepRegistrationCertGroup ::
  forall era.
  (HuddleRule "drep_credential" era, HuddleRule "coin" era, HuddleRule "anchor" era) =>
  Proxy "drep_registration_cert" ->
  Proxy era ->
  GroupDef
drepRegistrationCertGroup :: forall era.
(HuddleRule "drep_credential" era, HuddleRule "coin" era,
 HuddleRule "anchor" era) =>
Proxy "drep_registration_cert" -> Proxy era -> GroupDef
drepRegistrationCertGroup Proxy "drep_registration_cert"
pname Proxy era
p =
  Proxy "drep_registration_cert"
pname
    Proxy "drep_registration_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
16
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep_credential" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)
      , Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
      ]

drepUnregistrationCertGroup ::
  forall era.
  (HuddleRule "drep_credential" era, HuddleRule "coin" era) =>
  Proxy "drep_unregistration_cert" ->
  Proxy era ->
  GroupDef
drepUnregistrationCertGroup :: forall era.
(HuddleRule "drep_credential" era, HuddleRule "coin" era) =>
Proxy "drep_unregistration_cert" -> Proxy era -> GroupDef
drepUnregistrationCertGroup Proxy "drep_unregistration_cert"
pname Proxy era
p =
  Proxy "drep_unregistration_cert"
pname
    Proxy "drep_unregistration_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
17, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep_credential" Proxy era
p), Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p)]

drepUpdateCertGroup ::
  forall era.
  (HuddleRule "drep_credential" era, HuddleRule "anchor" era) =>
  Proxy "drep_update_cert" ->
  Proxy era ->
  GroupDef
drepUpdateCertGroup :: forall era.
(HuddleRule "drep_credential" era, HuddleRule "anchor" era) =>
Proxy "drep_update_cert" -> Proxy era -> GroupDef
drepUpdateCertGroup Proxy "drep_update_cert"
pname Proxy era
p =
  Proxy "drep_update_cert"
pname
    Proxy "drep_update_cert" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
18, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep_credential" Proxy era
p), Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)]

votingProcedureRule ::
  forall era.
  (HuddleRule "vote" era, HuddleRule "anchor" era) =>
  Proxy "voting_procedure" ->
  Proxy era ->
  Rule
votingProcedureRule :: forall era.
(HuddleRule "vote" era, HuddleRule "anchor" era) =>
Proxy "voting_procedure" -> Proxy era -> Rule
votingProcedureRule Proxy "voting_procedure"
pname Proxy era
p =
  Proxy "voting_procedure"
pname
    Proxy "voting_procedure" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vote" Proxy era
p), Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)]

votingProceduresRule ::
  forall era.
  ( HuddleRule "voter" era
  , HuddleRule "gov_action_id" era
  , HuddleRule "voting_procedure" era
  ) =>
  Proxy "voting_procedures" ->
  Proxy era ->
  Rule
votingProceduresRule :: forall era.
(HuddleRule "voter" era, HuddleRule "gov_action_id" era,
 HuddleRule "voting_procedure" era) =>
Proxy "voting_procedures" -> Proxy era -> Rule
votingProceduresRule Proxy "voting_procedures"
pname Proxy era
p =
  Proxy "voting_procedures"
pname
    Proxy "voting_procedures" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
      [ Word64
1
          Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"voter" Proxy era
p)
          Key -> MapChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> MapChoice -> MapChoice
mp [Word64
1 Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p) Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"voting_procedure" Proxy era
p]
      ]

constitutionRule ::
  forall era.
  (HuddleRule "anchor" era, HuddleRule "guardrails_script_hash" era) =>
  Proxy "constitution" ->
  Proxy era ->
  Rule
constitutionRule :: forall era.
(HuddleRule "anchor" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "constitution" -> Proxy era -> Rule
constitutionRule Proxy "constitution"
pname Proxy era
p =
  Proxy "constitution"
pname
    Proxy "constitution" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p)
      , Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"guardrails_script_hash" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
      ]

parameterChangeActionGroup ::
  forall era.
  ( HuddleRule "gov_action_id" era
  , HuddleRule "protocol_param_update" era
  , HuddleRule "guardrails_script_hash" era
  ) =>
  Proxy "parameter_change_action" ->
  Proxy era ->
  GroupDef
parameterChangeActionGroup :: forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "protocol_param_update" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "parameter_change_action" -> Proxy era -> GroupDef
parameterChangeActionGroup Proxy "parameter_change_action"
pname Proxy era
p =
  Proxy "parameter_change_action"
pname
    Proxy "parameter_change_action" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
0
      , Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
      , Rule -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item Group) -> Rule -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"protocol_param_update" Proxy era
p
      , Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"guardrails_script_hash" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
      ]

hardForkInitiationActionGroup ::
  forall era.
  (HuddleRule "gov_action_id" era, HuddleRule "protocol_version" era) =>
  Proxy "hard_fork_initiation_action" ->
  Proxy era ->
  GroupDef
hardForkInitiationActionGroup :: forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "protocol_version" era) =>
Proxy "hard_fork_initiation_action" -> Proxy era -> GroupDef
hardForkInitiationActionGroup Proxy "hard_fork_initiation_action"
pname Proxy era
p =
  Proxy "hard_fork_initiation_action"
pname
    Proxy "hard_fork_initiation_action" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
1, Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil, Rule -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item Group) -> Rule -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"protocol_version" Proxy era
p]

treasuryWithdrawalsActionGroup ::
  forall era.
  ( HuddleRule "reward_account" era
  , HuddleRule "coin" era
  , HuddleRule "guardrails_script_hash" era
  ) =>
  Proxy "treasury_withdrawals_action" ->
  Proxy era ->
  GroupDef
treasuryWithdrawalsActionGroup :: forall era.
(HuddleRule "reward_account" era, HuddleRule "coin" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "treasury_withdrawals_action" -> Proxy era -> GroupDef
treasuryWithdrawalsActionGroup Proxy "treasury_withdrawals_action"
pname Proxy era
p =
  Proxy "treasury_withdrawals_action"
pname
    Proxy "treasury_withdrawals_action" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
2
      , MapChoice -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (MapChoice -> Item Group) -> MapChoice -> Item Group
forall a b. (a -> b) -> a -> b
$
          MapChoice -> MapChoice
mp
            [ Word64
0
                Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"reward_account" Proxy era
p)
                Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p
            ]
      , Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"guardrails_script_hash" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
      ]

noConfidenceGroup ::
  forall era.
  HuddleRule "gov_action_id" era => Proxy "no_confidence" -> Proxy era -> GroupDef
noConfidenceGroup :: forall era.
HuddleRule "gov_action_id" era =>
Proxy "no_confidence" -> Proxy era -> GroupDef
noConfidenceGroup Proxy "no_confidence"
pname Proxy era
p =
  Proxy "no_confidence"
pname
    Proxy "no_confidence" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
3, Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil]

updateCommitteeGroup ::
  forall era.
  ( HuddleRule "gov_action_id" era
  , HuddleRule "committee_cold_credential" era
  , HuddleRule "epoch" era
  , HuddleRule "unit_interval" era
  , HuddleRule1 "set" era
  ) =>
  Proxy "update_committee" ->
  Proxy era ->
  GroupDef
updateCommitteeGroup :: forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "committee_cold_credential" era, HuddleRule "epoch" era,
 HuddleRule "unit_interval" era, HuddleRule1 "set" era) =>
Proxy "update_committee" -> Proxy era -> GroupDef
updateCommitteeGroup Proxy "update_committee"
pname Proxy era
p =
  Proxy "update_committee"
pname
    Proxy "update_committee" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
4
      , Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
      , GRuleCall -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GRuleCall -> Item Group) -> GRuleCall -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"set" Proxy era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"committee_cold_credential" Proxy era
p)
      , MapChoice -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (MapChoice -> Item Group) -> MapChoice -> Item Group
forall a b. (a -> b) -> a -> b
$
          MapChoice -> MapChoice
mp
            [ Word64
0
                Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"committee_cold_credential" Proxy era
p)
                Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"epoch" Proxy era
p
            ]
      , Rule -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item Group) -> Rule -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p
      ]

newConstitutionGroup ::
  forall era.
  (HuddleRule "gov_action_id" era, HuddleRule "constitution" era) =>
  Proxy "new_constitution" ->
  Proxy era ->
  GroupDef
newConstitutionGroup :: forall era.
(HuddleRule "gov_action_id" era, HuddleRule "constitution" era) =>
Proxy "new_constitution" -> Proxy era -> GroupDef
newConstitutionGroup Proxy "new_constitution"
pname Proxy era
p =
  Proxy "new_constitution"
pname
    Proxy "new_constitution" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp
      [ Item Group
ArrayEntry
5
      , Choice Type2 -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Choice Type2 -> Item Group) -> Choice Type2 -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action_id" Proxy era
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
      , Rule -> Item Group
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item Group) -> Rule -> Item Group
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"constitution" Proxy era
p
      ]

infoActionRule :: Proxy "info_action" -> Rule
infoActionRule :: Proxy "info_action" -> Rule
infoActionRule Proxy "info_action"
pname = Proxy "info_action"
pname Proxy "info_action" -> Literal -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Integer -> Literal
int Integer
6

govActionRule ::
  forall era.
  ( HuddleGroup "parameter_change_action" era
  , HuddleGroup "hard_fork_initiation_action" era
  , HuddleGroup "treasury_withdrawals_action" era
  , HuddleGroup "no_confidence" era
  , HuddleGroup "update_committee" era
  , HuddleGroup "new_constitution" era
  , HuddleRule "info_action" era
  ) =>
  Proxy "gov_action" ->
  Proxy era ->
  Rule
govActionRule :: forall era.
(HuddleGroup "parameter_change_action" era,
 HuddleGroup "hard_fork_initiation_action" era,
 HuddleGroup "treasury_withdrawals_action" era,
 HuddleGroup "no_confidence" era,
 HuddleGroup "update_committee" era,
 HuddleGroup "new_constitution" era,
 HuddleRule "info_action" era) =>
Proxy "gov_action" -> Proxy era -> Rule
govActionRule Proxy "gov_action"
pname Proxy era
p =
  Proxy "gov_action"
pname
    Proxy "gov_action" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"parameter_change_action" Proxy era
p)]
    ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"hard_fork_initiation_action" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"treasury_withdrawals_action" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"no_confidence" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"update_committee" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [GroupDef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleGroup name era =>
Proxy era -> GroupDef
huddleGroup @"new_constitution" Proxy era
p)]
    Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"info_action" Proxy era
p)]

proposalProcedureRule ::
  forall era.
  ( HuddleRule "coin" era
  , HuddleRule "reward_account" era
  , HuddleRule "gov_action" era
  , HuddleRule "anchor" era
  ) =>
  Proxy "proposal_procedure" ->
  Proxy era ->
  Rule
proposalProcedureRule :: forall era.
(HuddleRule "coin" era, HuddleRule "reward_account" era,
 HuddleRule "gov_action" era, HuddleRule "anchor" era) =>
Proxy "proposal_procedure" -> Proxy era -> Rule
proposalProcedureRule Proxy "proposal_procedure"
pname Proxy era
p =
  Proxy "proposal_procedure"
pname
    Proxy "proposal_procedure" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Key
"deposit" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"reward_account" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"gov_action" Proxy era
p)
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"anchor" Proxy era
p)
      ]

proposalProceduresRule ::
  forall era.
  ( HuddleRule "proposal_procedure" era
  , HuddleRule1 "nonempty_oset" era
  ) =>
  Proxy "proposal_procedures" ->
  Proxy era ->
  Rule
proposalProceduresRule :: forall era.
(HuddleRule "proposal_procedure" era,
 HuddleRule1 "nonempty_oset" era) =>
Proxy "proposal_procedures" -> Proxy era -> Rule
proposalProceduresRule Proxy "proposal_procedures"
pname Proxy era
p =
  Proxy "proposal_procedures"
pname
    Proxy "proposal_procedures" -> GRuleCall -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_oset" Proxy era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"proposal_procedure" Proxy era
p)

poolVotingThresholdsRule ::
  forall era.
  HuddleRule "unit_interval" era => Proxy "pool_voting_thresholds" -> Proxy era -> Rule
poolVotingThresholdsRule :: forall era.
HuddleRule "unit_interval" era =>
Proxy "pool_voting_thresholds" -> Proxy era -> Rule
poolVotingThresholdsRule Proxy "pool_voting_thresholds"
pname Proxy era
p =
  Proxy "pool_voting_thresholds"
pname
    Proxy "pool_voting_thresholds" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"motion no confidence"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"committee normal"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"committee no confidence"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"hard fork initiation"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"security relevant parameter voting threshold"
      ]

drepVotingThresholdsRule ::
  forall era.
  HuddleRule "unit_interval" era => Proxy "drep_voting_thresholds" -> Proxy era -> Rule
drepVotingThresholdsRule :: forall era.
HuddleRule "unit_interval" era =>
Proxy "drep_voting_thresholds" -> Proxy era -> Rule
drepVotingThresholdsRule Proxy "drep_voting_thresholds"
pname Proxy era
p =
  Proxy "drep_voting_thresholds"
pname
    Proxy "drep_voting_thresholds" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"motion no confidence"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"committee normal"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"committee no confidence"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"update constitution"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"hard fork initiation"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"PP network group"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"PP economic group"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"PP technical group"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"PP governance group"
      , Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy era
p) ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"treasury withdrawal"
      ]

conwayMultiasset ::
  forall era a.
  (HuddleRule "policy_id" era, HuddleRule "asset_name" era, IsType0 a) =>
  Proxy "multiasset" ->
  Proxy era ->
  a ->
  GRuleCall
conwayMultiasset :: forall era a.
(HuddleRule "policy_id" era, HuddleRule "asset_name" era,
 IsType0 a) =>
Proxy "multiasset" -> Proxy era -> a -> GRuleCall
conwayMultiasset Proxy "multiasset"
pname Proxy era
p =
  (GRef -> Rule) -> a -> GRuleCall
forall t0. IsType0 t0 => (GRef -> Rule) -> t0 -> GRuleCall
binding ((GRef -> Rule) -> a -> GRuleCall)
-> (GRef -> Rule) -> a -> GRuleCall
forall a b. (a -> b) -> a -> b
$ \GRef
x ->
    Proxy "multiasset"
pname
      Proxy "multiasset" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
        [ Word64
0
            Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"policy_id" Proxy era
p)
            Key -> MapChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> MapChoice -> MapChoice
mp [Word64
1 Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"asset_name" Proxy era
p) Key -> GRef -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> GRef
x]
        ]

conwayValueRule ::
  forall era.
  ( HuddleRule "positive_coin" era
  , HuddleRule1 "multiasset" era
  ) =>
  Proxy "value" ->
  Proxy era ->
  Rule
conwayValueRule :: forall era.
(HuddleRule "positive_coin" era, HuddleRule1 "multiasset" era) =>
Proxy "value" -> Proxy era -> Rule
conwayValueRule Proxy "value"
pname Proxy era
p =
  Proxy "value"
pname
    Proxy "value" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p
    Rule -> Seal (Choice ArrayChoice) -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> Seal (Choice ArrayChoice)
sarr
      [ Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p
      , GRuleCall -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (GRuleCall -> Item ArrayChoice) -> GRuleCall -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"multiasset" Proxy era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"positive_coin" Proxy era
p)
      ]

conwayMintRule ::
  forall era.
  ( HuddleRule "policy_id" era
  , HuddleRule "asset_name" era
  , HuddleRule "nonzero_int64" era
  ) =>
  Proxy "mint" ->
  Proxy era ->
  Rule
conwayMintRule :: forall era.
(HuddleRule "policy_id" era, HuddleRule "asset_name" era,
 HuddleRule "nonzero_int64" era) =>
Proxy "mint" -> Proxy era -> Rule
conwayMintRule Proxy "mint"
pname Proxy era
p =
  Proxy "mint"
pname
    Proxy "mint" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
      [ Word64
1
          Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"policy_id" Proxy era
p)
          Key -> MapChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> MapChoice -> MapChoice
mp [Word64
1 Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"asset_name" Proxy era
p) Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"nonzero_int64" Proxy era
p]
      ]

conwayWithdrawalsRule ::
  forall era. Era era => Proxy "withdrawals" -> Proxy era -> Rule
conwayWithdrawalsRule :: forall era. Era era => Proxy "withdrawals" -> Proxy era -> Rule
conwayWithdrawalsRule Proxy "withdrawals"
pname Proxy era
p =
  Proxy "withdrawals"
pname
    Proxy "withdrawals" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
      [ Word64
1
          Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"reward_account" Proxy era
p)
          Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy era
p
      ]

conwayRedeemerTag :: Proxy "redeemer_tag" -> Rule
conwayRedeemerTag :: Proxy "redeemer_tag" -> Rule
conwayRedeemerTag Proxy "redeemer_tag"
pname =
  Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
    Comment
[str|0: spend
        |1: mint
        |2: cert
        |3: reward
        |4: voting
        |5: proposing
        |]
    (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "redeemer_tag"
pname
      Proxy "redeemer_tag" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer
0 :: Integer)
      Integer -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (Integer
5 :: Integer)

conwayRedeemer ::
  forall era.
  ( HuddleRule "redeemer_tag" era
  , HuddleRule "plutus_data" era
  , HuddleRule "ex_units" era
  ) =>
  Proxy "redeemer" ->
  Proxy era ->
  Rule
conwayRedeemer :: forall era.
(HuddleRule "redeemer_tag" era, HuddleRule "plutus_data" era,
 HuddleRule "ex_units" era) =>
Proxy "redeemer" -> Proxy era -> Rule
conwayRedeemer Proxy "redeemer"
pname Proxy era
p =
  Proxy "redeemer"
pname
    Proxy "redeemer" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Key
"tag" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"redeemer_tag" Proxy era
p
      , Key
"index" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)
      , Key
"data" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_data" Proxy era
p
      , Key
"ex_units" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"ex_units" Proxy era
p
      ]

mkMaybeTaggedSet ::
  forall name a. (KnownSymbol name, IsType0 a) => Proxy name -> Word64 -> a -> GRuleCall
mkMaybeTaggedSet :: forall (name :: Symbol) a.
(KnownSymbol name, IsType0 a) =>
Proxy name -> Word64 -> a -> GRuleCall
mkMaybeTaggedSet Proxy name
pname Word64
n = (GRef -> Rule) -> a -> GRuleCall
forall t0. IsType0 t0 => (GRef -> Rule) -> t0 -> GRuleCall
binding ((GRef -> Rule) -> a -> GRuleCall)
-> (GRef -> Rule) -> a -> GRuleCall
forall a b. (a -> b) -> a -> b
$ \GRef
x -> Proxy name
pname Proxy name -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Word64 -> ArrayChoice -> Tagged ArrayChoice
forall a. Word64 -> a -> Tagged a
tag Word64
258 (ArrayChoice -> ArrayChoice
arr [Word64
n Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ GRef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a GRef
x]) Tagged ArrayChoice -> Seal (Choice ArrayChoice) -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> Seal (Choice ArrayChoice)
sarr [Word64
n Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ GRef -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a GRef
x]

maybeTaggedSet :: IsType0 a => Proxy "set" -> a -> GRuleCall
maybeTaggedSet :: forall a. IsType0 a => Proxy "set" -> a -> GRuleCall
maybeTaggedSet Proxy "set"
pname = Proxy "set" -> Word64 -> a -> GRuleCall
forall (name :: Symbol) a.
(KnownSymbol name, IsType0 a) =>
Proxy name -> Word64 -> a -> GRuleCall
mkMaybeTaggedSet Proxy "set"
pname Word64
0

maybeTaggedNonemptySet :: IsType0 a => Proxy "nonempty_set" -> a -> GRuleCall
maybeTaggedNonemptySet :: forall a. IsType0 a => Proxy "nonempty_set" -> a -> GRuleCall
maybeTaggedNonemptySet Proxy "nonempty_set"
pname = Proxy "nonempty_set" -> Word64 -> a -> GRuleCall
forall (name :: Symbol) a.
(KnownSymbol name, IsType0 a) =>
Proxy name -> Word64 -> a -> GRuleCall
mkMaybeTaggedSet Proxy "nonempty_set"
pname Word64
1

maybeTaggedNonemptyOset :: IsType0 a => Proxy "nonempty_oset" -> a -> GRuleCall
maybeTaggedNonemptyOset :: forall a. IsType0 a => Proxy "nonempty_oset" -> a -> GRuleCall
maybeTaggedNonemptyOset Proxy "nonempty_oset"
pname = Proxy "nonempty_oset" -> Word64 -> a -> GRuleCall
forall (name :: Symbol) a.
(KnownSymbol name, IsType0 a) =>
Proxy name -> Word64 -> a -> GRuleCall
mkMaybeTaggedSet Proxy "nonempty_oset"
pname Word64
1

instance HuddleRule "bounded_bytes" ConwayEra where
  huddleRuleNamed :: Proxy "bounded_bytes" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "bounded_bytes"
pname Proxy ConwayEra
_ = Proxy "bounded_bytes" -> Rule
boundedBytesRule Proxy "bounded_bytes"
pname

instance HuddleRule "distinct_bytes" ConwayEra where
  huddleRuleNamed :: Proxy "distinct_bytes" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "distinct_bytes"
pname Proxy ConwayEra
_ = Proxy "distinct_bytes" -> Rule
distinctBytesRule Proxy "distinct_bytes"
pname

instance HuddleRule "big_uint" ConwayEra where
  huddleRuleNamed :: Proxy "big_uint" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "big_uint" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "bounded_bytes" era =>
Proxy "big_uint" -> Proxy era -> Rule
bigUintRule

instance HuddleRule "big_nint" ConwayEra where
  huddleRuleNamed :: Proxy "big_nint" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "big_nint" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "bounded_bytes" era =>
Proxy "big_nint" -> Proxy era -> Rule
bigNintRule

instance HuddleRule "big_int" ConwayEra where
  huddleRuleNamed :: Proxy "big_int" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "big_int" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "big_uint" era, HuddleRule "big_nint" era) =>
Proxy "big_int" -> Proxy era -> Rule
bigIntRule

instance HuddleRule "network_id" ConwayEra where
  huddleRuleNamed :: Proxy "network_id" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "network_id"
pname Proxy ConwayEra
_ = Proxy "network_id" -> Rule
networkIdRule Proxy "network_id"
pname

instance HuddleRule "dns_name" ConwayEra where
  huddleRuleNamed :: Proxy "dns_name" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "dns_name"
pname Proxy ConwayEra
_ = Proxy "dns_name" -> Rule
dnsNameRule Proxy "dns_name"
pname

instance HuddleRule "url" ConwayEra where
  huddleRuleNamed :: Proxy "url" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "url"
pname Proxy ConwayEra
_ = Proxy "url" -> Rule
urlRule Proxy "url"
pname

instance HuddleRule "major_protocol_version" ConwayEra where
  huddleRuleNamed :: Proxy "major_protocol_version" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "major_protocol_version" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "major_protocol_version" -> Proxy era -> Rule
majorProtocolVersionRule

instance HuddleRule "genesis_hash" ConwayEra where
  huddleRuleNamed :: Proxy "genesis_hash" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "genesis_hash" -> Proxy ConwayEra -> Rule
forall era. Era era => Proxy "genesis_hash" -> Proxy era -> Rule
genesisHashRule

instance HuddleRule "genesis_delegate_hash" ConwayEra where
  huddleRuleNamed :: Proxy "genesis_delegate_hash" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "genesis_delegate_hash" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "genesis_delegate_hash" -> Proxy era -> Rule
genesisDelegateHashRule

instance HuddleRule "transaction_id" ConwayEra where
  huddleRuleNamed :: Proxy "transaction_id" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "transaction_id" -> Proxy ConwayEra -> Rule
forall era. Era era => Proxy "transaction_id" -> Proxy era -> Rule
transactionIdRule

instance HuddleRule "vkeywitness" ConwayEra where
  huddleRuleNamed :: Proxy "vkeywitness" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "vkeywitness" -> Proxy ConwayEra -> Rule
forall era. Era era => Proxy "vkeywitness" -> Proxy era -> Rule
vkeywitnessRule

instance HuddleRule "bootstrap_witness" ConwayEra where
  huddleRuleNamed :: Proxy "bootstrap_witness" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "bootstrap_witness" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "bootstrap_witness" -> Proxy era -> Rule
bootstrapWitnessRule

instance HuddleRule "ex_units" ConwayEra where
  huddleRuleNamed :: Proxy "ex_units" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "ex_units"
pname Proxy ConwayEra
_ = Proxy "ex_units" -> Rule
exUnitsRule Proxy "ex_units"
pname

instance HuddleRule "positive_interval" ConwayEra where
  huddleRuleNamed :: Proxy "positive_interval" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "positive_interval" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "positive_interval" -> Proxy era -> Rule
positiveIntervalRule

instance HuddleRule "vote" ConwayEra where
  huddleRuleNamed :: Proxy "vote" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "vote"
pname Proxy ConwayEra
_ = Proxy "vote" -> Rule
voteRule Proxy "vote"
pname

instance HuddleRule "asset_name" ConwayEra where
  huddleRuleNamed :: Proxy "asset_name" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "asset_name"
pname Proxy ConwayEra
_ = Proxy "asset_name" -> Rule
assetNameRule Proxy "asset_name"
pname

instance HuddleRule "drep_credential" ConwayEra where
  huddleRuleNamed :: Proxy "drep_credential" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "drep_credential" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "credential" era =>
Proxy "drep_credential" -> Proxy era -> Rule
drepCredentialRule

instance HuddleRule "committee_cold_credential" ConwayEra where
  huddleRuleNamed :: Proxy "committee_cold_credential" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "committee_cold_credential" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "credential" era =>
Proxy "committee_cold_credential" -> Proxy era -> Rule
committeeColdCredentialRule

instance HuddleRule "committee_hot_credential" ConwayEra where
  huddleRuleNamed :: Proxy "committee_hot_credential" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "committee_hot_credential" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "credential" era =>
Proxy "committee_hot_credential" -> Proxy era -> Rule
committeeHotCredentialRule

instance HuddleRule "anchor" ConwayEra where
  huddleRuleNamed :: Proxy "anchor" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "anchor" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "url" era, HuddleRule "hash32" era) =>
Proxy "anchor" -> Proxy era -> Rule
anchorRule

instance HuddleRule "drep" ConwayEra where
  huddleRuleNamed :: Proxy "drep" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "drep" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
Proxy "drep" -> Proxy era -> Rule
drepRule

instance HuddleRule "voter" ConwayEra where
  huddleRuleNamed :: Proxy "voter" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "voter" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "script_hash" era) =>
Proxy "voter" -> Proxy era -> Rule
voterRule

instance (Era era, HuddleRule "transaction_id" era) => HuddleRule "gov_action_id" era where
  huddleRuleNamed :: Proxy "gov_action_id" -> Proxy era -> Rule
huddleRuleNamed Proxy "gov_action_id"
pname Proxy era
p =
    Proxy "gov_action_id"
pname
      Proxy "gov_action_id" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Key
"transaction_id" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_id" Proxy era
p
        , Key
"gov_action_index" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)
        ]

instance HuddleRule "operational_cert" ConwayEra where
  huddleRuleNamed :: Proxy "operational_cert" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "operational_cert" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "operational_cert" -> Proxy era -> Rule
babbageOperationalCertRule

instance HuddleRule "protocol_version" ConwayEra where
  huddleRuleNamed :: Proxy "protocol_version" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "protocol_version" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "major_protocol_version" era =>
Proxy "protocol_version" -> Proxy era -> Rule
babbageProtocolVersionRule

instance (Era era, HuddleRule "distinct_bytes" era) => HuddleRule "plutus_v3_script" era where
  huddleRuleNamed :: Proxy "plutus_v3_script" -> Proxy era -> Rule
huddleRuleNamed Proxy "plutus_v3_script"
pname Proxy era
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|Conway introduces Plutus V3 with support for new governance features.
          |
          |Note: distinct VBytes ensures uniqueness in test generation.
          |The cddl tool we use for roundtrip testing doesn't generate
          |distinct collections, so we use sized variants to ensure uniqueness.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "plutus_v3_script"
pname Proxy "plutus_v3_script" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"distinct_bytes" Proxy era
p

instance Era era => HuddleRule "negative_int64" era where
  huddleRuleNamed :: Proxy "negative_int64" -> Proxy era -> Rule
huddleRuleNamed Proxy "negative_int64"
pname Proxy era
p =
    Proxy "negative_int64"
pname
      Proxy "negative_int64" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"min_int64" Proxy era
p
      Rule -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (-Integer
1 :: Integer)

instance Era era => HuddleRule "positive_int64" era where
  huddleRuleNamed :: Proxy "positive_int64" -> Proxy era -> Rule
huddleRuleNamed Proxy "positive_int64"
pname Proxy era
p =
    Proxy "positive_int64"
pname
      Proxy "positive_int64" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer
1 :: Integer)
      Integer -> Rule -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"max_int64" Proxy era
p

instance Era era => HuddleRule "nonzero_int64" era where
  huddleRuleNamed :: Proxy "nonzero_int64" -> Proxy era -> Rule
huddleRuleNamed Proxy "nonzero_int64"
pname Proxy era
p =
    Proxy "nonzero_int64"
pname
      Proxy "nonzero_int64" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"negative_int64" Proxy era
p
      Rule -> Rule -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"positive_int64" Proxy era
p

instance HuddleRule "policy_id" ConwayEra where
  huddleRuleNamed :: Proxy "policy_id" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "policy_id"
pname Proxy ConwayEra
p = Proxy "policy_id"
pname Proxy "policy_id" -> Rule -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_hash" Proxy ConwayEra
p

instance HuddleRule "guardrails_script_hash" ConwayEra where
  huddleRuleNamed :: Proxy "guardrails_script_hash" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "guardrails_script_hash" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "script_hash" era =>
Proxy "guardrails_script_hash" -> Proxy era -> Rule
guardrailsScriptHashRule

instance HuddleGroup "script_pubkey" ConwayEra where
  huddleGroupNamed :: Proxy "script_pubkey" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_pubkey"
pname = Proxy "script_pubkey" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "script_pubkey" -> Proxy era -> GroupDef
scriptPubkeyGroup Proxy "script_pubkey"
pname

instance HuddleGroup "script_all" ConwayEra where
  huddleGroupNamed :: Proxy "script_all" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_all"
pname = Proxy "script_all" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "native_script" era =>
Proxy "script_all" -> Proxy era -> GroupDef
scriptAllGroup Proxy "script_all"
pname

instance HuddleGroup "script_any" ConwayEra where
  huddleGroupNamed :: Proxy "script_any" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_any"
pname = Proxy "script_any" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "native_script" era =>
Proxy "script_any" -> Proxy era -> GroupDef
scriptAnyGroup Proxy "script_any"
pname

instance HuddleGroup "script_n_of_k" ConwayEra where
  huddleGroupNamed :: Proxy "script_n_of_k" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_n_of_k"
pname = Proxy "script_n_of_k" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "native_script" era =>
Proxy "script_n_of_k" -> Proxy era -> GroupDef
scriptNOfKGroup Proxy "script_n_of_k"
pname

instance HuddleGroup "script_invalid_before" ConwayEra where
  huddleGroupNamed :: Proxy "script_invalid_before" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_invalid_before"
pname = Proxy "script_invalid_before" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "script_invalid_before" -> Proxy era -> GroupDef
scriptInvalidBeforeGroup Proxy "script_invalid_before"
pname

instance HuddleGroup "script_invalid_hereafter" ConwayEra where
  huddleGroupNamed :: Proxy "script_invalid_hereafter" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "script_invalid_hereafter"
pname = Proxy "script_invalid_hereafter" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "script_invalid_hereafter" -> Proxy era -> GroupDef
scriptInvalidHereafterGroup Proxy "script_invalid_hereafter"
pname

instance HuddleRule "native_script" ConwayEra where
  huddleRuleNamed :: Proxy "native_script" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "native_script" -> Proxy ConwayEra -> Rule
forall era.
(HuddleGroup "script_pubkey" era, HuddleGroup "script_all" era,
 HuddleGroup "script_any" era, HuddleGroup "script_n_of_k" era,
 HuddleGroup "script_invalid_before" era,
 HuddleGroup "script_invalid_hereafter" era) =>
Proxy "native_script" -> Proxy era -> Rule
nativeScriptRule

instance HuddleGroup "single_host_addr" ConwayEra where
  huddleGroupNamed :: Proxy "single_host_addr" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "single_host_addr"
pname = Proxy "single_host_addr" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "single_host_addr" -> Proxy era -> GroupDef
singleHostAddrGroup Proxy "single_host_addr"
pname

instance HuddleGroup "single_host_name" ConwayEra where
  huddleGroupNamed :: Proxy "single_host_name" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "single_host_name"
pname = Proxy "single_host_name" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "dns_name" era =>
Proxy "single_host_name" -> Proxy era -> GroupDef
singleHostNameGroup Proxy "single_host_name"
pname

instance HuddleGroup "multi_host_name" ConwayEra where
  huddleGroupNamed :: Proxy "multi_host_name" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "multi_host_name"
pname = Proxy "multi_host_name" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "dns_name" era =>
Proxy "multi_host_name" -> Proxy era -> GroupDef
multiHostNameGroup Proxy "multi_host_name"
pname

instance HuddleRule "relay" ConwayEra where
  huddleRuleNamed :: Proxy "relay" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "relay" -> Proxy ConwayEra -> Rule
forall era.
(HuddleGroup "single_host_addr" era,
 HuddleGroup "single_host_name" era,
 HuddleGroup "multi_host_name" era) =>
Proxy "relay" -> Proxy era -> Rule
relayRule

instance HuddleRule "pool_metadata" ConwayEra where
  huddleRuleNamed :: Proxy "pool_metadata" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "pool_metadata" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "url" era =>
Proxy "pool_metadata" -> Proxy era -> Rule
poolMetadataRule

instance HuddleGroup "pool_params" ConwayEra where
  huddleGroupNamed :: Proxy "pool_params" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "pool_params"
pname = Proxy "pool_params" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "relay" era, HuddleRule "pool_metadata" era,
 HuddleRule1 "set" era) =>
Proxy "pool_params" -> Proxy era -> GroupDef
poolParamsGroup Proxy "pool_params"
pname

instance HuddleGroup "account_registration_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_registration_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_registration_cert"
pname = Proxy "account_registration_cert" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "account_registration_cert" -> Proxy era -> GroupDef
accountRegistrationCertGroup Proxy "account_registration_cert"
pname

instance HuddleGroup "account_unregistration_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_unregistration_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_unregistration_cert"
pname = Proxy "account_unregistration_cert" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "account_unregistration_cert" -> Proxy era -> GroupDef
accountUnregistrationCertGroup Proxy "account_unregistration_cert"
pname

instance HuddleGroup "delegation_to_stake_pool_cert" ConwayEra where
  huddleGroupNamed :: Proxy "delegation_to_stake_pool_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "delegation_to_stake_pool_cert"
pname = Proxy "delegation_to_stake_pool_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "delegation_to_stake_pool_cert" -> Proxy era -> GroupDef
delegationToStakePoolCertGroup Proxy "delegation_to_stake_pool_cert"
pname

instance HuddleGroup "pool_registration_cert" ConwayEra where
  huddleGroupNamed :: Proxy "pool_registration_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "pool_registration_cert"
pname = Proxy "pool_registration_cert" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleGroup "pool_params" era =>
Proxy "pool_registration_cert" -> Proxy era -> GroupDef
poolRegistrationCertGroup Proxy "pool_registration_cert"
pname

instance HuddleGroup "pool_retirement_cert" ConwayEra where
  huddleGroupNamed :: Proxy "pool_retirement_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "pool_retirement_cert"
pname = Proxy "pool_retirement_cert" -> Proxy ConwayEra -> GroupDef
forall era.
Era era =>
Proxy "pool_retirement_cert" -> Proxy era -> GroupDef
poolRetirementCertGroup Proxy "pool_retirement_cert"
pname

instance HuddleGroup "account_registration_deposit_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_registration_deposit_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_registration_deposit_cert"
pname = Proxy "account_registration_deposit_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
Proxy "account_registration_deposit_cert" -> Proxy era -> GroupDef
accountRegistrationDepositCertGroup Proxy "account_registration_deposit_cert"
pname

instance HuddleGroup "account_unregistration_deposit_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_unregistration_deposit_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_unregistration_deposit_cert"
pname = Proxy "account_unregistration_deposit_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "coin" era) =>
Proxy "account_unregistration_deposit_cert"
-> Proxy era -> GroupDef
accountUnregistrationDepositCertGroup Proxy "account_unregistration_deposit_cert"
pname

instance HuddleGroup "delegation_to_drep_cert" ConwayEra where
  huddleGroupNamed :: Proxy "delegation_to_drep_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "delegation_to_drep_cert"
pname = Proxy "delegation_to_drep_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "drep" era) =>
Proxy "delegation_to_drep_cert" -> Proxy era -> GroupDef
delegationToDrepCertGroup Proxy "delegation_to_drep_cert"
pname

instance HuddleGroup "delegation_to_stake_pool_and_drep_cert" ConwayEra where
  huddleGroupNamed :: Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "delegation_to_stake_pool_and_drep_cert"
pname = Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "drep" era) =>
Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy era -> GroupDef
delegationToStakePoolAndDrepCertGroup Proxy "delegation_to_stake_pool_and_drep_cert"
pname

instance HuddleGroup "account_registration_delegation_to_stake_pool_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_registration_delegation_to_stake_pool_cert"
pname = Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToStakePoolCertGroup Proxy "account_registration_delegation_to_stake_pool_cert"
pname

instance HuddleGroup "account_registration_delegation_to_drep_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_registration_delegation_to_drep_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_registration_delegation_to_drep_cert"
pname = Proxy "account_registration_delegation_to_drep_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "drep" era,
 HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_drep_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToDrepCertGroup Proxy "account_registration_delegation_to_drep_cert"
pname

instance HuddleGroup "account_registration_delegation_to_stake_pool_and_drep_cert" ConwayEra where
  huddleGroupNamed :: Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
pname = Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "stake_credential" era, HuddleRule "pool_keyhash" era,
 HuddleRule "drep" era, HuddleRule "coin" era) =>
Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy era -> GroupDef
accountRegistrationDelegationToStakePoolAndDrepCertGroup Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
pname

instance HuddleGroup "committee_authorization_cert" ConwayEra where
  huddleGroupNamed :: Proxy "committee_authorization_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "committee_authorization_cert"
pname = Proxy "committee_authorization_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "committee_cold_credential" era,
 HuddleRule "committee_hot_credential" era) =>
Proxy "committee_authorization_cert" -> Proxy era -> GroupDef
committeeAuthorizationCertGroup Proxy "committee_authorization_cert"
pname

instance HuddleGroup "committee_resignation_cert" ConwayEra where
  huddleGroupNamed :: Proxy "committee_resignation_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "committee_resignation_cert"
pname = Proxy "committee_resignation_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "committee_cold_credential" era,
 HuddleRule "anchor" era) =>
Proxy "committee_resignation_cert" -> Proxy era -> GroupDef
committeeResignationCertGroup Proxy "committee_resignation_cert"
pname

instance HuddleGroup "drep_registration_cert" ConwayEra where
  huddleGroupNamed :: Proxy "drep_registration_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "drep_registration_cert"
pname = Proxy "drep_registration_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "drep_credential" era, HuddleRule "coin" era,
 HuddleRule "anchor" era) =>
Proxy "drep_registration_cert" -> Proxy era -> GroupDef
drepRegistrationCertGroup Proxy "drep_registration_cert"
pname

instance HuddleGroup "drep_unregistration_cert" ConwayEra where
  huddleGroupNamed :: Proxy "drep_unregistration_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "drep_unregistration_cert"
pname = Proxy "drep_unregistration_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "drep_credential" era, HuddleRule "coin" era) =>
Proxy "drep_unregistration_cert" -> Proxy era -> GroupDef
drepUnregistrationCertGroup Proxy "drep_unregistration_cert"
pname

instance HuddleGroup "drep_update_cert" ConwayEra where
  huddleGroupNamed :: Proxy "drep_update_cert" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "drep_update_cert"
pname = Proxy "drep_update_cert" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "drep_credential" era, HuddleRule "anchor" era) =>
Proxy "drep_update_cert" -> Proxy era -> GroupDef
drepUpdateCertGroup Proxy "drep_update_cert"
pname

instance HuddleRule "certificate" ConwayEra where
  huddleRuleNamed :: Proxy "certificate" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "certificate" -> Proxy ConwayEra -> Rule
forall era.
(HuddleGroup "account_registration_cert" era,
 HuddleGroup "account_unregistration_cert" era,
 HuddleGroup "delegation_to_stake_pool_cert" era,
 HuddleGroup "pool_registration_cert" era,
 HuddleGroup "pool_retirement_cert" era,
 HuddleGroup "account_registration_deposit_cert" era,
 HuddleGroup "account_unregistration_deposit_cert" era,
 HuddleGroup "delegation_to_drep_cert" era,
 HuddleGroup "delegation_to_stake_pool_and_drep_cert" era,
 HuddleGroup
   "account_registration_delegation_to_stake_pool_cert" era,
 HuddleGroup "account_registration_delegation_to_drep_cert" era,
 HuddleGroup
   "account_registration_delegation_to_stake_pool_and_drep_cert" era,
 HuddleGroup "committee_authorization_cert" era,
 HuddleGroup "committee_resignation_cert" era,
 HuddleGroup "drep_registration_cert" era,
 HuddleGroup "drep_unregistration_cert" era,
 HuddleGroup "drep_update_cert" era) =>
Proxy "certificate" -> Proxy era -> Rule
conwayCertificateRule

instance HuddleRule "certificates" ConwayEra where
  huddleRuleNamed :: Proxy "certificates" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "certificates" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "certificate" era, HuddleRule1 "nonempty_oset" era) =>
Proxy "certificates" -> Proxy era -> Rule
certificatesRule

instance HuddleRule "voting_procedure" ConwayEra where
  huddleRuleNamed :: Proxy "voting_procedure" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "voting_procedure" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "vote" era, HuddleRule "anchor" era) =>
Proxy "voting_procedure" -> Proxy era -> Rule
votingProcedureRule

instance HuddleRule "voting_procedures" ConwayEra where
  huddleRuleNamed :: Proxy "voting_procedures" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "voting_procedures" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "voter" era, HuddleRule "gov_action_id" era,
 HuddleRule "voting_procedure" era) =>
Proxy "voting_procedures" -> Proxy era -> Rule
votingProceduresRule

instance HuddleRule "constitution" ConwayEra where
  huddleRuleNamed :: Proxy "constitution" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "constitution" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "anchor" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "constitution" -> Proxy era -> Rule
constitutionRule

instance HuddleGroup "parameter_change_action" ConwayEra where
  huddleGroupNamed :: Proxy "parameter_change_action" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "parameter_change_action"
pname = Proxy "parameter_change_action" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "protocol_param_update" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "parameter_change_action" -> Proxy era -> GroupDef
parameterChangeActionGroup Proxy "parameter_change_action"
pname

instance HuddleGroup "hard_fork_initiation_action" ConwayEra where
  huddleGroupNamed :: Proxy "hard_fork_initiation_action" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "hard_fork_initiation_action"
pname = Proxy "hard_fork_initiation_action" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "protocol_version" era) =>
Proxy "hard_fork_initiation_action" -> Proxy era -> GroupDef
hardForkInitiationActionGroup Proxy "hard_fork_initiation_action"
pname

instance HuddleGroup "treasury_withdrawals_action" ConwayEra where
  huddleGroupNamed :: Proxy "treasury_withdrawals_action" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "treasury_withdrawals_action"
pname = Proxy "treasury_withdrawals_action" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "reward_account" era, HuddleRule "coin" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "treasury_withdrawals_action" -> Proxy era -> GroupDef
treasuryWithdrawalsActionGroup Proxy "treasury_withdrawals_action"
pname

instance HuddleGroup "no_confidence" ConwayEra where
  huddleGroupNamed :: Proxy "no_confidence" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "no_confidence"
pname = Proxy "no_confidence" -> Proxy ConwayEra -> GroupDef
forall era.
HuddleRule "gov_action_id" era =>
Proxy "no_confidence" -> Proxy era -> GroupDef
noConfidenceGroup Proxy "no_confidence"
pname

instance HuddleGroup "update_committee" ConwayEra where
  huddleGroupNamed :: Proxy "update_committee" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "update_committee"
pname = Proxy "update_committee" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "gov_action_id" era,
 HuddleRule "committee_cold_credential" era, HuddleRule "epoch" era,
 HuddleRule "unit_interval" era, HuddleRule1 "set" era) =>
Proxy "update_committee" -> Proxy era -> GroupDef
updateCommitteeGroup Proxy "update_committee"
pname

instance HuddleGroup "new_constitution" ConwayEra where
  huddleGroupNamed :: Proxy "new_constitution" -> Proxy ConwayEra -> GroupDef
huddleGroupNamed Proxy "new_constitution"
pname = Proxy "new_constitution" -> Proxy ConwayEra -> GroupDef
forall era.
(HuddleRule "gov_action_id" era, HuddleRule "constitution" era) =>
Proxy "new_constitution" -> Proxy era -> GroupDef
newConstitutionGroup Proxy "new_constitution"
pname

instance HuddleRule "info_action" ConwayEra where
  huddleRuleNamed :: Proxy "info_action" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "info_action"
pname Proxy ConwayEra
_ = Proxy "info_action" -> Rule
infoActionRule Proxy "info_action"
pname

instance HuddleRule "gov_action" ConwayEra where
  huddleRuleNamed :: Proxy "gov_action" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "gov_action" -> Proxy ConwayEra -> Rule
forall era.
(HuddleGroup "parameter_change_action" era,
 HuddleGroup "hard_fork_initiation_action" era,
 HuddleGroup "treasury_withdrawals_action" era,
 HuddleGroup "no_confidence" era,
 HuddleGroup "update_committee" era,
 HuddleGroup "new_constitution" era,
 HuddleRule "info_action" era) =>
Proxy "gov_action" -> Proxy era -> Rule
govActionRule

instance HuddleRule "proposal_procedure" ConwayEra where
  huddleRuleNamed :: Proxy "proposal_procedure" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "proposal_procedure" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "coin" era, HuddleRule "reward_account" era,
 HuddleRule "gov_action" era, HuddleRule "anchor" era) =>
Proxy "proposal_procedure" -> Proxy era -> Rule
proposalProcedureRule

instance HuddleRule "proposal_procedures" ConwayEra where
  huddleRuleNamed :: Proxy "proposal_procedures" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "proposal_procedures" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "proposal_procedure" era,
 HuddleRule1 "nonempty_oset" era) =>
Proxy "proposal_procedures" -> Proxy era -> Rule
proposalProceduresRule

instance HuddleRule "transaction_input" ConwayEra where
  huddleRuleNamed :: Proxy "transaction_input" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "transaction_input"
pname Proxy ConwayEra
p =
    Proxy "transaction_input"
pname
      Proxy "transaction_input" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Key
"transaction_id" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_id" Proxy ConwayEra
p
        , Key
"index" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)
        ]

instance HuddleRule "required_signers" ConwayEra where
  huddleRuleNamed :: Proxy "required_signers" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "required_signers"
pname Proxy ConwayEra
p =
    Proxy "required_signers"
pname
      Proxy "required_signers" -> GRuleCall -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy ConwayEra
p)

instance HuddleRule "value" ConwayEra where
  huddleRuleNamed :: Proxy "value" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "value" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "positive_coin" era, HuddleRule1 "multiasset" era) =>
Proxy "value" -> Proxy era -> Rule
conwayValueRule

instance HuddleRule "mint" ConwayEra where
  huddleRuleNamed :: Proxy "mint" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "mint" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "policy_id" era, HuddleRule "asset_name" era,
 HuddleRule "nonzero_int64" era) =>
Proxy "mint" -> Proxy era -> Rule
conwayMintRule

instance HuddleRule "withdrawals" ConwayEra where
  huddleRuleNamed :: Proxy "withdrawals" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "withdrawals" -> Proxy ConwayEra -> Rule
forall era. Era era => Proxy "withdrawals" -> Proxy era -> Rule
conwayWithdrawalsRule

instance HuddleRule "data" ConwayEra where
  huddleRuleNamed :: Proxy "data" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "data"
pname Proxy ConwayEra
p =
    Proxy "data"
pname Proxy "data" -> Tagged Constrained -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Word64 -> Constrained -> Tagged Constrained
forall a. Word64 -> a -> Tagged a
tag Word64
24 (Value ByteString
VBytes Value ByteString -> Rule -> Constrained
forall b c.
(IsCborable b, IsConstrainable c b) =>
c -> Rule -> Constrained
`cbor` forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_data" Proxy ConwayEra
p)

instance HuddleRule "datum_option" ConwayEra where
  huddleRuleNamed :: Proxy "datum_option" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "datum_option"
pname Proxy ConwayEra
p =
    Proxy "datum_option"
pname
      Proxy "datum_option" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
0, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"hash32" Proxy ConwayEra
p)]
      ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
1, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"data" Proxy ConwayEra
p)]

instance HuddleRule "script_ref" ConwayEra where
  huddleRuleNamed :: Proxy "script_ref" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "script_ref" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "script" era =>
Proxy "script_ref" -> Proxy era -> Rule
scriptRefRule

instance HuddleRule "alonzo_transaction_output" ConwayEra where
  huddleRuleNamed :: Proxy "alonzo_transaction_output" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "alonzo_transaction_output"
pname Proxy ConwayEra
p =
    Proxy "alonzo_transaction_output"
pname
      Proxy "alonzo_transaction_output" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"address" Proxy ConwayEra
p)
        , Key
"amount" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"value" Proxy ConwayEra
p
        , ArrayEntry -> ArrayEntry
forall a. CanQuantify a => a -> a
opt (Key
"datum_hash" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"hash32" Proxy ConwayEra
p)
        ]

instance HuddleRule "babbage_transaction_output" ConwayEra where
  huddleRuleNamed :: Proxy "babbage_transaction_output" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "babbage_transaction_output" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "address" era, HuddleRule "value" era,
 HuddleRule "datum_option" era, HuddleRule "script_ref" era) =>
Proxy "babbage_transaction_output" -> Proxy era -> Rule
babbageTransactionOutput

instance HuddleRule "transaction_output" ConwayEra where
  huddleRuleNamed :: Proxy "transaction_output" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "transaction_output"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|Both of the Alonzo and Babbage style TxOut formats are equally valid
          |and can be used interchangeably
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "transaction_output"
pname
        Proxy "transaction_output" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"alonzo_transaction_output" Proxy ConwayEra
p
        Rule -> Rule -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"babbage_transaction_output" Proxy ConwayEra
p

instance HuddleRule "script" ConwayEra where
  huddleRuleNamed :: Proxy "script" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "script"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|Conway supports four script types:
          |  0: Native scripts (timelock) - unchanged from Allegra
          |  1: Plutus V1 scripts
          |  2: Plutus V2 scripts
          |  3: Plutus V3 scripts
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "script"
pname
        Proxy "script" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
0, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"native_script" Proxy ConwayEra
p)]
        ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
1, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v1_script" Proxy ConwayEra
p)]
        Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
2, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v2_script" Proxy ConwayEra
p)]
        Choice ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr [Item ArrayChoice
ArrayEntry
3, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v3_script" Proxy ConwayEra
p)]

instance HuddleRule "language" ConwayEra where
  huddleRuleNamed :: Proxy "language" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "language"
pname Proxy ConwayEra
_ =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|0: Plutus v1
          |1: Plutus v2
          |2: Plutus v3
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "language"
pname Proxy "language" -> Ranged -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer
0 :: Integer) Integer -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (Integer
2 :: Integer)

instance HuddleRule "potential_languages" ConwayEra where
  huddleRuleNamed :: Proxy "potential_languages" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "potential_languages"
pname Proxy ConwayEra
_ = Proxy "potential_languages" -> Rule
potentialLanguagesRule Proxy "potential_languages"
pname

instance HuddleRule "cost_models" ConwayEra where
  huddleRuleNamed :: Proxy "cost_models" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "cost_models"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|The format for cost_models is flexible enough to allow adding
          |Plutus built-ins and language versions in the future.
          |
          |Plutus v1: only 166 integers are used, but more are accepted (and ignored)
          |Plutus v2: only 175 integers are used, but more are accepted (and ignored)
          |Plutus v3: only 223 integers are used, but more are accepted (and ignored)
          |
          |Any 8-bit unsigned number can be used as a key.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "cost_models"
pname
        Proxy "cost_models" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
          [ Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
0 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"int64" Proxy ConwayEra
p)]
          , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
1 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"int64" Proxy ConwayEra
p)]
          , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
2 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"int64" Proxy ConwayEra
p)]
          , Word64
0 Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Ranged -> Key
forall r. IsType0 r => r -> Key
asKey ((Integer
3 :: Integer) Integer -> Integer -> Ranged
forall a b. (IsRangeBound a, IsRangeBound b) => a -> b -> Ranged
... (Integer
255 :: Integer)) Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"int64" Proxy ConwayEra
p)]
          ]

instance HuddleRule "redeemer_tag" ConwayEra where
  huddleRuleNamed :: Proxy "redeemer_tag" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "redeemer_tag"
pname Proxy ConwayEra
_ = Proxy "redeemer_tag" -> Rule
conwayRedeemerTag Proxy "redeemer_tag"
pname

instance HuddleRule "redeemer" ConwayEra where
  huddleRuleNamed :: Proxy "redeemer" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "redeemer" -> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "redeemer_tag" era, HuddleRule "plutus_data" era,
 HuddleRule "ex_units" era) =>
Proxy "redeemer" -> Proxy era -> Rule
conwayRedeemer

instance HuddleRule "redeemers" ConwayEra where
  huddleRuleNamed :: Proxy "redeemers" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "redeemers"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|Flat Array support is included for backwards compatibility and
          |will be removed in the next era. It is recommended for tools to
          |adopt using a Map instead of Array going forward.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "redeemers"
pname
        Proxy "redeemers" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> Seal (Choice ArrayChoice)
sarr [Word64
1 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"redeemer" Proxy ConwayEra
p)]
        Seal (Choice ArrayChoice) -> Seal Map -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ MapChoice -> Seal Map
smp
          [ Word64
1
              Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ ArrayChoice -> Key
forall r. IsType0 r => r -> Key
asKey
                ( ArrayChoice -> ArrayChoice
arr
                    [ Key
"tag" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"redeemer_tag" Proxy ConwayEra
p
                    , Key
"index" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)
                    ]
                )
              Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr
                [ Key
"data" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_data" Proxy ConwayEra
p
                , Key
"ex_units" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"ex_units" Proxy ConwayEra
p
                ]
          ]

instance HuddleRule "script_data_hash" ConwayEra where
  huddleRuleNamed :: Proxy "script_data_hash" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "script_data_hash"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|This is a hash of data which may affect evaluation of a script.
          |This data consists of:
          |  - The redeemers from the transaction_witness_set (the value of field 5).
          |  - The datums from the transaction_witness_set (the value of field 4).
          |  - The value in the cost_models map corresponding to the script's language
          |    (in field 18 of protocol_param_update.)
          |(In the future it may contain additional protocol parameters.)
          |
          |Since this data does not exist in contiguous form inside a transaction, it needs
          |to be independently constructed by each recipient.
          |
          |The bytestring which is hashed is the concatenation of three things:
          |  redeemers || datums || language views
          |The redeemers are exactly the data present in the transaction witness set.
          |Similarly for the datums, if present. If no datums are provided, the middle
          |field is omitted (i.e. it is the empty/null bytestring).
          |
          |language views CDDL:
          |{ * language => script_integrity_data }
          |
          |This must be encoded canonically, using the same scheme as in
          |RFC7049 section 3.9:
          | - Maps, strings, and bytestrings must use a definite-length encoding
          | - Integers must be as small as possible.
          | - The expressions for map length, string length, and bytestring length
          |   must be as short as possible.
          | - The keys in the map must be sorted as follows:
          |    -  If two keys have different lengths, the shorter one sorts earlier.
          |    -  If two keys have the same length, the one with the lower value
          |       in (byte-wise) lexical order sorts earlier.
          |
          |For PlutusV1 (language id 0), the language view is the following:
          |  - the value of cost_models map at key 0 (in other words, the script_integrity_data)
          |    is encoded as an indefinite length list and the result is encoded as a bytestring.
          |    (our apologies)
          |    For example, the script_integrity_data corresponding to the all zero costmodel for V1
          |    would be encoded as (in hex):
          |    58a89f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ff
          |  - the language ID tag is also encoded twice. first as a uint then as
          |    a bytestring. (our apologies)
          |    Concretely, this means that the language version for V1 is encoded as
          |    4100 in hex.
          |For PlutusV2 (language id 1), the language view is the following:
          |  - the value of cost_models map at key 1 is encoded as an definite length list.
          |    For example, the script_integrity_data corresponding to the all zero costmodel for V2
          |    would be encoded as (in hex):
          |    98af0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
          |  - the language ID tag is encoded as expected.
          |    Concretely, this means that the language version for V2 is encoded as
          |    01 in hex.
          |For PlutusV3 (language id 2), the language view is the following:
          |  - the value of cost_models map at key 2 is encoded as a definite length list.
          |
          |Note that each Plutus language represented inside a transaction must have
          |a cost model in the cost_models protocol parameter in order to execute,
          |regardless of what the script integrity data is.
          |
          |Finally, note that in the case that a transaction includes datums but does not
          |include the redeemers field, the script data format becomes (in hex):
          |[ A0 | datums | A0 ]
          |corresponding to a CBOR empty map and an empty map for language view.
          |This empty redeeemer case has changed from the previous eras, since default
          |representation for redeemers has been changed to a map. Also whenever redeemers are
          |supplied either as a map or as an array they must contain at least one element,
          |therefore there is no way to override this behavior by providing a custom
          |representation for empty redeemers.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "script_data_hash" -> Proxy ConwayEra -> Rule
forall era.
Era era =>
Proxy "script_data_hash" -> Proxy era -> Rule
scriptDataHashRule Proxy "script_data_hash"
pname Proxy ConwayEra
p

instance HuddleRule "transaction_body" ConwayEra where
  huddleRuleNamed :: Proxy "transaction_body" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "transaction_body"
pname Proxy ConwayEra
p =
    Proxy "transaction_body"
pname
      Proxy "transaction_body" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
        [ Word64 -> Key
idx Word64
0 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy ConwayEra
p)
        , Word64 -> Key
idx Word64
1 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_output" Proxy ConwayEra
p)]
        , Word64 -> Key
idx Word64
2 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"fee"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
3 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"slot" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"time to live"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
4 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"certificates" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
5 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"withdrawals" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
7 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"auxiliary_data_hash" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
8 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"slot" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"validity interval start"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
9 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"mint" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
11 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"script_data_hash" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
13 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy ConwayEra
p)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"collateral"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
14 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"required_signers" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
15 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"network_id" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
16 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_output" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"collateral return"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
17 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"total collateral"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
18 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy ConwayEra
p))
            MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"reference inputs"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
19 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"voting_procedures" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
20 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"proposal_procedures" Proxy ConwayEra
p)
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
21 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"current treasury value"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
22 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"positive_coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"donation"
        ]

instance HuddleRule "transaction_witness_set" ConwayEra where
  huddleRuleNamed :: Proxy "transaction_witness_set" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "transaction_witness_set"
pname Proxy ConwayEra
p =
    Proxy "transaction_witness_set"
pname
      Proxy "transaction_witness_set" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
        [ Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
0 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vkeywitness" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
1 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"native_script" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
2 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"bootstrap_witness" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
3 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v1_script" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
4 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_data" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
5 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"redeemers" Proxy ConwayEra
p
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
6 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v2_script" Proxy ConwayEra
p)
        , Item MapChoice -> Item MapChoice
forall a. CanQuantify a => a -> a
opt (Item MapChoice -> Item MapChoice)
-> Item MapChoice -> Item MapChoice
forall a b. (a -> b) -> a -> b
$ Word64 -> Key
idx Word64
7 Key -> GRuleCall -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era a.
(HuddleRule1 name era, IsType0 a) =>
Proxy era -> a -> GRuleCall
huddleRule1 @"nonempty_set" Proxy ConwayEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v3_script" Proxy ConwayEra
p)
        ]

instance HuddleRule "transaction" ConwayEra where
  huddleRuleNamed :: Proxy "transaction" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "transaction"
pname Proxy ConwayEra
p =
    Proxy "transaction"
pname
      Proxy "transaction" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_body" Proxy ConwayEra
p
        , Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_witness_set" Proxy ConwayEra
p
        , Value Bool -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a Value Bool
VBool
        , Choice Type2 -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"auxiliary_data" Proxy ConwayEra
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
        ]

instance HuddleRule "ex_unit_prices" ConwayEra where
  huddleRuleNamed :: Proxy "ex_unit_prices" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "ex_unit_prices"
pname Proxy ConwayEra
p =
    Proxy "ex_unit_prices"
pname
      Proxy "ex_unit_prices" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Key
"mem_price" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"nonnegative_interval" Proxy ConwayEra
p
        , Key
"step_price" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"nonnegative_interval" Proxy ConwayEra
p
        ]

instance HuddleRule "pool_voting_thresholds" ConwayEra where
  huddleRuleNamed :: Proxy "pool_voting_thresholds" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "pool_voting_thresholds" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "unit_interval" era =>
Proxy "pool_voting_thresholds" -> Proxy era -> Rule
poolVotingThresholdsRule

instance HuddleRule "drep_voting_thresholds" ConwayEra where
  huddleRuleNamed :: Proxy "drep_voting_thresholds" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "drep_voting_thresholds" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "unit_interval" era =>
Proxy "drep_voting_thresholds" -> Proxy era -> Rule
drepVotingThresholdsRule

instance HuddleRule "protocol_param_update" ConwayEra where
  huddleRuleNamed :: Proxy "protocol_param_update" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "protocol_param_update"
pname Proxy ConwayEra
p =
    Proxy "protocol_param_update"
pname
      Proxy "protocol_param_update" -> MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= MapChoice -> MapChoice
mp
        [ MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
0 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"minfeeA"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
1 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"minfeeB"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
2 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max block body size"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
3 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max transaction size"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
4 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max block header size"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
5 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"key deposit"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
6 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"pool deposit"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
7 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"epoch_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"maximum epoch"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
8 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"n_opt: desired number of stake pools"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
9 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"nonnegative_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"pool pledge influence"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
10 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"expansion rate"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
11 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"unit_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"treasury growth rate"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
16 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"min pool cost"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
17 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"ada per utxo byte"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
18 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"cost_models" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"cost models for script languages"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
19 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"ex_unit_prices" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"execution costs"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
20 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"ex_units" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max tx ex units"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
21 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"ex_units" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max block ex units"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
22 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max value size"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
23 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"collateral percentage"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
24 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"max collateral inputs"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
25 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"pool_voting_thresholds" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"pool voting thresholds"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
26 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"drep_voting_thresholds" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"drep voting thresholds"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
27 Key -> Constrained -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
2 :: Word64)) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"min committee size"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
28 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"epoch_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"committee term limit"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
29 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"epoch_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"goveranance action validity period"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
30 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"governance action deposit"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
31 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"coin" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"drep deposit"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
32 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"epoch_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"drep inactivity period"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
33 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"nonnegative_interval" Proxy ConwayEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"minfee refscriptcoinsperbyte"
        ]

instance HuddleRule "proposed_protocol_parameter_updates" ConwayEra where
  huddleRuleNamed :: Proxy "proposed_protocol_parameter_updates"
-> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "proposed_protocol_parameter_updates"
-> Proxy ConwayEra -> Rule
forall era.
(HuddleRule "genesis_hash" era,
 HuddleRule "protocol_param_update" era) =>
Proxy "proposed_protocol_parameter_updates" -> Proxy era -> Rule
proposedProtocolParameterUpdatesRule

instance HuddleRule "update" ConwayEra where
  huddleRuleNamed :: Proxy "update" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "update" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "proposed_protocol_parameter_updates" era =>
Proxy "update" -> Proxy era -> Rule
updateRule

instance HuddleRule "header_body" ConwayEra where
  huddleRuleNamed :: Proxy "header_body" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "header_body"
pname Proxy ConwayEra
p =
    Proxy "header_body"
pname
      Proxy "header_body" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Key
"block_number" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"block_number" Proxy ConwayEra
p
        , Key
"slot" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"slot" Proxy ConwayEra
p
        , Key
"prev_hash" Key -> Choice Type2 -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"hash32" Proxy ConwayEra
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
        , Key
"issuer_vkey" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vkey" Proxy ConwayEra
p
        , Key
"vrf_vkey" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vrf_vkey" Proxy ConwayEra
p
        , Key
"vrf_result" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vrf_cert" Proxy ConwayEra
p
        , Key
"block_body_size" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value Int
VUInt Value Int -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
4 :: Word64)
        , Key
"block_body_hash" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"hash32" Proxy ConwayEra
p ArrayEntry -> Comment -> ArrayEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"merkle triple root"
        , Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"operational_cert" Proxy ConwayEra
p
        , Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"protocol_version" Proxy ConwayEra
p
        ]

instance HuddleRule "header" ConwayEra where
  huddleRuleNamed :: Proxy "header" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "header" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "header_body" era =>
Proxy "header" -> Proxy era -> Rule
headerRule

instance HuddleRule "block" ConwayEra where
  huddleRuleNamed :: Proxy "block" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "block"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|Valid blocks must also satisfy the following two constraints:
          |  1) the length of transaction_bodies and transaction_witness_sets must be
          |     the same
          |  2) every transaction_index must be strictly smaller than the length of
          |     transaction_bodies
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "block"
pname
        Proxy "block" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
          [ Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"header" Proxy ConwayEra
p
          , Key
"transaction_bodies" Key -> ArrayChoice -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_body" Proxy ConwayEra
p)]
          , Key
"transaction_witness_sets" Key -> ArrayChoice -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_witness_set" Proxy ConwayEra
p)]
          , Key
"auxiliary_data_set"
              Key -> MapChoice -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> MapChoice -> MapChoice
mp
                [ Word64
0
                    Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> Key
forall r. IsType0 r => r -> Key
asKey (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_index" Proxy ConwayEra
p)
                    Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"auxiliary_data" Proxy ConwayEra
p
                ]
          , Key
"invalid_transactions" Key -> ArrayChoice -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_index" Proxy ConwayEra
p)]
          ]

instance HuddleRule "auxiliary_scripts" ConwayEra where
  huddleRuleNamed :: Proxy "auxiliary_scripts" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "auxiliary_scripts" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "native_script" era =>
Proxy "auxiliary_scripts" -> Proxy era -> Rule
auxiliaryScriptsRule

instance HuddleRule "auxiliary_data_map" ConwayEra where
  huddleRuleNamed :: Proxy "auxiliary_data_map" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "auxiliary_data_map"
pname Proxy ConwayEra
p =
    Proxy "auxiliary_data_map"
pname
      Proxy "auxiliary_data_map" -> Tagged MapChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Word64 -> MapChoice -> Tagged MapChoice
forall a. Word64 -> a -> Tagged a
tag
        Word64
259
        ( MapChoice -> MapChoice
mp
            [ MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
0 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"metadata" Proxy ConwayEra
p)
            , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
1 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"native_script" Proxy ConwayEra
p)])
            , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
2 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v1_script" Proxy ConwayEra
p)])
            , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
3 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v2_script" Proxy ConwayEra
p)])
            , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
4 Key -> ArrayChoice -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> ArrayChoice -> ArrayChoice
arr [Word64
0 Word64 -> ArrayEntry -> ArrayEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v3_script" Proxy ConwayEra
p)])
            ]
        )

instance HuddleRule "auxiliary_data_array" ConwayEra where
  huddleRuleNamed :: Proxy "auxiliary_data_array" -> Proxy ConwayEra -> Rule
huddleRuleNamed = Proxy "auxiliary_data_array" -> Proxy ConwayEra -> Rule
forall era.
HuddleRule "auxiliary_scripts" era =>
Proxy "auxiliary_data_array" -> Proxy era -> Rule
auxiliaryDataArrayRule

instance HuddleRule "auxiliary_data" ConwayEra where
  huddleRuleNamed :: Proxy "auxiliary_data" -> Proxy ConwayEra -> Rule
huddleRuleNamed Proxy "auxiliary_data"
pname Proxy ConwayEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str|auxiliary_data supports three serialization formats:
          |  1. metadata (raw) - Supported since Shelley
          |  2. auxiliary_data_array - Array format, introduced in Allegra
          |  3. auxiliary_data_map - Tagged map format, introduced in Alonzo
          |     Conway adds plutus_v3_script support at index 4
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "auxiliary_data"
pname
        Proxy "auxiliary_data" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"metadata" Proxy ConwayEra
p
        Rule -> Rule -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"auxiliary_data_array" Proxy ConwayEra
p
        Choice Type2 -> Rule -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"auxiliary_data_map" Proxy ConwayEra
p

instance HuddleRule1 "set" ConwayEra where
  huddleRule1Named :: forall a.
IsType0 a =>
Proxy "set" -> Proxy ConwayEra -> a -> GRuleCall
huddleRule1Named Proxy "set"
pname Proxy ConwayEra
_ = Proxy "set" -> a -> GRuleCall
forall a. IsType0 a => Proxy "set" -> a -> GRuleCall
maybeTaggedSet Proxy "set"
pname

instance HuddleRule1 "nonempty_set" ConwayEra where
  huddleRule1Named :: forall a.
IsType0 a =>
Proxy "nonempty_set" -> Proxy ConwayEra -> a -> GRuleCall
huddleRule1Named Proxy "nonempty_set"
pname Proxy ConwayEra
_ = Proxy "nonempty_set" -> a -> GRuleCall
forall a. IsType0 a => Proxy "nonempty_set" -> a -> GRuleCall
maybeTaggedNonemptySet Proxy "nonempty_set"
pname

instance HuddleRule1 "nonempty_oset" ConwayEra where
  huddleRule1Named :: forall a.
IsType0 a =>
Proxy "nonempty_oset" -> Proxy ConwayEra -> a -> GRuleCall
huddleRule1Named Proxy "nonempty_oset"
pname Proxy ConwayEra
_ = Proxy "nonempty_oset" -> a -> GRuleCall
forall a. IsType0 a => Proxy "nonempty_oset" -> a -> GRuleCall
maybeTaggedNonemptyOset Proxy "nonempty_oset"
pname

instance HuddleRule1 "multiasset" ConwayEra where
  huddleRule1Named :: forall a.
IsType0 a =>
Proxy "multiasset" -> Proxy ConwayEra -> a -> GRuleCall
huddleRule1Named = Proxy "multiasset" -> Proxy ConwayEra -> a -> GRuleCall
forall era a.
(HuddleRule "policy_id" era, HuddleRule "asset_name" era,
 IsType0 a) =>
Proxy "multiasset" -> Proxy era -> a -> GRuleCall
conwayMultiasset