{-# 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.Dijkstra.HuddleSpec (
  module Cardano.Ledger.Conway.HuddleSpec,
  DijkstraEra,
  dijkstraCDDL,
  dijkstraMultiasset,
  dijkstraValueRule,
  guardsRule,
  subTransactionsRule,
  subTransactionRule,
  subTransactionBodyRule,
  requiredTopLevelGuardsRule,
  directDepositsRule,
  dijkstraScriptRule,
  dijkstraNativeScriptRule,
  scriptRequireGuardGroup,
  dijkstraRedeemerTagRule,
  auxiliaryDataMapRule,
) where

import Cardano.Ledger.Conway.HuddleSpec hiding ()
import Cardano.Ledger.Dijkstra (DijkstraEra)
import Cardano.Ledger.Huddle.Gen (CBORGen, RuleTerm (..), genArrayTerm, liftAntiGen, withAntiGen)
import Codec.CBOR.Cuddle.CBOR.Gen (generateFromName)
import Codec.CBOR.Term (Term (..))
import Control.Monad (zipWithM)
import Data.Proxy (Proxy (..))
import Data.Text ()
import Data.Text qualified as T
import Data.Word (Word16, Word64)
import Test.AntiGen (withAnnotation, (|!))
import Test.QuickCheck (choose, shuffle)
import Test.QuickCheck qualified as QC
import Test.QuickCheck.GenT (liftGen)
import Text.Heredoc
import Prelude hiding ((/))

dijkstraCDDL :: Huddle
dijkstraCDDL :: Huddle
dijkstraCDDL =
  [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 @DijkstraEra)
    , 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 @DijkstraEra)
    , 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 @DijkstraEra)
    , 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 @DijkstraEra)
    , 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 @DijkstraEra)
    , 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 @DijkstraEra)
    , 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 @DijkstraEra)
    ]

-- | Dijkstra constrains the minor protocol version to Word32 (uint .size 4).
dijkstraProtocolVersionRule ::
  forall era.
  HuddleRule "major_protocol_version" era => Proxy "protocol_version" -> Proxy era -> Rule
dijkstraProtocolVersionRule :: forall era.
HuddleRule "major_protocol_version" era =>
Proxy "protocol_version" -> Proxy era -> Rule
dijkstraProtocolVersionRule Proxy "protocol_version"
pname Proxy era
p =
  Proxy "protocol_version"
pname Proxy "protocol_version" -> 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 @"major_protocol_version" Proxy era
p, Constrained -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Constrained -> Item ArrayChoice)
-> Constrained -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ 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)]

guardsRule ::
  forall era.
  ( HuddleRule "addr_keyhash" era
  , HuddleRule "credential" era
  , HuddleRule1 "nonempty_set" era
  , HuddleRule1 "nonempty_oset" era
  ) =>
  Proxy "guards" ->
  Proxy era ->
  Rule
guardsRule :: forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "credential" era,
 HuddleRule1 "nonempty_set" era, HuddleRule1 "nonempty_oset" era) =>
Proxy "guards" -> Proxy era -> Rule
guardsRule Proxy "guards"
pname Proxy era
p =
  Proxy "guards"
pname
    Proxy "guards" -> Choice Type2 -> 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 era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy era
p)
    GRuleCall -> GRuleCall -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ 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 @"credential" Proxy era
p)

subTransactionsRule ::
  forall era.
  ( HuddleRule "sub_transaction" era
  , HuddleRule1 "nonempty_oset" era
  ) =>
  Proxy "sub_transactions" ->
  Proxy era ->
  Rule
subTransactionsRule :: forall era.
(HuddleRule "sub_transaction" era,
 HuddleRule1 "nonempty_oset" era) =>
Proxy "sub_transactions" -> Proxy era -> Rule
subTransactionsRule Proxy "sub_transactions"
pname Proxy era
p =
  Proxy "sub_transactions"
pname Proxy "sub_transactions" -> 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 @"sub_transaction" Proxy era
p)

subTransactionRule ::
  forall era.
  ( HuddleRule "sub_transaction_body" era
  , HuddleRule "transaction_witness_set" era
  , HuddleRule "auxiliary_data" era
  ) =>
  Proxy "sub_transaction" ->
  Proxy era ->
  Rule
subTransactionRule :: forall era.
(HuddleRule "sub_transaction_body" era,
 HuddleRule "transaction_witness_set" era,
 HuddleRule "auxiliary_data" era) =>
Proxy "sub_transaction" -> Proxy era -> Rule
subTransactionRule Proxy "sub_transaction"
pname Proxy era
p =
  Proxy "sub_transaction"
pname
    Proxy "sub_transaction" -> 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 @"sub_transaction_body" 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 @"transaction_witness_set" 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 @"auxiliary_data" 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)
      ]

subTransactionBodyRule ::
  forall era.
  ( HuddleRule "transaction_input" era
  , HuddleRule "transaction_output" era
  , HuddleRule "slot" era
  , HuddleRule "certificates" era
  , HuddleRule "withdrawals" era
  , HuddleRule "auxiliary_data_hash" era
  , HuddleRule "mint" era
  , HuddleRule "script_data_hash" era
  , HuddleRule "network_id" era
  , HuddleRule "voting_procedures" era
  , HuddleRule "proposal_procedures" era
  , HuddleRule "coin" era
  , HuddleRule "positive_coin" era
  , HuddleRule "guards" era
  , HuddleRule "required_top_level_guards" era
  , HuddleRule "direct_deposits" era
  , HuddleRule "account_balance_intervals" era
  , HuddleRule1 "set" era
  , HuddleRule1 "nonempty_set" era
  ) =>
  Proxy "sub_transaction_body" ->
  Proxy era ->
  Rule
subTransactionBodyRule :: forall era.
(HuddleRule "transaction_input" era,
 HuddleRule "transaction_output" era, HuddleRule "slot" era,
 HuddleRule "certificates" era, HuddleRule "withdrawals" era,
 HuddleRule "auxiliary_data_hash" era, HuddleRule "mint" era,
 HuddleRule "script_data_hash" era, HuddleRule "network_id" era,
 HuddleRule "voting_procedures" era,
 HuddleRule "proposal_procedures" era, HuddleRule "coin" era,
 HuddleRule "positive_coin" era, HuddleRule "guards" era,
 HuddleRule "required_top_level_guards" era,
 HuddleRule "direct_deposits" era,
 HuddleRule "account_balance_intervals" era, HuddleRule1 "set" era,
 HuddleRule1 "nonempty_set" era) =>
Proxy "sub_transaction_body" -> Proxy era -> Rule
subTransactionBodyRule Proxy "sub_transaction_body"
pname Proxy era
p =
  Proxy "sub_transaction_body"
pname
    Proxy "sub_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 era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy era
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 era
p)]
      , 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 era
p)
      , 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 era
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 era
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 era
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 era
p)
      , 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 era
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 era
p)
      , 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 @"guards" Proxy era
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 era
p)
      , 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 era
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy era
p))
      , 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 era
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 era
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 era
p)
      , 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 era
p)
      , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
24 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_top_level_guards" Proxy era
p)
      , 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 @"direct_deposits" Proxy era
p)
      , 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 @"account_balance_intervals" Proxy era
p)
      ]

requiredTopLevelGuardsRule ::
  forall era.
  ( HuddleRule "credential" era
  , HuddleRule "plutus_data" era
  ) =>
  Proxy "required_top_level_guards" ->
  Proxy era ->
  Rule
requiredTopLevelGuardsRule :: forall era.
(HuddleRule "credential" era, HuddleRule "plutus_data" era) =>
Proxy "required_top_level_guards" -> Proxy era -> Rule
requiredTopLevelGuardsRule Proxy "required_top_level_guards"
pname Proxy era
p =
  Proxy "required_top_level_guards"
pname
    Proxy "required_top_level_guards" -> 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 @"credential" Proxy era
p)
          Key -> Choice Type2 -> MapEntry
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 Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
      ]

directDepositsRule ::
  forall era.
  ( HuddleRule "reward_account" era
  , HuddleRule "coin" era
  ) =>
  Proxy "direct_deposits" ->
  Proxy era ->
  Rule
directDepositsRule :: forall era.
(HuddleRule "reward_account" era, HuddleRule "coin" era) =>
Proxy "direct_deposits" -> Proxy era -> Rule
directDepositsRule Proxy "direct_deposits"
pname Proxy era
p =
  Proxy "direct_deposits"
pname
    Proxy "direct_deposits" -> 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
      ]

accountBalanceIntervalsRule ::
  forall era.
  ( HuddleRule "credential" era
  , HuddleRule "account_balance_interval" era
  ) =>
  Proxy "account_balance_intervals" ->
  Proxy era ->
  Rule
accountBalanceIntervalsRule :: forall era.
(HuddleRule "credential" era,
 HuddleRule "account_balance_interval" era) =>
Proxy "account_balance_intervals" -> Proxy era -> Rule
accountBalanceIntervalsRule Proxy "account_balance_intervals"
pname Proxy era
p =
  Proxy "account_balance_intervals"
pname
    Proxy "account_balance_intervals" -> 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 @"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 @"account_balance_interval" Proxy era
p
      ]

accountBalanceIntervalRule ::
  forall era.
  HuddleRule "coin" era =>
  Proxy "account_balance_interval" ->
  Proxy era ->
  Rule
accountBalanceIntervalRule :: forall era.
HuddleRule "coin" era =>
Proxy "account_balance_interval" -> Proxy era -> Rule
accountBalanceIntervalRule Proxy "account_balance_interval"
pname Proxy era
p =
  Proxy "account_balance_interval"
pname
    Proxy "account_balance_interval" -> Choice ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Key
"inclusive_lower_bound" 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
      , Key
"exclusive_upper_bound" 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 @"coin" 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
      ]
    ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ ArrayChoice -> ArrayChoice
arr
      [ Key
"inclusive_lower_bound" 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 @"coin" 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
      , Key
"exclusive_upper_bound" 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
      ]

scriptRequireGuardGroup ::
  forall era.
  HuddleRule "credential" era => Proxy "script_require_guard" -> Proxy era -> GroupDef
scriptRequireGuardGroup :: forall era.
HuddleRule "credential" era =>
Proxy "script_require_guard" -> Proxy era -> GroupDef
scriptRequireGuardGroup Proxy "script_require_guard"
pname Proxy era
p =
  Comment -> GroupDef -> GroupDef
forall a. HasComment a => Comment -> a -> a
comment
    Comment
[str| Dijkstra adds guard scripts for enhanced security.
        | A guard script requires a credential to authorize execution.
        |]
    (GroupDef -> GroupDef) -> GroupDef -> GroupDef
forall a b. (a -> b) -> a -> b
$ Proxy "script_require_guard"
pname Proxy "script_require_guard" -> Group -> GroupDef
forall (name :: Symbol).
KnownSymbol name =>
Proxy name -> Group -> GroupDef
=.~ Group -> Group
grp [Item Group
ArrayEntry
6, Rule -> ArrayEntry
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"credential" Proxy era
p)]

dijkstraNativeScriptRule ::
  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
  , HuddleGroup "script_require_guard" era
  ) =>
  Proxy "native_script" ->
  Proxy era ->
  Rule
dijkstraNativeScriptRule :: 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,
 HuddleGroup "script_require_guard" era) =>
Proxy "native_script" -> Proxy era -> Rule
dijkstraNativeScriptRule Proxy "native_script"
pname Proxy era
p =
  Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
    Comment
[str| Dijkstra native scripts extend Allegra's 6-variant format
        | with a 7th variant for guard scripts.
        |]
    (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "native_script"
pname
      Proxy "native_script" -> 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 @"script_pubkey" 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 @"script_all" 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 @"script_any" 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 @"script_n_of_k" 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 @"script_invalid_before" 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 @"script_invalid_hereafter" 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 @"script_require_guard" Proxy era
p)]

dijkstraScriptRule ::
  forall era.
  ( HuddleRule "native_script" era
  , HuddleRule "plutus_v1_script" era
  , HuddleRule "plutus_v2_script" era
  , HuddleRule "plutus_v3_script" era
  , HuddleRule "plutus_v4_script" era
  ) =>
  Proxy "script" ->
  Proxy era ->
  Rule
dijkstraScriptRule :: forall era.
(HuddleRule "native_script" era, HuddleRule "plutus_v1_script" era,
 HuddleRule "plutus_v2_script" era,
 HuddleRule "plutus_v3_script" era,
 HuddleRule "plutus_v4_script" era) =>
Proxy "script" -> Proxy era -> Rule
dijkstraScriptRule Proxy "script"
pname Proxy era
p =
  Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
    Comment
[str| Dijkstra supports five script types:
        |   0: Native scripts with guard support (7 variants)
        |   1: Plutus V1 scripts
        |   2: Plutus V2 scripts
        |   3: Plutus V3 scripts
        |   4: Plutus V4 scripts (NEW)
        |]
    (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 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 @"plutus_v1_script" 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 @"plutus_v2_script" 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 @"plutus_v3_script" 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 @"plutus_v4_script" Proxy era
p)]

dijkstraRedeemerTagRule :: Proxy "redeemer_tag" -> Rule
dijkstraRedeemerTagRule :: Proxy "redeemer_tag" -> Rule
dijkstraRedeemerTagRule Proxy "redeemer_tag"
pname =
  Proxy "redeemer_tag"
pname
    Proxy "redeemer_tag" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= (Integer -> Literal
int Integer
0 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"spend")
    Literal -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
1 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"mint")
    Choice Type2 -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
2 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"cert")
    Choice Type2 -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
3 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"reward")
    Choice Type2 -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
4 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"voting")
    Choice Type2 -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
5 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"proposing")
    Choice Type2 -> Literal -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ (Integer -> Literal
int Integer
6 Literal -> Comment -> Literal
forall a. HasComment a => a -> Comment -> a
//- Comment
"guarding")

auxiliaryDataMapRule ::
  forall era.
  ( HuddleRule "metadata" era
  , HuddleRule "native_script" era
  , HuddleRule "plutus_v1_script" era
  , HuddleRule "plutus_v2_script" era
  , HuddleRule "plutus_v3_script" era
  , HuddleRule "plutus_v4_script" era
  ) =>
  Proxy "auxiliary_data_map" ->
  Proxy era ->
  Rule
auxiliaryDataMapRule :: forall era.
(HuddleRule "metadata" era, HuddleRule "native_script" era,
 HuddleRule "plutus_v1_script" era,
 HuddleRule "plutus_v2_script" era,
 HuddleRule "plutus_v3_script" era,
 HuddleRule "plutus_v4_script" era) =>
Proxy "auxiliary_data_map" -> Proxy era -> Rule
auxiliaryDataMapRule Proxy "auxiliary_data_map"
pname Proxy era
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 era
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 era
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 era
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 era
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 era
p)])
          , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
5 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_v4_script" Proxy era
p)])
          ]
      )

dijkstraValueRule ::
  forall era.
  ( HuddleRule "positive_coin" era
  , HuddleRule1 "multiasset" era
  ) =>
  Proxy "value" ->
  Proxy era ->
  Rule
dijkstraValueRule :: forall era.
(HuddleRule "positive_coin" era, HuddleRule1 "multiasset" era) =>
Proxy "value" -> Proxy era -> Rule
dijkstraValueRule 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)
      ]

dijkstraMultiasset ::
  forall era a.
  (HuddleRule "policy_id" era, HuddleRule "asset_name" era, IsType0 a) =>
  Proxy "multiasset" ->
  Proxy era ->
  a ->
  GRuleCall
dijkstraMultiasset :: forall era a.
(HuddleRule "policy_id" era, HuddleRule "asset_name" era,
 IsType0 a) =>
Proxy "multiasset" -> Proxy era -> a -> GRuleCall
dijkstraMultiasset 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
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 -> GRef -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> GRef
x]
        ]

dijkstraCertificateRule ::
  forall 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
dijkstraCertificateRule :: forall 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
dijkstraCertificateRule 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 @"delegation_to_stake_pool_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 @"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]

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

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

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

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

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

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

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

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

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

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

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

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

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

instance HuddleRule "ex_units" DijkstraEra where
  huddleRuleNamed :: Proxy "ex_units" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "ex_units" -> Proxy DijkstraEra -> Rule
forall era. Era era => Proxy "ex_units" -> Proxy era -> Rule
exUnitsRule

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

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

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

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

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

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

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

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

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

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

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

instance HuddleRule "policy_id" DijkstraEra where
  huddleRuleNamed :: Proxy "policy_id" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "policy_id"
pname Proxy DijkstraEra
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 DijkstraEra
p

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

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

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

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

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

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

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

instance HuddleGroup "script_require_guard" DijkstraEra where
  huddleGroupNamed :: Proxy "script_require_guard" -> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "script_require_guard" -> Proxy DijkstraEra -> GroupDef
forall era.
HuddleRule "credential" era =>
Proxy "script_require_guard" -> Proxy era -> GroupDef
scriptRequireGuardGroup

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

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

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

instance HuddleRule "relay" DijkstraEra where
  huddleRuleNamed :: Proxy "relay" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "relay" -> Proxy DijkstraEra -> 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" DijkstraEra where
  huddleRuleNamed :: Proxy "pool_metadata" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "pool_metadata" -> Proxy DijkstraEra -> Rule
forall era.
HuddleRule "url" era =>
Proxy "pool_metadata" -> Proxy era -> Rule
poolMetadataRule

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

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

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

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

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

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

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

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

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

instance HuddleGroup "delegation_to_stake_pool_and_drep_cert" DijkstraEra where
  huddleGroupNamed :: Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "delegation_to_stake_pool_and_drep_cert"
-> Proxy DijkstraEra -> 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

instance HuddleGroup "account_registration_delegation_to_stake_pool_cert" DijkstraEra where
  huddleGroupNamed :: Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "account_registration_delegation_to_stake_pool_cert"
-> Proxy DijkstraEra -> 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

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

instance HuddleGroup "account_registration_delegation_to_stake_pool_and_drep_cert" DijkstraEra where
  huddleGroupNamed :: Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "account_registration_delegation_to_stake_pool_and_drep_cert"
-> Proxy DijkstraEra -> 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

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

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

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

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

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

instance HuddleRule "certificate" DijkstraEra where
  huddleRuleNamed :: Proxy "certificate" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "certificate" -> Proxy DijkstraEra -> Rule
forall 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
dijkstraCertificateRule

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

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

instance HuddleRule "voting_procedures" DijkstraEra where
  huddleRuleNamed :: Proxy "voting_procedures" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "voting_procedures" -> Proxy DijkstraEra -> 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" DijkstraEra where
  huddleRuleNamed :: Proxy "constitution" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "constitution" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "anchor" era,
 HuddleRule "guardrails_script_hash" era) =>
Proxy "constitution" -> Proxy era -> Rule
constitutionRule

instance HuddleGroup "parameter_change_action" DijkstraEra where
  huddleGroupNamed :: Proxy "parameter_change_action" -> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "parameter_change_action" -> Proxy DijkstraEra -> 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

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

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

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

instance HuddleGroup "update_committee" DijkstraEra where
  huddleGroupNamed :: Proxy "update_committee" -> Proxy DijkstraEra -> GroupDef
huddleGroupNamed = Proxy "update_committee" -> Proxy DijkstraEra -> 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

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

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

instance HuddleRule "gov_action" DijkstraEra where
  huddleRuleNamed :: Proxy "gov_action" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "gov_action" -> Proxy DijkstraEra -> 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" DijkstraEra where
  huddleRuleNamed :: Proxy "proposal_procedure" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "proposal_procedure" -> Proxy DijkstraEra -> 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" DijkstraEra where
  huddleRuleNamed :: Proxy "proposal_procedures" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "proposal_procedures" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "proposal_procedure" era,
 HuddleRule1 "nonempty_oset" era) =>
Proxy "proposal_procedures" -> Proxy era -> Rule
proposalProceduresRule

instance HuddleRule "transaction_input" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction_input" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction_input"
pname Proxy DijkstraEra
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 DijkstraEra
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" DijkstraEra where
  huddleRuleNamed :: Proxy "required_signers" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "required_signers"
pname Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"addr_keyhash" Proxy DijkstraEra
p)

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

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

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

instance HuddleRule "direct_deposits" DijkstraEra where
  huddleRuleNamed :: Proxy "direct_deposits" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "direct_deposits" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "reward_account" era, HuddleRule "coin" era) =>
Proxy "direct_deposits" -> Proxy era -> Rule
directDepositsRule

instance HuddleRule "account_balance_intervals" DijkstraEra where
  huddleRuleNamed :: Proxy "account_balance_intervals" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "account_balance_intervals" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "credential" era,
 HuddleRule "account_balance_interval" era) =>
Proxy "account_balance_intervals" -> Proxy era -> Rule
accountBalanceIntervalsRule

instance HuddleRule "account_balance_interval" DijkstraEra where
  huddleRuleNamed :: Proxy "account_balance_interval" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "account_balance_interval" -> Proxy DijkstraEra -> Rule
forall era.
HuddleRule "coin" era =>
Proxy "account_balance_interval" -> Proxy era -> Rule
accountBalanceIntervalRule

instance HuddleRule "data" DijkstraEra where
  huddleRuleNamed :: Proxy "data" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "data" -> Proxy DijkstraEra -> Rule
forall era.
HuddleRule "plutus_data" era =>
Proxy "data" -> Proxy era -> Rule
dataRule

instance HuddleRule "datum_option" DijkstraEra where
  huddleRuleNamed :: Proxy "datum_option" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "datum_option" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "hash32" era, HuddleRule "data" era) =>
Proxy "datum_option" -> Proxy era -> Rule
datumOptionRule

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

instance HuddleRule "alonzo_transaction_output" DijkstraEra where
  huddleRuleNamed :: Proxy "alonzo_transaction_output" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "alonzo_transaction_output" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "address" era, HuddleRule "value" era,
 HuddleRule "hash32" era) =>
Proxy "alonzo_transaction_output" -> Proxy era -> Rule
alonzoTransactionOutputRule

instance HuddleRule "babbage_transaction_output" DijkstraEra where
  huddleRuleNamed :: Proxy "babbage_transaction_output" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "babbage_transaction_output" -> Proxy DijkstraEra -> 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" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction_output" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction_output"
pname Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
p

instance HuddleRule "sub_transaction_body" DijkstraEra where
  huddleRuleNamed :: Proxy "sub_transaction_body" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "sub_transaction_body" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "transaction_input" era,
 HuddleRule "transaction_output" era, HuddleRule "slot" era,
 HuddleRule "certificates" era, HuddleRule "withdrawals" era,
 HuddleRule "auxiliary_data_hash" era, HuddleRule "mint" era,
 HuddleRule "script_data_hash" era, HuddleRule "network_id" era,
 HuddleRule "voting_procedures" era,
 HuddleRule "proposal_procedures" era, HuddleRule "coin" era,
 HuddleRule "positive_coin" era, HuddleRule "guards" era,
 HuddleRule "required_top_level_guards" era,
 HuddleRule "direct_deposits" era,
 HuddleRule "account_balance_intervals" era, HuddleRule1 "set" era,
 HuddleRule1 "nonempty_set" era) =>
Proxy "sub_transaction_body" -> Proxy era -> Rule
subTransactionBodyRule

instance HuddleRule "sub_transaction" DijkstraEra where
  huddleRuleNamed :: Proxy "sub_transaction" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "sub_transaction" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "sub_transaction_body" era,
 HuddleRule "transaction_witness_set" era,
 HuddleRule "auxiliary_data" era) =>
Proxy "sub_transaction" -> Proxy era -> Rule
subTransactionRule

instance HuddleRule "sub_transactions" DijkstraEra where
  huddleRuleNamed :: Proxy "sub_transactions" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "sub_transactions" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "sub_transaction" era,
 HuddleRule1 "nonempty_oset" era) =>
Proxy "sub_transactions" -> Proxy era -> Rule
subTransactionsRule

instance HuddleRule "guards" DijkstraEra where
  huddleRuleNamed :: Proxy "guards" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "guards" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "addr_keyhash" era, HuddleRule "credential" era,
 HuddleRule1 "nonempty_set" era, HuddleRule1 "nonempty_oset" era) =>
Proxy "guards" -> Proxy era -> Rule
guardsRule

instance HuddleRule "required_top_level_guards" DijkstraEra where
  huddleRuleNamed :: Proxy "required_top_level_guards" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "required_top_level_guards" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "credential" era, HuddleRule "plutus_data" era) =>
Proxy "required_top_level_guards" -> Proxy era -> Rule
requiredTopLevelGuardsRule

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

instance HuddleRule "redeemers" DijkstraEra where
  huddleRuleNamed :: Proxy "redeemers" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "redeemers"
pname Proxy DijkstraEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str| Dijkstra uses map format only for redeemers.
          | The flat array format has been removed.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "redeemers"
pname
        Proxy "redeemers" -> 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
<+ 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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p
                ]
          ]

instance HuddleRule "script_data_hash" DijkstraEra where
  huddleRuleNamed :: Proxy "script_data_hash" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "script_data_hash"
pname Proxy DijkstraEra
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 DijkstraEra -> Rule
forall era.
Era era =>
Proxy "script_data_hash" -> Proxy era -> Rule
scriptDataHashRule Proxy "script_data_hash"
pname Proxy DijkstraEra
p

instance HuddleRule "transaction" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction"
pname Proxy DijkstraEra
p =
    Proxy "transaction"
pname
      Proxy "transaction" -> Choice 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 DijkstraEra
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 DijkstraEra
p
        , Literal -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Literal -> Item ArrayChoice) -> Literal -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ (Bool -> Literal
bool Bool
True)
        , 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 DijkstraEra
p Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil)
        ]
      ArrayChoice -> ArrayChoice -> Choice ArrayChoice
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ 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 DijkstraEra
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 DijkstraEra
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 @"auxiliary_data" Proxy DijkstraEra
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" DijkstraEra where
  huddleRuleNamed :: Proxy "ex_unit_prices" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "ex_unit_prices"
pname Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
p
        ]

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

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

instance HuddleRule "protocol_param_update" DijkstraEra where
  huddleRuleNamed :: Proxy "protocol_param_update" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "protocol_param_update"
pname Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"minfee refScript coins per byte"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
34 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 refScript size per block"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
35 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 refScript size per tx"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
36 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_word32" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"refScript cost stride"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
37 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_interval" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"refScript cost multiplier"
        ]

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

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

instance HuddleRule "header_body" DijkstraEra where
  huddleRuleNamed :: Proxy "header_body" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "header_body" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "operational_cert" era,
 HuddleRule "protocol_version" era) =>
Proxy "header_body" -> Proxy era -> Rule
babbageHeaderBodyRule

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

instance HuddleRule "block" DijkstraEra where
  huddleRuleNamed :: Proxy "block" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "block"
pname Proxy DijkstraEra
p =
    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 DijkstraEra
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 @"block_body" Proxy DijkstraEra
p
        ]

instance HuddleRule "peras_certificate" DijkstraEra where
  huddleRuleNamed :: Proxy "peras_certificate" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "peras_certificate"
pname Proxy DijkstraEra
_era = Proxy "peras_certificate"
pname Proxy "peras_certificate" -> Choice Type2 -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Value ByteString
VBytes Value ByteString -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil

instance HuddleRule "invalid_transactions" DijkstraEra where
  huddleRuleNamed :: Proxy "invalid_transactions" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "invalid_transactions"
pname Proxy DijkstraEra
era = Proxy "invalid_transactions"
pname Proxy "invalid_transactions" -> 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 DijkstraEra
era (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_index" Proxy DijkstraEra
era)

instance HuddleRule "block_body" DijkstraEra where
  huddleRuleNamed :: Proxy "block_body" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "block_body"
pname Proxy DijkstraEra
era =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str| Note that every transaction_index must be strictly smaller than the length of transaction_bodies
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ CBORGen RuleTerm -> Rule -> Rule
forall a. HasGenerator a => CBORGen RuleTerm -> a -> a
withCBORGen CBORGen RuleTerm
blockBodyGen
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "block_body"
pname
        Proxy "block_body" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
          [ Key
"invalid_transactions" 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 @"invalid_transactions" Proxy DijkstraEra
era Rule -> Value Void -> Choice Type2
forall a c b.
(IsChoosable a c, IsChoosable b c) =>
a -> b -> Choice c
/ Value Void
VNil
          , Key
"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" Proxy DijkstraEra
era)]
          , Key
"peras_certificate" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"peras_certificate" Proxy DijkstraEra
era
          ]

blockBodyGen :: CBORGen RuleTerm
blockBodyGen :: CBORGen RuleTerm
blockBodyGen = do
  numTxs <- Gen Int -> CBORGen Int
forall a. Gen a -> CBORGen a
forall (g :: * -> *) a. MonadGen g => Gen a -> g a
liftGen (Gen Int -> CBORGen Int)
-> ((Int -> Gen Int) -> Gen Int) -> (Int -> Gen Int) -> CBORGen Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Gen Int) -> Gen Int
forall a. (Int -> Gen a) -> Gen a
QC.sized ((Int -> Gen Int) -> CBORGen Int)
-> (Int -> Gen Int) -> CBORGen Int
forall a b. (a -> b) -> a -> b
$ \Int
s -> (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0 :: Int, Int
s)
  txs <-
    mapM
      (\Int
i -> (AntiGen Term -> AntiGen Term) -> CBORGen Term -> CBORGen Term
forall a b. (AntiGen a -> AntiGen b) -> CBORGen a -> CBORGen b
withAntiGen (Text -> AntiGen Term -> AntiGen Term
forall a. Text -> AntiGen a -> AntiGen a
withAnnotation (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show Int
i)) (CBORGen Term -> CBORGen Term) -> CBORGen Term -> CBORGen Term
forall a b. (a -> b) -> a -> b
$ HasCallStack => Name -> CBORGen Term
Name -> CBORGen Term
generateFromName Name
"transaction")
      [0 .. numTxs - 1]
  invalidIxIxs <-
    if numTxs == 0
      then pure []
      else do
        n <-
          liftAntiGen $
            choose (0, numTxs) |! choose (numTxs + 1, 2 * numTxs)
        txIndices <- liftGen $ shuffle [0 .. toInteger numTxs - 1]
        -- We need this so that a zapped `n` still produces indices
        txIndicesOverflow <- liftGen $ shuffle txIndices
        let
          txIndicesWithOverflow = Int -> [Integer] -> [Integer]
forall a. Int -> [a] -> [a]
take Int
n ([Integer] -> [Integer]) -> [Integer] -> [Integer]
forall a b. (a -> b) -> a -> b
$ [Integer]
txIndices [Integer] -> [Integer] -> [Integer]
forall a. Semigroup a => a -> a -> a
<> [Integer]
txIndicesOverflow
          faultyIndex Int
pos Integer
i =
            Text -> AntiGen Integer -> AntiGen Integer
forall a. Text -> AntiGen a -> AntiGen a
withAnnotation (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show Int
pos) (AntiGen Integer -> AntiGen Integer)
-> AntiGen Integer -> AntiGen Integer
forall a b. (a -> b) -> a -> b
$
              Integer -> Gen Integer
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
i
                Gen Integer -> Gen Integer -> AntiGen Integer
forall a. Gen a -> Gen a -> AntiGen a
|! (Integer, Integer) -> Gen Integer
forall a. Random a => (a, a) -> Gen a
choose (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
numTxs Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1, Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word16 -> Integer) -> Word16 -> Integer
forall a b. (a -> b) -> a -> b
$ forall a. Bounded a => a
maxBound @Word16)
        liftAntiGen $
          withAnnotation "invalid_transactions" $
            zipWithM faultyIndex [0 :: Int ..] txIndicesWithOverflow
  invalidTxIxsTerm <- genArrayTerm $ TInteger . toInteger <$> invalidIxIxs
  txsTerm <- withAntiGen (withAnnotation "transactions") $ genArrayTerm txs
  perasCertTerm <- generateFromName "peras_certificate"
  SingleTerm <$> liftGen (genArrayTerm [invalidTxIxsTerm, txsTerm, perasCertTerm])

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

instance HuddleRule "auxiliary_data_array" DijkstraEra where
  huddleRuleNamed :: Proxy "auxiliary_data_array" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "auxiliary_data_array" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "auxiliary_scripts" era, HuddleRule "metadatum" era) =>
Proxy "auxiliary_data_array" -> Proxy era -> Rule
auxiliaryDataArrayRule

instance HuddleRule "transaction_body" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction_body" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction_body"
pname Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy DijkstraEra
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 @"guards" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"guards (replaces required_signers)"
        , 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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_input" Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"donation"
        , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
23 Key -> Rule -> MapEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"sub_transactions" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"sub-transactions (NEW)"
        , 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 @"direct_deposits" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"direct deposits"
        , 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 @"account_balance_intervals" Proxy DijkstraEra
p) MapEntry -> Comment -> MapEntry
forall a. HasComment a => a -> Comment -> a
//- Comment
"account balance intervals"
        ]

instance HuddleRule "transaction_witness_set" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction_witness_set" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction_witness_set"
pname Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vkeywitness" Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"native_script" Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"bootstrap_witness" Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v1_script" Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_data" Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v2_script" Proxy DijkstraEra
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 DijkstraEra
p (forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"plutus_v3_script" Proxy DijkstraEra
p)
        -- TODO: Add plutus_v4_script at index 8 once AlonzoTxWitsRaw encoder/decoder supports it
        ]

instance HuddleRule "native_script" DijkstraEra where
  huddleRuleNamed :: Proxy "native_script" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "native_script" -> Proxy DijkstraEra -> 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,
 HuddleGroup "script_require_guard" era) =>
Proxy "native_script" -> Proxy era -> Rule
dijkstraNativeScriptRule

instance HuddleRule "script" DijkstraEra where
  huddleRuleNamed :: Proxy "script" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "script" -> Proxy DijkstraEra -> Rule
forall era.
(HuddleRule "native_script" era, HuddleRule "plutus_v1_script" era,
 HuddleRule "plutus_v2_script" era,
 HuddleRule "plutus_v3_script" era,
 HuddleRule "plutus_v4_script" era) =>
Proxy "script" -> Proxy era -> Rule
dijkstraScriptRule

instance HuddleRule "redeemer_tag" DijkstraEra where
  huddleRuleNamed :: Proxy "redeemer_tag" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "redeemer_tag"
pname Proxy DijkstraEra
_ = Proxy "redeemer_tag" -> Rule
dijkstraRedeemerTagRule Proxy "redeemer_tag"
pname

instance Era era => HuddleRule "plutus_v4_script" era where
  huddleRuleNamed :: Proxy "plutus_v4_script" -> Proxy era -> Rule
huddleRuleNamed Proxy "plutus_v4_script"
pname Proxy era
_ =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str| Dijkstra introduces Plutus V4.
          |]
      (Rule -> Rule) -> (Rule -> Rule) -> Rule -> Rule
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CBORGen RuleTerm -> Rule -> Rule
forall a. HasGenerator a => CBORGen RuleTerm -> a -> a
withCBORGen CBORGen RuleTerm
forall (m :: * -> *). MonadGen m => m RuleTerm
plutusScriptGen
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "plutus_v4_script"
pname Proxy "plutus_v4_script" -> Value ByteString -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= Value ByteString
VBytes

instance HuddleRule "auxiliary_data" DijkstraEra where
  huddleRuleNamed :: Proxy "auxiliary_data" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "auxiliary_data"
pname Proxy DijkstraEra
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
          |      Dijkstra adds plutus_v4_script support at index 5
          |]
      (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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p

instance HuddleRule "auxiliary_data_map" DijkstraEra where
  huddleRuleNamed :: Proxy "auxiliary_data_map" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "auxiliary_data_map"
pname Proxy DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
p)])
            , MapEntry -> MapEntry
forall a. CanQuantify a => a -> a
opt (Word64 -> Key
idx Word64
5 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_v4_script" Proxy DijkstraEra
p)])
            ]
        )

instance HuddleRule "language" DijkstraEra where
  huddleRuleNamed :: Proxy "language" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "language"
pname Proxy DijkstraEra
_ =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str| 0: Plutus v1
          | 1: Plutus v2
          | 2: Plutus v3
          | 3: Plutus v4 (NEW)
          |]
      (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
3 :: Integer)

instance HuddleRule "cost_models" DijkstraEra where
  huddleRuleNamed :: Proxy "cost_models" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "cost_models"
pname Proxy DijkstraEra
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)
          | Plutus v4: TBD integers are used (NEW)
          |
          | Any 8-bit unsigned number can be used as a key.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ CBORGen RuleTerm -> Rule -> Rule
forall a. HasGenerator a => CBORGen RuleTerm -> a -> a
withCBORGen (forall era. Era era => CBORGen RuleTerm
conwayCostModelsGenerator @DijkstraEra)
      (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 DijkstraEra
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 DijkstraEra
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 DijkstraEra
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 -> 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 DijkstraEra
p)]
          , Word64
0 Word64 -> MapEntry -> MapEntry
forall a. CanQuantify a => Word64 -> a -> a
<+ Ranged -> Key
forall r. IsType0 r => r -> Key
asKey ((Integer
4 :: 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 DijkstraEra
p)]
          ]

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

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

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

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

instance HuddleRule "metadatum" DijkstraEra where
  huddleRuleNamed :: Proxy "metadatum" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "metadatum" -> Proxy DijkstraEra -> Rule
forall era. Era era => Proxy "metadatum" -> Proxy era -> Rule
allegraMetadatumRule