{-# 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,
  MonadGen (choose, liftGen),
  Name (..),
  RuleTerm (..),
  genArrayTerm,
  genRule,
  generateFromName,
  liftAntiGen,
  scale,
  shuffle,
  unwrapSingle,
  validateArrayTerm,
  validateFromName,
  withAntiGen,
 )
import Cardano.Ledger.Huddle.Gen qualified as Gen
import Codec.CBOR.Term (Term (..))
import Control.Monad (unless, zipWithM)
import Data.Foldable (traverse_)
import Data.List (nub)
import Data.Maybe (mapMaybe)
import Data.Proxy (Proxy (..))
import Data.Text ()
import Data.Text qualified as T
import Data.Word (Word16, Word64)
import Test.AntiGen (withAnnotation, (|!))
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 @"transaction_mempool" (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 =
  CBORGen RuleTerm -> Rule -> Rule
forall a. HasGenerator a => CBORGen RuleTerm -> a -> a
withCBORGen CBORGen RuleTerm
generate
    (Rule -> Rule) -> (Rule -> Rule) -> Rule -> Rule
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TermValidator -> Rule -> Rule
forall a. HasValidator a => TermValidator -> a -> a
withValidator TermValidator
validator
    (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ 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)
  where
    -- The Haskell representation is @OMap TxId (Tx SubTx era)@: dedup is by
    -- body hash, so both the generator and the validator must work in terms
    -- of body equality, not full-element equality (which is what the generic
    -- @nonempty_oset@ validator checks).
    validator :: TermValidator
validator RuleTerm
term = do
      term_ <- RuleTerm -> Validator Term
unwrapSingle RuleTerm
term
      let
        bodyOf (TList (Term
b : [Term]
_)) = Term -> Maybe Term
forall a. a -> Maybe a
Just Term
b
        bodyOf (TListI (Term
b : [Term]
_)) = Term -> Maybe Term
forall a. a -> Maybe a
Just Term
b
        bodyOf Term
_ = Maybe Term
forall a. Maybe a
Nothing
        validateInner Term
t = do
          elems <- Term -> Validator [Term]
validateArrayTerm Term
t
          let bodies = (Term -> Maybe Term) -> [Term] -> [Term]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Term -> Maybe Term
bodyOf [Term]
elems
          unless (length bodies == length (nub bodies)) $
            fail "duplicate sub_transaction bodies"
          traverse_ (validateFromName (Name "sub_transaction")) elems
      case term_ of
        TTagged Word64
258 Term
x -> Term -> Validator ()
validateInner Term
x
        Term
x -> Term -> Validator ()
validateInner Term
x
    generate :: CBORGen RuleTerm
generate = do
      nElems <- (Int -> CBORGen Int) -> CBORGen Int
forall a. (Int -> CBORGen a) -> CBORGen a
forall (g :: * -> *) a. MonadGen g => (Int -> g a) -> g a
Gen.sized ((Int -> CBORGen Int) -> CBORGen Int)
-> (Int -> CBORGen Int) -> CBORGen Int
forall a b. (a -> b) -> a -> b
$ \Int
sz -> (Int, Int) -> CBORGen Int
forall a. Random a => (a, a) -> CBORGen a
forall (g :: * -> *) a. (MonadGen g, Random a) => (a, a) -> g a
choose (Int
1, Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 (Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
sz Int
3))
      let subTxGen = (Int -> Int) -> CBORGen Term -> CBORGen Term
forall (m :: * -> *) a. MonadGen m => (Int -> Int) -> m a -> m a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (CBORGen Term -> CBORGen Term) -> CBORGen Term -> CBORGen Term
forall a b. (a -> b) -> a -> b
$ forall (rule :: Symbol) era. HuddleRule rule era => CBORGen Term
genRule @"sub_transaction" @era
      txs <- uniqueByBody nElems subTxGen
      elemsArr <- genArrayTerm txs
      tagged <- Gen.arbitrary
      pure $ SingleTerm $ if tagged then TTagged 258 elemsArr else elemsArr
    uniqueByBody :: Int -> CBORGen Term -> CBORGen [Term]
    uniqueByBody :: Int -> CBORGen Term -> CBORGen [Term]
uniqueByBody Int
n CBORGen Term
gen = [Term] -> Int -> CBORGen [Term]
loop [] Int
n
      where
        triesPerElement :: Int
triesPerElement = Int
20 :: Int
        loop :: [Term] -> Int -> CBORGen [Term]
loop [Term]
acc Int
0 = [Term] -> CBORGen [Term]
forall a. a -> CBORGen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Term]
acc
        loop [Term]
acc Int
k = Int -> [Term] -> Int -> CBORGen [Term]
attempt Int
triesPerElement [Term]
acc Int
k
        attempt :: Int -> [Term] -> Int -> CBORGen [Term]
attempt Int
0 [Term]
acc Int
_ = [Term] -> CBORGen [Term]
forall a. a -> CBORGen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Term]
acc
        attempt Int
tries [Term]
acc Int
k = do
          tx <- CBORGen Term
gen
          case bodyOf tx of
            Just Term
b | Term
b Term -> [Term] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` (Term -> Maybe Term) -> [Term] -> [Term]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Term -> Maybe Term
bodyOf [Term]
acc -> [Term] -> Int -> CBORGen [Term]
loop (Term
tx Term -> [Term] -> [Term]
forall a. a -> [a] -> [a]
: [Term]
acc) (Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            Maybe Term
_ -> Int -> [Term] -> Int -> CBORGen [Term]
attempt (Int
tries Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Term]
acc Int
k
        bodyOf :: Term -> Maybe Term
bodyOf (TList (Term
b : [Term]
_)) = Term -> Maybe Term
forall a. a -> Maybe a
Just Term
b
        bodyOf (TListI (Term
b : [Term]
_)) = Term -> Maybe Term
forall a. a -> Maybe a
Just Term
b
        bodyOf Term
_ = Maybe Term
forall a. Maybe a
Nothing

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

dijkstraBootstrapWitnessRule :: Proxy "bootstrap_witness" -> Proxy DijkstraEra -> Rule
dijkstraBootstrapWitnessRule :: Proxy "bootstrap_witness" -> Proxy DijkstraEra -> Rule
dijkstraBootstrapWitnessRule Proxy "bootstrap_witness"
pname Proxy DijkstraEra
p =
  Proxy "bootstrap_witness"
pname
    Proxy "bootstrap_witness" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
      [ Key
"public_key" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"vkey" Proxy DijkstraEra
p
      , Key
"signature" Key -> Rule -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"signature" Proxy DijkstraEra
p
      , Key
"chain_code" Key -> Constrained -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value ByteString
VBytes Value ByteString -> Word64 -> Constrained
forall c a s.
(IsSizeable a, IsSize s, IsConstrainable c a) =>
c -> s -> Constrained
`sized` (Word64
32 :: Word64)
      , Key
"attributes" Key -> Value ByteString -> ArrayEntry
forall a me. (IsType0 a, IsEntryLike me) => Key -> a -> me
==> Value ByteString
VBytes
      ]

instance HuddleRule "bootstrap_witness" DijkstraEra where
  huddleRuleNamed :: Proxy "bootstrap_witness" -> Proxy DijkstraEra -> Rule
huddleRuleNamed = Proxy "bootstrap_witness" -> Proxy DijkstraEra -> Rule
dijkstraBootstrapWitnessRule

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_mempool" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction_mempool" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction_mempool"
pname Proxy DijkstraEra
p =
    Comment -> Rule -> Rule
forall a. HasComment a => Comment -> a -> a
comment
      Comment
[str| In Dijkstra we're deprecating the `is_valid` flag, but for backwards
          | compatibility we still allow this flag to be present in incoming 
          | transactions. Once the transaction is added to a block, the flag will
          | be stripped, so the `is_valid` flag cannot appear in transactions that
          | are in a block.
          |
          | In the next era `is_valid` flags will not be allowed even in mempool 
          | transactions, so it's strongly recommended to encode transactions
          | according to the `transaction` rule.
          |]
      (Rule -> Rule) -> Rule -> Rule
forall a b. (a -> b) -> a -> b
$ Proxy "transaction_mempool"
pname
        Proxy "transaction_mempool" -> 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 @"transaction" Proxy DijkstraEra
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 @"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)
          ]

instance HuddleRule "transaction" DijkstraEra where
  huddleRuleNamed :: Proxy "transaction" -> Proxy DijkstraEra -> Rule
huddleRuleNamed Proxy "transaction"
pname Proxy DijkstraEra
p =
    Proxy "transaction"
pname
      Proxy "transaction" -> ArrayChoice -> Rule
forall (name :: Symbol) t.
(KnownSymbol name, IsType0 t) =>
Proxy name -> t -> Rule
=.= ArrayChoice -> ArrayChoice
arr
        [ Rule -> Item ArrayChoice
forall a e. (IsType0 a, IsGroupOrArrayEntry e) => a -> e
a (Rule -> Item ArrayChoice) -> Rule -> Item ArrayChoice
forall a b. (a -> b) -> a -> b
$ forall (name :: Symbol) era.
HuddleRule name era =>
Proxy era -> Rule
huddleRule @"transaction_body" Proxy 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
forall (g :: * -> *) a. MonadGen g => (Int -> g a) -> g a
Gen.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
forall (g :: * -> *) a. (MonadGen g, Random a) => (a, a) -> g a
choose (Int
0 :: Int, Int
s Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
15)
  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) -> CBORGen Term -> CBORGen Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int) -> CBORGen Term -> CBORGen Term
forall (m :: * -> *) a. MonadGen m => (Int -> Int) -> m a -> m a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 Int
numTxs) (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
forall (g :: * -> *) a. (MonadGen g, Random a) => (a, a) -> g 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 <-
    if null invalidIxIxs
      then pure TNull
      else genArrayTerm $ TInteger . toInteger <$> invalidIxIxs
  txsTerm <- withAntiGen (withAnnotation "transactions") $ genArrayTerm txs
  perasCertTerm <- generateFromName "peras_certificate"
  SingleTerm <$> 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