{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-deprecations #-}

module Test.Gen.Cardano.Api.Typed
  ( genFeaturedInEra
  , genMaybeFeaturedInEra

    -- * Byron
  , genAddressInEraByron
  , genAddressByron
  , genTxBodyByron
  , genTxByron
  , genTxOutByron
  , genWitnessesByron
  , genAddressInEra
  , genAddressShelley
  , genCertificate
  , genCostModel
  , genCostModels
  , genMaybePraosNonce
  , genPraosNonce
  , genValidProtocolParameters
  , genProtocolParameters
  , genValueNestedRep
  , genValueNestedBundle
  , genByronKeyWitness
  , genCardanoKeyWitness
  , genShelleyKeyWitness
  , genTxId
  , genTxIn
  , genTxOutTxContext
  , genTxOutUTxOContext
  , genUTxO

    -- * Scripts
  , genHashableScriptData
  , genReferenceScript
  , genScript
  , genValidScript
  , genSimpleScript
  , genPlutusScript
  , genPlutusV1Script
  , genPlutusV2Script
  , genPlutusV3Script
  , genScriptInAnyLang
  , genScriptInEra
  , genScriptHash
  , genScriptData
  , genScriptDataSchema
  , genScriptValidity
  , genAssetName
  , genAssetId
  , genEpochNo
  , genExecutionUnitPrices
  , genExecutionUnits
  , genHashScriptData
  , genKESPeriod
  , genNat
  , genNetworkId
  , genNetworkMagic
  , genOperationalCertificate
  , genOperationalCertificateIssueCounter
  , genOperationalCertificateWithCounter
  , genPaymentCredential
  , genPolicyId
  , genQuantity
  , genRationalInt64
  , genSeed
  , genShelleyBootstrapWitness
  , genShelleyHash
  , genShelleyWitness
  , genShelleyWitnessSigningKey
  , genSignedQuantity
  , genSignedNonZeroQuantity
  , genSigningKey
  , genSlotNo
  , genStakeAddress
  , genStakeAddressReference
  , genStakeCredential
  , genTtl
  , genTx
  , genTxAuxScripts
  , genTxBody
  , genTxBodyContent
  , genValidTxBody
  , genTxCertificates
  , genTxFee
  , genTxIndex
  , genTxInsCollateral
  , genTxInsReference
  , genTxMetadataInEra
  , genTxMintValue
  , genLovelace
  , genPositiveLovelace
  , genValue
  , genValueDefault
  , genValueForRole
  , genVerificationKey
  , genVerificationKeyHash
  , genUpdateProposal
  , genProtocolParametersUpdate
  , genTxOutDatumHashTxContext
  , genTxOutDatumHashUTxOContext
  , genTxOutValue
  , genTxReturnCollateral
  , genTxScriptValidity
  , genTxTotalCollateral
  , genTxUpdateProposal
  , genTxValidityLowerBound
  , genTxValidityUpperBound
  , genTxWithdrawals
  , genUnsignedQuantity
  , genPositiveQuantity
  , genValueForMinting
  , genValueForTxOut
  , genWitnesses
  , genWitnessNetworkIdOrByronAddress
  , genRational
  , genGovernancePoll
  , genGovernancePollAnswer
  , genProposals
  , genProposal
  , genVotingProcedures
  , genSimpleScriptWithoutEmptyAnys
  )
where

import           Cardano.Api hiding (txIns)
import qualified Cardano.Api as Api
import           Cardano.Api.Byron (KeyWitness (ByronKeyWitness),
                   WitnessNetworkIdOrByronAddress (..))
import qualified Cardano.Api.Byron as Byron
import           Cardano.Api.Internal.Error
import qualified Cardano.Api.Ledger as L
import qualified Cardano.Api.Ledger.Lens as A
import           Cardano.Api.Internal.Script (scriptInEraToRefScript)
import           Cardano.Api.Shelley
import qualified Cardano.Api.Shelley as ShelleyApi

import qualified Cardano.Binary as CBOR
import qualified Cardano.Crypto.Hash as Crypto
import qualified Cardano.Crypto.Hash.Class as CRYPTO
import qualified Cardano.Crypto.Seed as Crypto
import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
import qualified Cardano.Ledger.BaseTypes as Ledger
import qualified Cardano.Ledger.Core as Ledger
import           Cardano.Ledger.SafeHash (unsafeMakeSafeHash)

import           Control.Applicative (Alternative (..), optional)
import           Control.Monad
import           Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Short as SBS
import           Data.Coerce
import           Data.Int (Int64)
import           Data.Maybe
import qualified Data.ByteString.Base16 as Base16
import           Data.Ratio (Ratio, (%))
import           Data.String
import Test.Gen.Cardano.Api.Hardcoded
import           Data.Word (Word16, Word32, Word64)
import           GHC.Exts (IsList (..))
import           GHC.Stack
import           Numeric.Natural (Natural)

import           Test.Gen.Cardano.Api.Era
import           Test.Gen.Cardano.Api.Metadata (genTxMetadata)

import           Test.Cardano.Chain.UTxO.Gen (genVKWitness)
import           Test.Cardano.Crypto.Gen (genProtocolMagicId)
import           Test.Cardano.Ledger.Conway.Arbitrary ()
import           Test.Cardano.Ledger.Core.Arbitrary ()

import           Hedgehog (Gen, MonadGen, Range)
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Gen.QuickCheck as Q
import qualified Hedgehog.Range as Range


genAddressByron :: Gen (Address ByronAddr)
genAddressByron :: Gen (Address ByronAddr)
genAddressByron =
  NetworkId -> VerificationKey ByronKey -> Address ByronAddr
makeByronAddress
    (NetworkId -> VerificationKey ByronKey -> Address ByronAddr)
-> GenT Identity NetworkId
-> GenT Identity (VerificationKey ByronKey -> Address ByronAddr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity NetworkId
genNetworkId
    GenT Identity (VerificationKey ByronKey -> Address ByronAddr)
-> GenT Identity (VerificationKey ByronKey)
-> Gen (Address ByronAddr)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AsType ByronKey -> GenT Identity (VerificationKey ByronKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType ByronKey
AsByronKey

genAddressShelley :: Gen (Address ShelleyAddr)
genAddressShelley :: Gen (Address ShelleyAddr)
genAddressShelley =
  NetworkId
-> PaymentCredential
-> StakeAddressReference
-> Address ShelleyAddr
makeShelleyAddress
    (NetworkId
 -> PaymentCredential
 -> StakeAddressReference
 -> Address ShelleyAddr)
-> GenT Identity NetworkId
-> GenT
     Identity
     (PaymentCredential -> StakeAddressReference -> Address ShelleyAddr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity NetworkId
genNetworkId
    GenT
  Identity
  (PaymentCredential -> StakeAddressReference -> Address ShelleyAddr)
-> GenT Identity PaymentCredential
-> GenT Identity (StakeAddressReference -> Address ShelleyAddr)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity PaymentCredential
genPaymentCredential
    GenT Identity (StakeAddressReference -> Address ShelleyAddr)
-> GenT Identity StakeAddressReference -> Gen (Address ShelleyAddr)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity StakeAddressReference
genStakeAddressReference

genAddressInEra :: ShelleyBasedEra era -> Gen (AddressInEra era)
genAddressInEra :: forall era. ShelleyBasedEra era -> Gen (AddressInEra era)
genAddressInEra ShelleyBasedEra era
sbe = ShelleyBasedEra era -> Address ShelleyAddr -> AddressInEra era
forall era.
ShelleyBasedEra era -> Address ShelleyAddr -> AddressInEra era
shelleyAddressInEra ShelleyBasedEra era
sbe (Address ShelleyAddr -> AddressInEra era)
-> Gen (Address ShelleyAddr) -> GenT Identity (AddressInEra era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Address ShelleyAddr)
genAddressShelley

_genAddressInEraByron :: Gen (AddressInEra era)
_genAddressInEraByron :: forall era. Gen (AddressInEra era)
_genAddressInEraByron = Address ByronAddr -> AddressInEra era
forall era. Address ByronAddr -> AddressInEra era
byronAddressInEra (Address ByronAddr -> AddressInEra era)
-> Gen (Address ByronAddr) -> GenT Identity (AddressInEra era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Address ByronAddr)
genAddressByron

genKESPeriod :: Gen KESPeriod
genKESPeriod :: Gen KESPeriod
genKESPeriod = Word -> KESPeriod
KESPeriod (Word -> KESPeriod) -> GenT Identity Word -> Gen KESPeriod
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word -> GenT Identity Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word Range Word
forall a. (Bounded a, Num a) => Range a
Range.constantBounded

genLovelace :: Gen L.Coin
genLovelace :: Gen Coin
genLovelace = Integer -> Coin
L.Coin (Integer -> Coin) -> GenT Identity Integer -> Gen Coin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Integer -> Integer -> Range Integer
forall a. Integral a => a -> a -> Range a
Range.linear Integer
0 Integer
5000)

genPositiveLovelace :: Gen L.Coin
genPositiveLovelace :: Gen Coin
genPositiveLovelace = Integer -> Coin
L.Coin (Integer -> Coin) -> GenT Identity Integer -> Gen Coin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Integer -> Integer -> Range Integer
forall a. Integral a => a -> a -> Range a
Range.linear Integer
1 Integer
5000)

----------------------------------------------------------------------------
-- SimpleScript generators
--

-- This generator does not generate the deprecated double encoded plutus scripts
genValidScript :: ScriptLanguage lang -> Gen (Script lang)
genValidScript :: forall lang. ScriptLanguage lang -> Gen (Script lang)
genValidScript ScriptLanguage lang
SimpleScriptLanguage =
  SimpleScript -> Script lang
SimpleScript -> Script SimpleScript'
SimpleScript (SimpleScript -> Script lang)
-> GenT Identity SimpleScript -> GenT Identity (Script lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SimpleScript
genSimpleScript
genValidScript (PlutusScriptLanguage PlutusScriptVersion lang
lang) =
  PlutusScriptVersion lang -> PlutusScript lang -> Script lang
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion lang
lang (PlutusScript lang -> Script lang)
-> GenT Identity (PlutusScript lang) -> GenT Identity (Script lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PlutusScriptVersion lang -> GenT Identity (PlutusScript lang)
forall lang. PlutusScriptVersion lang -> Gen (PlutusScript lang)
genValidPlutusScript PlutusScriptVersion lang
lang

-- This generator will also generate the deprecated double encoded plutus scripts
genScript :: ScriptLanguage lang -> Gen (Script lang)
genScript :: forall lang. ScriptLanguage lang -> Gen (Script lang)
genScript ScriptLanguage lang
SimpleScriptLanguage =
  SimpleScript -> Script lang
SimpleScript -> Script SimpleScript'
SimpleScript (SimpleScript -> Script lang)
-> GenT Identity SimpleScript -> GenT Identity (Script lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SimpleScript
genSimpleScript
genScript (PlutusScriptLanguage PlutusScriptVersion lang
lang) =
  PlutusScriptVersion lang -> PlutusScript lang -> Script lang
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion lang
lang (PlutusScript lang -> Script lang)
-> GenT Identity (PlutusScript lang) -> GenT Identity (Script lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PlutusScriptVersion lang -> GenT Identity (PlutusScript lang)
forall lang. PlutusScriptVersion lang -> Gen (PlutusScript lang)
genPlutusScript PlutusScriptVersion lang
lang

genSimpleScriptWithoutEmptyAnys :: Gen SimpleScript
genSimpleScriptWithoutEmptyAnys :: GenT Identity SimpleScript
genSimpleScriptWithoutEmptyAnys = Bool -> GenT Identity SimpleScript
genRandomSimpleScript Bool
False

genSimpleScript :: Gen SimpleScript
genSimpleScript :: GenT Identity SimpleScript
genSimpleScript = Bool -> GenT Identity SimpleScript
genRandomSimpleScript Bool
True

-- | We include a @hasEmptyAnys@ parameter to control whether we allow empty
-- 'RequireAnyOf' constructors. This is because an empty 'RequireAnyOf',
-- same as a 'RequireMOf' with less than M elements, is not satisfiable.
-- In the function @satisfyScript@ in the "Test.Cardano.Api.TxBody" module,
-- we look for a set of witnesses that satisfy a script, and we can't do it
-- if the script consists of an empty 'RequireAnyOf' constructor.
-- Note that this is not the only way to make an unsatisfiable script,
-- but this is the one that affects the @satisfyScript@ function, because
-- it is only concerned with the witnesses, and not with the times.
genRandomSimpleScript :: Bool -> Gen SimpleScript
genRandomSimpleScript :: Bool -> GenT Identity SimpleScript
genRandomSimpleScript Bool
hasEmptyAnys =
  GenT Identity SimpleScript
genTerm
 where
  genTerm :: GenT Identity SimpleScript
genTerm = ([GenT Identity SimpleScript] -> GenT Identity SimpleScript)
-> [GenT Identity SimpleScript]
-> [GenT Identity SimpleScript]
-> GenT Identity SimpleScript
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive [GenT Identity SimpleScript] -> GenT Identity SimpleScript
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice [GenT Identity SimpleScript]
nonRecursive [GenT Identity SimpleScript]
recursive

  -- Non-recursive generators
  nonRecursive :: [GenT Identity SimpleScript]
nonRecursive =
    [ Hash PaymentKey -> SimpleScript
RequireSignature (Hash PaymentKey -> SimpleScript)
-> (VerificationKey PaymentKey -> Hash PaymentKey)
-> VerificationKey PaymentKey
-> SimpleScript
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VerificationKey PaymentKey -> Hash PaymentKey
forall keyrole.
Key keyrole =>
VerificationKey keyrole -> Hash keyrole
verificationKeyHash (VerificationKey PaymentKey -> SimpleScript)
-> GenT Identity (VerificationKey PaymentKey)
-> GenT Identity SimpleScript
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType PaymentKey -> GenT Identity (VerificationKey PaymentKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType PaymentKey
AsPaymentKey
    , SlotNo -> SimpleScript
RequireTimeBefore (SlotNo -> SimpleScript)
-> GenT Identity SlotNo -> GenT Identity SimpleScript
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SlotNo
genSlotNo
    , SlotNo -> SimpleScript
RequireTimeAfter (SlotNo -> SimpleScript)
-> GenT Identity SlotNo -> GenT Identity SimpleScript
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SlotNo
genSlotNo
    ]

  -- Recursive generators
  recursive :: [GenT Identity SimpleScript]
recursive =
    [ [SimpleScript] -> SimpleScript
RequireAllOf ([SimpleScript] -> SimpleScript)
-> GenT Identity [SimpleScript] -> GenT Identity SimpleScript
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity SimpleScript -> GenT Identity [SimpleScript]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10) GenT Identity SimpleScript
genTerm
    , [SimpleScript] -> SimpleScript
RequireAnyOf ([SimpleScript] -> SimpleScript)
-> GenT Identity [SimpleScript] -> GenT Identity SimpleScript
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity SimpleScript -> GenT Identity [SimpleScript]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear (if Bool
hasEmptyAnys then Int
0 else Int
1) Int
10) GenT Identity SimpleScript
genTerm
    , do
        [SimpleScript]
ts <- Range Int
-> GenT Identity SimpleScript -> GenT Identity [SimpleScript]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10) GenT Identity SimpleScript
genTerm
        Int
m <- Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 ([SimpleScript] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SimpleScript]
ts))
        SimpleScript -> GenT Identity SimpleScript
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> [SimpleScript] -> SimpleScript
RequireMOf Int
m [SimpleScript]
ts)
    ]

-- | 'genPlutusScript' will generate the deprecated double encoded
-- plutus scripts as well as valid plutus scripts.
genPlutusScript :: PlutusScriptVersion lang -> Gen (PlutusScript lang)
genPlutusScript :: forall lang. PlutusScriptVersion lang -> Gen (PlutusScript lang)
genPlutusScript PlutusScriptVersion lang
l =
  case PlutusScriptVersion lang
l of
    PlutusScriptVersion lang
PlutusScriptV1 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV1
_ PlutusScript PlutusScriptV1
s <- Gen (Script PlutusScriptV1)
genPlutusV1Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV1
s
    PlutusScriptVersion lang
PlutusScriptV2 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV2
_ PlutusScript PlutusScriptV2
s <- Gen (Script PlutusScriptV2)
genPlutusV2Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV2
s
    PlutusScriptVersion lang
PlutusScriptV3 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV3
_ PlutusScript PlutusScriptV3
s <- Gen (Script PlutusScriptV3)
genPlutusV3Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV3
s

genValidPlutusScript :: PlutusScriptVersion lang -> Gen (PlutusScript lang)
genValidPlutusScript :: forall lang. PlutusScriptVersion lang -> Gen (PlutusScript lang)
genValidPlutusScript PlutusScriptVersion lang
l =
  case PlutusScriptVersion lang
l of
    PlutusScriptVersion lang
PlutusScriptV1 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV1
_ PlutusScript PlutusScriptV1
s <- Gen (Script PlutusScriptV1)
genValidPlutusV1Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV1
s
    PlutusScriptVersion lang
PlutusScriptV2 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV2
_ PlutusScript PlutusScriptV2
s <- Gen (Script PlutusScriptV2)
genValidPlutusV2Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV2
s
    PlutusScriptVersion lang
PlutusScriptV3 -> do
      PlutusScript PlutusScriptVersion PlutusScriptV3
_ PlutusScript PlutusScriptV3
s <- Gen (Script PlutusScriptV3)
genValidPlutusV3Script
      PlutusScript lang -> Gen (PlutusScript lang)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return PlutusScript lang
PlutusScript PlutusScriptV3
s

genPlutusV1Script :: Gen (Script PlutusScriptV1)
genPlutusV1Script :: Gen (Script PlutusScriptV1)
genPlutusV1Script = do
  ByteString
v1Script <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v1Loop2024PlutusScriptHexDoubleEncoded,ByteString
v1Loop2024PlutusScriptHex]
  let v1ScriptBytes :: ByteString
v1ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v1Script
  Script PlutusScriptV1 -> Gen (Script PlutusScriptV1)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV1 -> Gen (Script PlutusScriptV1))
-> (ShortByteString -> Script PlutusScriptV1)
-> ShortByteString
-> Gen (Script PlutusScriptV1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV1
-> PlutusScript PlutusScriptV1 -> Script PlutusScriptV1
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV1
PlutusScriptV1 (PlutusScript PlutusScriptV1 -> Script PlutusScriptV1)
-> (ShortByteString -> PlutusScript PlutusScriptV1)
-> ShortByteString
-> Script PlutusScriptV1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV1
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV1))
-> ShortByteString -> Gen (Script PlutusScriptV1)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v1ScriptBytes

genValidPlutusV1Script :: Gen (Script PlutusScriptV1)
genValidPlutusV1Script :: Gen (Script PlutusScriptV1)
genValidPlutusV1Script = do
  ByteString
v1Script <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v1Loop2024PlutusScriptHex]
  let v1ScriptBytes :: ByteString
v1ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v1Script
  Script PlutusScriptV1 -> Gen (Script PlutusScriptV1)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV1 -> Gen (Script PlutusScriptV1))
-> (ShortByteString -> Script PlutusScriptV1)
-> ShortByteString
-> Gen (Script PlutusScriptV1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV1
-> PlutusScript PlutusScriptV1 -> Script PlutusScriptV1
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV1
PlutusScriptV1 (PlutusScript PlutusScriptV1 -> Script PlutusScriptV1)
-> (ShortByteString -> PlutusScript PlutusScriptV1)
-> ShortByteString
-> Script PlutusScriptV1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV1
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV1))
-> ShortByteString -> Gen (Script PlutusScriptV1)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v1ScriptBytes

genPlutusV2Script :: Gen (Script PlutusScriptV2)
genPlutusV2Script :: Gen (Script PlutusScriptV2)
genPlutusV2Script = do
  ByteString
v2Script <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v2EcdsaLoopPlutusScriptHexDoubleEncoded, ByteString
v2EcdsaLoopPlutusScriptHex]
  let v2ScriptBytes :: ByteString
v2ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v2Script
  Script PlutusScriptV2 -> Gen (Script PlutusScriptV2)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV2 -> Gen (Script PlutusScriptV2))
-> (ShortByteString -> Script PlutusScriptV2)
-> ShortByteString
-> Gen (Script PlutusScriptV2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV2
-> PlutusScript PlutusScriptV2 -> Script PlutusScriptV2
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV2
PlutusScriptV2 (PlutusScript PlutusScriptV2 -> Script PlutusScriptV2)
-> (ShortByteString -> PlutusScript PlutusScriptV2)
-> ShortByteString
-> Script PlutusScriptV2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV2
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV2))
-> ShortByteString -> Gen (Script PlutusScriptV2)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v2ScriptBytes

genValidPlutusV2Script :: Gen (Script PlutusScriptV2)
genValidPlutusV2Script :: Gen (Script PlutusScriptV2)
genValidPlutusV2Script = do
  ByteString
v2Script <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v2EcdsaLoopPlutusScriptHex]
  let v2ScriptBytes :: ByteString
v2ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v2Script
  Script PlutusScriptV2 -> Gen (Script PlutusScriptV2)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV2 -> Gen (Script PlutusScriptV2))
-> (ShortByteString -> Script PlutusScriptV2)
-> ShortByteString
-> Gen (Script PlutusScriptV2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV2
-> PlutusScript PlutusScriptV2 -> Script PlutusScriptV2
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV2
PlutusScriptV2 (PlutusScript PlutusScriptV2 -> Script PlutusScriptV2)
-> (ShortByteString -> PlutusScript PlutusScriptV2)
-> ShortByteString
-> Script PlutusScriptV2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV2
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV2))
-> ShortByteString -> Gen (Script PlutusScriptV2)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v2ScriptBytes

genPlutusV3Script :: Gen (Script PlutusScriptV3)
genPlutusV3Script :: Gen (Script PlutusScriptV3)
genPlutusV3Script = do
  ByteString
v3AlwaysSucceedsPlutusScriptHex
   <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v3AlwaysSucceedsPlutusScriptDoubleEncoded, ByteString
v3AlwaysSucceedsPlutusScript]
  let v3ScriptBytes :: ByteString
v3ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v3AlwaysSucceedsPlutusScriptHex
  Script PlutusScriptV3 -> Gen (Script PlutusScriptV3)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV3 -> Gen (Script PlutusScriptV3))
-> (ShortByteString -> Script PlutusScriptV3)
-> ShortByteString
-> Gen (Script PlutusScriptV3)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV3
-> PlutusScript PlutusScriptV3 -> Script PlutusScriptV3
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV3
PlutusScriptV3 (PlutusScript PlutusScriptV3 -> Script PlutusScriptV3)
-> (ShortByteString -> PlutusScript PlutusScriptV3)
-> ShortByteString
-> Script PlutusScriptV3
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV3
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV3))
-> ShortByteString -> Gen (Script PlutusScriptV3)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v3ScriptBytes

genValidPlutusV3Script :: Gen (Script PlutusScriptV3)
genValidPlutusV3Script :: Gen (Script PlutusScriptV3)
genValidPlutusV3Script = do
  ByteString
v3AlwaysSucceedsPlutusScriptHex
   <- [ByteString] -> GenT Identity ByteString
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ByteString
v3AlwaysSucceedsPlutusScript]
  let v3ScriptBytes :: ByteString
v3ScriptBytes = ByteString -> ByteString
Base16.decodeLenient ByteString
v3AlwaysSucceedsPlutusScriptHex
  Script PlutusScriptV3 -> Gen (Script PlutusScriptV3)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script PlutusScriptV3 -> Gen (Script PlutusScriptV3))
-> (ShortByteString -> Script PlutusScriptV3)
-> ShortByteString
-> Gen (Script PlutusScriptV3)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PlutusScriptVersion PlutusScriptV3
-> PlutusScript PlutusScriptV3 -> Script PlutusScriptV3
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
PlutusScript PlutusScriptVersion PlutusScriptV3
PlutusScriptV3 (PlutusScript PlutusScriptV3 -> Script PlutusScriptV3)
-> (ShortByteString -> PlutusScript PlutusScriptV3)
-> ShortByteString
-> Script PlutusScriptV3
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> PlutusScript PlutusScriptV3
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> Gen (Script PlutusScriptV3))
-> ShortByteString -> Gen (Script PlutusScriptV3)
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort ByteString
v3ScriptBytes


genScriptDataSchema :: Gen ScriptDataJsonSchema
genScriptDataSchema :: Gen ScriptDataJsonSchema
genScriptDataSchema = [ScriptDataJsonSchema] -> Gen ScriptDataJsonSchema
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ScriptDataJsonSchema
ScriptDataJsonNoSchema, ScriptDataJsonSchema
ScriptDataJsonDetailedSchema]

genHashableScriptData :: HasCallStack => Gen HashableScriptData
genHashableScriptData :: HasCallStack => Gen HashableScriptData
genHashableScriptData = do
  ScriptData
sd <- Gen ScriptData
genScriptData
  case AsType HashableScriptData
-> ByteString -> Either DecoderError HashableScriptData
forall a.
SerialiseAsCBOR a =>
AsType a -> ByteString -> Either DecoderError a
deserialiseFromCBOR AsType HashableScriptData
AsHashableScriptData (ByteString -> Either DecoderError HashableScriptData)
-> ByteString -> Either DecoderError HashableScriptData
forall a b. (a -> b) -> a -> b
$ ScriptData -> ByteString
forall a. SerialiseAsCBOR a => a -> ByteString
serialiseToCBOR ScriptData
sd of
    Left DecoderError
e -> [Char] -> Gen HashableScriptData
forall a. HasCallStack => [Char] -> a
error ([Char] -> Gen HashableScriptData)
-> [Char] -> Gen HashableScriptData
forall a b. (a -> b) -> a -> b
$ [Char]
"genHashableScriptData: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> DecoderError -> [Char]
forall a. Show a => a -> [Char]
show DecoderError
e
    Right HashableScriptData
r -> HashableScriptData -> Gen HashableScriptData
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return HashableScriptData
r

{-# DEPRECATED genScriptData "Use genHashableScriptData" #-}
genScriptData :: Gen ScriptData
genScriptData :: Gen ScriptData
genScriptData =
  ([Gen ScriptData] -> Gen ScriptData)
-> [Gen ScriptData] -> [Gen ScriptData] -> Gen ScriptData
forall (m :: * -> *) a.
MonadGen m =>
([m a] -> m a) -> [m a] -> [m a] -> m a
Gen.recursive
    [Gen ScriptData] -> Gen ScriptData
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ Integer -> ScriptData
ScriptDataNumber (Integer -> ScriptData) -> GenT Identity Integer -> Gen ScriptData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity Integer
genInteger
    , ByteString -> ScriptData
ScriptDataBytes (ByteString -> ScriptData)
-> GenT Identity ByteString -> Gen ScriptData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity ByteString
genByteString
    ]
    -- The Gen.recursive combinator calls these with the size halved
    [ Integer -> [ScriptData] -> ScriptData
ScriptDataConstructor
        (Integer -> [ScriptData] -> ScriptData)
-> GenT Identity Integer
-> GenT Identity ([ScriptData] -> ScriptData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity Integer
genConstructorInteger
        GenT Identity ([ScriptData] -> ScriptData)
-> GenT Identity [ScriptData] -> Gen ScriptData
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity [ScriptData]
genScriptDataList
    , [ScriptData] -> ScriptData
ScriptDataList ([ScriptData] -> ScriptData)
-> GenT Identity [ScriptData] -> Gen ScriptData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity [ScriptData]
genScriptDataList
    , [(ScriptData, ScriptData)] -> ScriptData
ScriptDataMap ([(ScriptData, ScriptData)] -> ScriptData)
-> GenT Identity [(ScriptData, ScriptData)] -> Gen ScriptData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity [(ScriptData, ScriptData)]
genScriptDataMap
    ]
 where
  genInteger :: Gen Integer
  genInteger :: GenT Identity Integer
genInteger =
    Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral
      ( Integer -> Integer -> Range Integer
forall a. Integral a => a -> a -> Range a
Range.linear
          (-Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
forall a. Bounded a => a
maxBound :: Word64) :: Integer)
          (Integer
2 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
forall a. Bounded a => a
maxBound :: Word64) :: Integer)
      )

  genConstructorInteger :: Gen Integer
  genConstructorInteger :: GenT Identity Integer
genConstructorInteger =
    Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral
      ( Integer -> Integer -> Range Integer
forall a. Integral a => a -> a -> Range a
Range.linear
          Integer
0 -- TODO: Alonzo should be -> (-fromIntegral (maxBound :: Word64) :: Integer)
          -- Wrapping bug needs to be fixed in Plutus library
          (Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
forall a. Bounded a => a
maxBound :: Word64) :: Integer)
      )

  genByteString :: Gen ByteString
  genByteString :: GenT Identity ByteString
genByteString =
    [Word8] -> ByteString
BS.pack
      ([Word8] -> ByteString)
-> GenT Identity [Word8] -> GenT Identity ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity Word8 -> GenT Identity [Word8]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
        (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
64)
        (Range Word8 -> GenT Identity Word8
forall (m :: * -> *). MonadGen m => Range Word8 -> m Word8
Gen.word8 Range Word8
forall a. (Bounded a, Num a) => Range a
Range.constantBounded)

  genScriptDataList :: Gen [ScriptData]
  genScriptDataList :: GenT Identity [ScriptData]
genScriptDataList =
    (Size -> GenT Identity [ScriptData]) -> GenT Identity [ScriptData]
forall (m :: * -> *) a. MonadGen m => (Size -> m a) -> m a
Gen.sized ((Size -> GenT Identity [ScriptData])
 -> GenT Identity [ScriptData])
-> (Size -> GenT Identity [ScriptData])
-> GenT Identity [ScriptData]
forall a b. (a -> b) -> a -> b
$ \Size
sz ->
      Range Int -> Gen ScriptData -> GenT Identity [ScriptData]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Size -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Size
sz)) Gen ScriptData
genScriptData

  genScriptDataMap :: Gen [(ScriptData, ScriptData)]
  genScriptDataMap :: GenT Identity [(ScriptData, ScriptData)]
genScriptDataMap =
    (Size -> GenT Identity [(ScriptData, ScriptData)])
-> GenT Identity [(ScriptData, ScriptData)]
forall (m :: * -> *) a. MonadGen m => (Size -> m a) -> m a
Gen.sized ((Size -> GenT Identity [(ScriptData, ScriptData)])
 -> GenT Identity [(ScriptData, ScriptData)])
-> (Size -> GenT Identity [(ScriptData, ScriptData)])
-> GenT Identity [(ScriptData, ScriptData)]
forall a b. (a -> b) -> a -> b
$ \Size
sz ->
      Range Int
-> GenT Identity (ScriptData, ScriptData)
-> GenT Identity [(ScriptData, ScriptData)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 (Size -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Size
sz)) (GenT Identity (ScriptData, ScriptData)
 -> GenT Identity [(ScriptData, ScriptData)])
-> GenT Identity (ScriptData, ScriptData)
-> GenT Identity [(ScriptData, ScriptData)]
forall a b. (a -> b) -> a -> b
$
        (,) (ScriptData -> ScriptData -> (ScriptData, ScriptData))
-> Gen ScriptData
-> GenT Identity (ScriptData -> (ScriptData, ScriptData))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ScriptData
genScriptData GenT Identity (ScriptData -> (ScriptData, ScriptData))
-> Gen ScriptData -> GenT Identity (ScriptData, ScriptData)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ScriptData
genScriptData

-- ----------------------------------------------------------------------------
-- Script generators for any language, or any language valid in a specific era
--

genScriptInAnyLang :: Gen ScriptInAnyLang
genScriptInAnyLang :: Gen ScriptInAnyLang
genScriptInAnyLang =
  [Gen ScriptInAnyLang] -> Gen ScriptInAnyLang
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ ScriptLanguage lang -> Script lang -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang ScriptLanguage lang
lang (Script lang -> ScriptInAnyLang)
-> GenT Identity (Script lang) -> Gen ScriptInAnyLang
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ScriptLanguage lang -> GenT Identity (Script lang)
forall lang. ScriptLanguage lang -> Gen (Script lang)
genScript ScriptLanguage lang
lang
    | AnyScriptLanguage ScriptLanguage lang
lang <- [AnyScriptLanguage
forall a. Bounded a => a
minBound .. AnyScriptLanguage
forall a. Bounded a => a
maxBound]
    ]

genScriptInEra :: ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra :: forall era. ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra ShelleyBasedEra era
era =
  [GenT Identity (ScriptInEra era)]
-> GenT Identity (ScriptInEra era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ ScriptLanguageInEra lang era -> Script lang -> ScriptInEra era
forall lang era.
ScriptLanguageInEra lang era -> Script lang -> ScriptInEra era
ScriptInEra ScriptLanguageInEra lang era
langInEra (Script lang -> ScriptInEra era)
-> GenT Identity (Script lang) -> GenT Identity (ScriptInEra era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ScriptLanguage lang -> GenT Identity (Script lang)
forall lang. ScriptLanguage lang -> Gen (Script lang)
genValidScript ScriptLanguage lang
lang
    | AnyScriptLanguage ScriptLanguage lang
lang <- [AnyScriptLanguage
forall a. Bounded a => a
minBound .. AnyScriptLanguage
forall a. Bounded a => a
maxBound]
    , Just ScriptLanguageInEra lang era
langInEra <- [ShelleyBasedEra era
-> ScriptLanguage lang -> Maybe (ScriptLanguageInEra lang era)
forall era lang.
ShelleyBasedEra era
-> ScriptLanguage lang -> Maybe (ScriptLanguageInEra lang era)
scriptLanguageSupportedInEra ShelleyBasedEra era
era ScriptLanguage lang
lang]
    ]

genScriptHash :: Gen ScriptHash
genScriptHash :: Gen ScriptHash
genScriptHash = do
  ScriptInAnyLang ScriptLanguage lang
_ Script lang
script <- Gen ScriptInAnyLang
genScriptInAnyLang
  ScriptHash -> Gen ScriptHash
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Script lang -> ScriptHash
forall lang. Script lang -> ScriptHash
hashScript Script lang
script)

----------------------------------------------------------------------------
-- Multi-asset generators
--

genAssetName :: Gen AssetName
genAssetName :: Gen AssetName
genAssetName =
  [(Int, Gen AssetName)] -> Gen AssetName
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency
    -- mostly from a small number of choices, so we get plenty of repetition
    [ (Int
9, [AssetName] -> Gen AssetName
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [AssetName
"", AssetName
"a", AssetName
"b", AssetName
"c"])
    , (Int
1, ByteString -> AssetName
AssetName (ByteString -> AssetName)
-> GenT Identity ByteString -> Gen AssetName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Int -> Range Int
forall a. a -> Range a
Range.singleton Int
32))
    , (Int
1, ByteString -> AssetName
AssetName (ByteString -> AssetName)
-> GenT Identity ByteString -> Gen AssetName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
31))
    ]

genPolicyId :: Gen PolicyId
genPolicyId :: Gen PolicyId
genPolicyId =
  [(Int, Gen PolicyId)] -> Gen PolicyId
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency
    -- mostly from a small number of choices, so we get plenty of repetition
    [ (Int
9, [PolicyId] -> Gen PolicyId
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [[Char] -> PolicyId
forall a. IsString a => [Char] -> a
fromString (Char
x Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
55 Char
'0') | Char
x <- [Char
'a' .. Char
'c']])
    , -- and some from the full range of the type
      (Int
1, ScriptHash -> PolicyId
PolicyId (ScriptHash -> PolicyId) -> Gen ScriptHash -> Gen PolicyId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ScriptHash
genScriptHash)
    ]

genAssetId :: Gen AssetId
genAssetId :: Gen AssetId
genAssetId =
  PolicyId -> AssetName -> AssetId
AssetId (PolicyId -> AssetName -> AssetId)
-> Gen PolicyId -> GenT Identity (AssetName -> AssetId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen PolicyId
genPolicyId GenT Identity (AssetName -> AssetId)
-> Gen AssetName -> Gen AssetId
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen AssetName
genAssetName

genQuantity :: Range Integer -> Gen Quantity
genQuantity :: Range Integer -> Gen Quantity
genQuantity Range Integer
range = Integer -> Quantity
forall a. Num a => Integer -> a
fromInteger (Integer -> Quantity) -> GenT Identity Integer -> Gen Quantity
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral Range Integer
range

-- | Generate a positive or negative quantity.
genSignedQuantity :: Gen Quantity
genSignedQuantity :: Gen Quantity
genSignedQuantity = Range Integer -> Gen Quantity
genQuantity (Integer -> Integer -> Integer -> Range Integer
forall a. a -> a -> a -> Range a
Range.constantFrom Integer
0 (-Integer
2) Integer
2)

-- | Generate a positive or negative, but not zero quantity.
genSignedNonZeroQuantity :: Gen Quantity
genSignedNonZeroQuantity :: Gen Quantity
genSignedNonZeroQuantity =
  [Gen Quantity] -> Gen Quantity
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ Range Integer -> Gen Quantity
genQuantity (Integer -> Integer -> Range Integer
forall a. a -> a -> Range a
Range.constant (-Integer
2) (-Integer
1))
    , Range Integer -> Gen Quantity
genQuantity (Integer -> Integer -> Range Integer
forall a. a -> a -> Range a
Range.constant Integer
1 Integer
2)
    ]

genUnsignedQuantity :: Gen Quantity
genUnsignedQuantity :: Gen Quantity
genUnsignedQuantity = Range Integer -> Gen Quantity
genQuantity (Integer -> Integer -> Range Integer
forall a. a -> a -> Range a
Range.constant Integer
0 Integer
2)

genPositiveQuantity :: Gen Quantity
genPositiveQuantity :: Gen Quantity
genPositiveQuantity = Range Integer -> Gen Quantity
genQuantity (Integer -> Integer -> Range Integer
forall a. a -> a -> Range a
Range.constant Integer
1 Integer
2)

genValue :: Gen AssetId -> Gen Quantity -> Gen Value
genValue :: Gen AssetId -> Gen Quantity -> Gen Value
genValue Gen AssetId
genAId Gen Quantity
genQuant =
  [(AssetId, Quantity)] -> Value
valueFromList ([(AssetId, Quantity)] -> Value)
-> GenT Identity [(AssetId, Quantity)] -> Gen Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity (AssetId, Quantity)
-> GenT Identity [(AssetId, Quantity)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
      (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
10)
      ((,) (AssetId -> Quantity -> (AssetId, Quantity))
-> Gen AssetId -> GenT Identity (Quantity -> (AssetId, Quantity))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen AssetId
genAId GenT Identity (Quantity -> (AssetId, Quantity))
-> Gen Quantity -> GenT Identity (AssetId, Quantity)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Quantity
genQuant)

genLedgerValue
  :: MaryEraOnwards era -> Gen AssetId -> Gen Quantity -> Gen (L.Value (ShelleyLedgerEra era))
genLedgerValue :: forall era.
MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
genLedgerValue MaryEraOnwards era
w Gen AssetId
genAId Gen Quantity
genQuant =
  MaryEraOnwards era -> Value -> Value (ShelleyLedgerEra era)
forall era.
MaryEraOnwards era -> Value -> Value (ShelleyLedgerEra era)
toLedgerValue MaryEraOnwards era
w (Value -> Value (ShelleyLedgerEra era))
-> Gen Value -> GenT Identity (Value (ShelleyLedgerEra era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen AssetId -> Gen Quantity -> Gen Value
genValue Gen AssetId
genAId Gen Quantity
genQuant

-- | Generate a 'Value' with any asset ID and a positive or negative quantity.
genValueDefault :: MaryEraOnwards era -> Gen (L.Value (ShelleyLedgerEra era))
genValueDefault :: forall era.
MaryEraOnwards era -> Gen (Value (ShelleyLedgerEra era))
genValueDefault MaryEraOnwards era
w = MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> GenT Identity (Value (ShelleyLedgerEra era))
forall era.
MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
genLedgerValue MaryEraOnwards era
w Gen AssetId
genAssetId Gen Quantity
genSignedNonZeroQuantity

genValueForRole :: MaryEraOnwards era -> ParserValueRole -> Gen Value
genValueForRole :: forall era. MaryEraOnwards era -> ParserValueRole -> Gen Value
genValueForRole MaryEraOnwards era
w =
  \case
    ParserValueRole
RoleMint ->
      Gen Value
genValueForMinting
    ParserValueRole
RoleUTxO ->
      ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
fromLedgerValue (MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert MaryEraOnwards era
w) (Value (ShelleyLedgerEra era) -> Value)
-> GenT Identity (Value (ShelleyLedgerEra era)) -> Gen Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (Value (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era -> Gen (Value (ShelleyLedgerEra era))
genValueForTxOut (MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert MaryEraOnwards era
w)

-- | Generate a 'Value' suitable for minting, i.e. non-ADA asset ID and a
-- positive or negative quantity.
genValueForMinting :: Gen Value
genValueForMinting :: Gen Value
genValueForMinting =
  Gen AssetId -> Gen Quantity -> Gen Value
genValue Gen AssetId
genAssetIdNoAda Gen Quantity
genSignedNonZeroQuantity
 where
  genAssetIdNoAda :: Gen AssetId
  genAssetIdNoAda :: Gen AssetId
genAssetIdNoAda = PolicyId -> AssetName -> AssetId
AssetId (PolicyId -> AssetName -> AssetId)
-> Gen PolicyId -> GenT Identity (AssetName -> AssetId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen PolicyId
genPolicyId GenT Identity (AssetName -> AssetId)
-> Gen AssetName -> Gen AssetId
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen AssetName
genAssetName

-- | Generate a 'Value' suitable for usage in a transaction output, i.e. any
-- asset ID and a positive quantity.
genValueForTxOut :: ShelleyBasedEra era -> Gen (L.Value (ShelleyLedgerEra era))
genValueForTxOut :: forall era.
ShelleyBasedEra era -> Gen (Value (ShelleyLedgerEra era))
genValueForTxOut ShelleyBasedEra era
sbe = do
  -- Generate at least one positive ADA, without it Value in TxOut makes no sense
  -- and will fail deserialization starting with ConwayEra
  Value (ShelleyLedgerEra era)
ada <- ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
forall era.
ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
A.mkAdaValue ShelleyBasedEra era
sbe (Coin -> Value (ShelleyLedgerEra era))
-> (Integer -> Coin) -> Integer -> Value (ShelleyLedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Coin
L.Coin (Integer -> Value (ShelleyLedgerEra era))
-> GenT Identity Integer -> Gen (Value (ShelleyLedgerEra era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Integer -> GenT Identity Integer
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Integer -> Integer -> Range Integer
forall a. a -> a -> Range a
Range.constant Integer
1 Integer
2)

  -- Generate a potentially empty list with multi assets
  (ShelleyToAllegraEraConstraints era =>
 ShelleyToAllegraEra era -> Gen (Value (ShelleyLedgerEra era)))
-> (MaryEraOnwardsConstraints era =>
    MaryEraOnwards era -> Gen (Value (ShelleyLedgerEra era)))
-> ShelleyBasedEra era
-> Gen (Value (ShelleyLedgerEra era))
forall era a.
(ShelleyToAllegraEraConstraints era =>
 ShelleyToAllegraEra era -> a)
-> (MaryEraOnwardsConstraints era => MaryEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToAllegraOrMaryEraOnwards
    (Gen (Value (ShelleyLedgerEra era))
-> ShelleyToAllegraEra era -> Gen (Value (ShelleyLedgerEra era))
forall a b. a -> b -> a
const (Value (ShelleyLedgerEra era) -> Gen (Value (ShelleyLedgerEra era))
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Value (ShelleyLedgerEra era)
ada))
    ( \MaryEraOnwards era
w -> do
        [Value (ShelleyLedgerEra era)]
v <- Range Int
-> Gen (Value (ShelleyLedgerEra era))
-> GenT Identity [Value (ShelleyLedgerEra era)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
5) (Gen (Value (ShelleyLedgerEra era))
 -> GenT Identity [Value (ShelleyLedgerEra era)])
-> Gen (Value (ShelleyLedgerEra era))
-> GenT Identity [Value (ShelleyLedgerEra era)]
forall a b. (a -> b) -> a -> b
$ MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
forall era.
MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
genLedgerValue MaryEraOnwards era
w Gen AssetId
genAssetId Gen Quantity
genPositiveQuantity
        Value (ShelleyLedgerEra era) -> Gen (Value (ShelleyLedgerEra era))
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value (ShelleyLedgerEra era)
 -> Gen (Value (ShelleyLedgerEra era)))
-> Value (ShelleyLedgerEra era)
-> Gen (Value (ShelleyLedgerEra era))
forall a b. (a -> b) -> a -> b
$ Value (ShelleyLedgerEra era)
ada Value (ShelleyLedgerEra era)
-> Value (ShelleyLedgerEra era) -> Value (ShelleyLedgerEra era)
forall a. Semigroup a => a -> a -> a
<> [Value (ShelleyLedgerEra era)] -> Value (ShelleyLedgerEra era)
forall a. Monoid a => [a] -> a
mconcat [Value (ShelleyLedgerEra era)]
v
    )
    ShelleyBasedEra era
sbe

-- Note that we expect to sometimes generate duplicate policy id keys since we
-- pick 90% of policy ids from a set of just three.
genValueNestedRep :: Gen ValueNestedRep
genValueNestedRep :: Gen ValueNestedRep
genValueNestedRep =
  [ValueNestedBundle] -> ValueNestedRep
ValueNestedRep ([ValueNestedBundle] -> ValueNestedRep)
-> GenT Identity [ValueNestedBundle] -> Gen ValueNestedRep
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity ValueNestedBundle
-> GenT Identity [ValueNestedBundle]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
5) GenT Identity ValueNestedBundle
genValueNestedBundle

genValueNestedBundle :: Gen ValueNestedBundle
genValueNestedBundle :: GenT Identity ValueNestedBundle
genValueNestedBundle =
  [GenT Identity ValueNestedBundle]
-> GenT Identity ValueNestedBundle
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ Quantity -> ValueNestedBundle
ValueNestedBundleAda (Quantity -> ValueNestedBundle)
-> Gen Quantity -> GenT Identity ValueNestedBundle
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Quantity
genSignedQuantity
    , PolicyId -> Map AssetName Quantity -> ValueNestedBundle
ValueNestedBundle
        (PolicyId -> Map AssetName Quantity -> ValueNestedBundle)
-> Gen PolicyId
-> GenT Identity (Map AssetName Quantity -> ValueNestedBundle)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen PolicyId
genPolicyId
        GenT Identity (Map AssetName Quantity -> ValueNestedBundle)
-> GenT Identity (Map AssetName Quantity)
-> GenT Identity ValueNestedBundle
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Int
-> GenT Identity (AssetName, Quantity)
-> GenT Identity (Map AssetName Quantity)
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map
          (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
5)
          ((,) (AssetName -> Quantity -> (AssetName, Quantity))
-> Gen AssetName
-> GenT Identity (Quantity -> (AssetName, Quantity))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen AssetName
genAssetName GenT Identity (Quantity -> (AssetName, Quantity))
-> Gen Quantity -> GenT Identity (AssetName, Quantity)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Quantity
genSignedQuantity)
    ]

genNetworkId :: Gen NetworkId
genNetworkId :: GenT Identity NetworkId
genNetworkId =
  [GenT Identity NetworkId] -> GenT Identity NetworkId
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ NetworkId -> GenT Identity NetworkId
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NetworkId
Mainnet
    , NetworkMagic -> NetworkId
Testnet (NetworkMagic -> NetworkId)
-> GenT Identity NetworkMagic -> GenT Identity NetworkId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity NetworkMagic
genNetworkMagic
    ]

genNetworkMagic :: Gen NetworkMagic
genNetworkMagic :: GenT Identity NetworkMagic
genNetworkMagic = Word32 -> NetworkMagic
NetworkMagic (Word32 -> NetworkMagic)
-> GenT Identity Word32 -> GenT Identity NetworkMagic
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word32 -> GenT Identity Word32
forall (m :: * -> *). MonadGen m => Range Word32 -> m Word32
Gen.word32 Range Word32
forall a. (Bounded a, Num a) => Range a
Range.constantBounded

genOperationalCertificate :: Gen OperationalCertificate
genOperationalCertificate :: Gen OperationalCertificate
genOperationalCertificate = (OperationalCertificate, OperationalCertificateIssueCounter)
-> OperationalCertificate
forall a b. (a, b) -> a
fst ((OperationalCertificate, OperationalCertificateIssueCounter)
 -> OperationalCertificate)
-> GenT
     Identity
     (OperationalCertificate, OperationalCertificateIssueCounter)
-> Gen OperationalCertificate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity
  (OperationalCertificate, OperationalCertificateIssueCounter)
HasCallStack =>
GenT
  Identity
  (OperationalCertificate, OperationalCertificateIssueCounter)
genOperationalCertificateWithCounter

genOperationalCertificateIssueCounter :: Gen OperationalCertificateIssueCounter
genOperationalCertificateIssueCounter :: Gen OperationalCertificateIssueCounter
genOperationalCertificateIssueCounter = (OperationalCertificate, OperationalCertificateIssueCounter)
-> OperationalCertificateIssueCounter
forall a b. (a, b) -> b
snd ((OperationalCertificate, OperationalCertificateIssueCounter)
 -> OperationalCertificateIssueCounter)
-> GenT
     Identity
     (OperationalCertificate, OperationalCertificateIssueCounter)
-> Gen OperationalCertificateIssueCounter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT
  Identity
  (OperationalCertificate, OperationalCertificateIssueCounter)
HasCallStack =>
GenT
  Identity
  (OperationalCertificate, OperationalCertificateIssueCounter)
genOperationalCertificateWithCounter

genOperationalCertificateWithCounter
  :: HasCallStack => Gen (OperationalCertificate, OperationalCertificateIssueCounter)
genOperationalCertificateWithCounter :: HasCallStack =>
GenT
  Identity
  (OperationalCertificate, OperationalCertificateIssueCounter)
genOperationalCertificateWithCounter = do
  VerificationKey KesKey
kesVKey <- AsType KesKey -> Gen (VerificationKey KesKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType KesKey
AsKesKey
  Either
  (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey)
stkPoolOrGenDelExtSign <-
    GenT Identity (SigningKey StakePoolKey)
-> GenT Identity (SigningKey GenesisDelegateExtendedKey)
-> GenT
     Identity
     (Either
        (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey))
forall (m :: * -> *) a b.
MonadGen m =>
m a -> m b -> m (Either a b)
Gen.either (AsType StakePoolKey -> GenT Identity (SigningKey StakePoolKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType StakePoolKey
AsStakePoolKey) (AsType GenesisDelegateExtendedKey
-> GenT Identity (SigningKey GenesisDelegateExtendedKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType GenesisDelegateExtendedKey
AsGenesisDelegateExtendedKey)
  KESPeriod
kesP <- Gen KESPeriod
genKESPeriod
  Word64
c <- Range Word64 -> GenT Identity Word64
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Range Word64 -> GenT Identity Word64)
-> Range Word64 -> GenT Identity Word64
forall a b. (a -> b) -> a -> b
$ Word64 -> Word64 -> Range Word64
forall a. Integral a => a -> a -> Range a
Range.linear Word64
0 Word64
1000
  let stakePoolVer :: VerificationKey StakePoolKey
stakePoolVer = (SigningKey StakePoolKey -> VerificationKey StakePoolKey)
-> (SigningKey GenesisDelegateExtendedKey
    -> VerificationKey StakePoolKey)
-> Either
     (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey)
-> VerificationKey StakePoolKey
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either SigningKey StakePoolKey -> VerificationKey StakePoolKey
forall keyrole.
(Key keyrole, HasTypeProxy keyrole) =>
SigningKey keyrole -> VerificationKey keyrole
getVerificationKey (VerificationKey GenesisDelegateExtendedKey
-> VerificationKey StakePoolKey
convert' (VerificationKey GenesisDelegateExtendedKey
 -> VerificationKey StakePoolKey)
-> (SigningKey GenesisDelegateExtendedKey
    -> VerificationKey GenesisDelegateExtendedKey)
-> SigningKey GenesisDelegateExtendedKey
-> VerificationKey StakePoolKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SigningKey GenesisDelegateExtendedKey
-> VerificationKey GenesisDelegateExtendedKey
forall keyrole.
(Key keyrole, HasTypeProxy keyrole) =>
SigningKey keyrole -> VerificationKey keyrole
getVerificationKey) Either
  (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey)
stkPoolOrGenDelExtSign
      iCounter :: OperationalCertificateIssueCounter
iCounter = Word64
-> VerificationKey StakePoolKey
-> OperationalCertificateIssueCounter
OperationalCertificateIssueCounter Word64
c VerificationKey StakePoolKey
stakePoolVer

  case VerificationKey KesKey
-> Either
     (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey)
-> KESPeriod
-> OperationalCertificateIssueCounter
-> Either
     OperationalCertIssueError
     (OperationalCertificate, OperationalCertificateIssueCounter)
issueOperationalCertificate VerificationKey KesKey
kesVKey Either
  (SigningKey StakePoolKey) (SigningKey GenesisDelegateExtendedKey)
stkPoolOrGenDelExtSign KESPeriod
kesP OperationalCertificateIssueCounter
iCounter of
    -- This case should be impossible as we clearly derive the verification
    -- key from the generated signing key.
    Left OperationalCertIssueError
err -> [Char]
-> GenT
     Identity
     (OperationalCertificate, OperationalCertificateIssueCounter)
forall a. HasCallStack => [Char] -> a
error ([Char]
 -> GenT
      Identity
      (OperationalCertificate, OperationalCertificateIssueCounter))
-> [Char]
-> GenT
     Identity
     (OperationalCertificate, OperationalCertificateIssueCounter)
forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle -> [Char]
docToString (Doc AnsiStyle -> [Char]) -> Doc AnsiStyle -> [Char]
forall a b. (a -> b) -> a -> b
$ OperationalCertIssueError -> Doc AnsiStyle
forall e ann. Error e => e -> Doc ann
forall ann. OperationalCertIssueError -> Doc ann
prettyError OperationalCertIssueError
err
    Right (OperationalCertificate, OperationalCertificateIssueCounter)
pair -> (OperationalCertificate, OperationalCertificateIssueCounter)
-> GenT
     Identity
     (OperationalCertificate, OperationalCertificateIssueCounter)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (OperationalCertificate, OperationalCertificateIssueCounter)
pair
 where
  convert'
    :: VerificationKey GenesisDelegateExtendedKey
    -> VerificationKey StakePoolKey
  convert' :: VerificationKey GenesisDelegateExtendedKey
-> VerificationKey StakePoolKey
convert' =
    ( VerificationKey GenesisDelegateKey -> VerificationKey StakePoolKey
forall keyroleA keyroleB.
CastVerificationKeyRole keyroleA keyroleB =>
VerificationKey keyroleA -> VerificationKey keyroleB
castVerificationKey
        :: VerificationKey GenesisDelegateKey
        -> VerificationKey StakePoolKey
    )
      (VerificationKey GenesisDelegateKey
 -> VerificationKey StakePoolKey)
-> (VerificationKey GenesisDelegateExtendedKey
    -> VerificationKey GenesisDelegateKey)
-> VerificationKey GenesisDelegateExtendedKey
-> VerificationKey StakePoolKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ( VerificationKey GenesisDelegateExtendedKey
-> VerificationKey GenesisDelegateKey
forall keyroleA keyroleB.
CastVerificationKeyRole keyroleA keyroleB =>
VerificationKey keyroleA -> VerificationKey keyroleB
castVerificationKey
            :: VerificationKey GenesisDelegateExtendedKey
            -> VerificationKey GenesisDelegateKey
        )

-- TODO: Generate payment credential via script
genPaymentCredential :: Gen PaymentCredential
genPaymentCredential :: GenT Identity PaymentCredential
genPaymentCredential = do
  VerificationKey PaymentKey
vKey <- AsType PaymentKey -> GenT Identity (VerificationKey PaymentKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType PaymentKey
AsPaymentKey
  PaymentCredential -> GenT Identity PaymentCredential
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (PaymentCredential -> GenT Identity PaymentCredential)
-> (Hash PaymentKey -> PaymentCredential)
-> Hash PaymentKey
-> GenT Identity PaymentCredential
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash PaymentKey -> PaymentCredential
PaymentCredentialByKey (Hash PaymentKey -> GenT Identity PaymentCredential)
-> Hash PaymentKey -> GenT Identity PaymentCredential
forall a b. (a -> b) -> a -> b
$ VerificationKey PaymentKey -> Hash PaymentKey
forall keyrole.
Key keyrole =>
VerificationKey keyrole -> Hash keyrole
verificationKeyHash VerificationKey PaymentKey
vKey

genSigningKey :: Key keyrole => ShelleyApi.AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey :: forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType keyrole
roletoken = do
  Seed
seed <- Int -> Gen Seed
genSeed (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
seedSize)
  let sk :: SigningKey keyrole
sk = AsType keyrole -> Seed -> SigningKey keyrole
forall keyrole.
Key keyrole =>
AsType keyrole -> Seed -> SigningKey keyrole
deterministicSigningKey AsType keyrole
roletoken Seed
seed
  SigningKey keyrole -> Gen (SigningKey keyrole)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return SigningKey keyrole
sk
 where
  seedSize :: Word
  seedSize :: Word
seedSize = AsType keyrole -> Word
forall keyrole. Key keyrole => AsType keyrole -> Word
deterministicSigningKeySeedSize AsType keyrole
roletoken

genStakeAddress :: Gen StakeAddress
genStakeAddress :: Gen StakeAddress
genStakeAddress = NetworkId -> StakeCredential -> StakeAddress
makeStakeAddress (NetworkId -> StakeCredential -> StakeAddress)
-> GenT Identity NetworkId
-> GenT Identity (StakeCredential -> StakeAddress)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity NetworkId
genNetworkId GenT Identity (StakeCredential -> StakeAddress)
-> GenT Identity StakeCredential -> Gen StakeAddress
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity StakeCredential
genStakeCredential

-- TODO: Generate StakeAddressReference via pointer
genStakeAddressReference :: Gen StakeAddressReference
genStakeAddressReference :: GenT Identity StakeAddressReference
genStakeAddressReference =
  [GenT Identity StakeAddressReference]
-> GenT Identity StakeAddressReference
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ StakeCredential -> StakeAddressReference
StakeAddressByValue (StakeCredential -> StakeAddressReference)
-> GenT Identity StakeCredential
-> GenT Identity StakeAddressReference
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity StakeCredential
genStakeCredential
    , StakeAddressReference -> GenT Identity StakeAddressReference
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return StakeAddressReference
NoStakeAddress
    ]

-- TODO: Generate StakeCredential via script
genStakeCredential :: Gen StakeCredential
genStakeCredential :: GenT Identity StakeCredential
genStakeCredential = do
  VerificationKey StakeKey
vKey <- AsType StakeKey -> Gen (VerificationKey StakeKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType StakeKey
AsStakeKey
  StakeCredential -> GenT Identity StakeCredential
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (StakeCredential -> GenT Identity StakeCredential)
-> (Hash StakeKey -> StakeCredential)
-> Hash StakeKey
-> GenT Identity StakeCredential
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash StakeKey -> StakeCredential
StakeCredentialByKey (Hash StakeKey -> GenT Identity StakeCredential)
-> Hash StakeKey -> GenT Identity StakeCredential
forall a b. (a -> b) -> a -> b
$ VerificationKey StakeKey -> Hash StakeKey
forall keyrole.
Key keyrole =>
VerificationKey keyrole -> Hash keyrole
verificationKeyHash VerificationKey StakeKey
vKey

genShelleyHash :: Gen (Crypto.Hash Crypto.Blake2b_256 Ledger.EraIndependentTxBody)
genShelleyHash :: Gen (Hash Blake2b_256 EraIndependentTxBody)
genShelleyHash = Hash Blake2b_256 EraIndependentTxBody
-> Gen (Hash Blake2b_256 EraIndependentTxBody)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Hash Blake2b_256 EraIndependentTxBody
 -> Gen (Hash Blake2b_256 EraIndependentTxBody))
-> (Hash Blake2b_256 () -> Hash Blake2b_256 EraIndependentTxBody)
-> Hash Blake2b_256 ()
-> Gen (Hash Blake2b_256 EraIndependentTxBody)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash Blake2b_256 () -> Hash Blake2b_256 EraIndependentTxBody
forall h a b. Hash h a -> Hash h b
Crypto.castHash (Hash Blake2b_256 ()
 -> Gen (Hash Blake2b_256 EraIndependentTxBody))
-> Hash Blake2b_256 ()
-> Gen (Hash Blake2b_256 EraIndependentTxBody)
forall a b. (a -> b) -> a -> b
$ (() -> ByteString) -> () -> Hash Blake2b_256 ()
forall h a. HashAlgorithm h => (a -> ByteString) -> a -> Hash h a
Crypto.hashWith () -> ByteString
forall a. ToCBOR a => a -> ByteString
CBOR.serialize' ()

genSlotNo :: Gen SlotNo
genSlotNo :: GenT Identity SlotNo
genSlotNo = Word64 -> SlotNo
SlotNo (Word64 -> SlotNo) -> GenT Identity Word64 -> GenT Identity SlotNo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word64 -> GenT Identity Word64
forall (m :: * -> *). MonadGen m => Range Word64 -> m Word64
Gen.word64 Range Word64
forall a. (Bounded a, Num a) => Range a
Range.constantBounded

genTxIn :: Gen TxIn
genTxIn :: Gen TxIn
genTxIn = TxId -> TxIx -> TxIn
TxIn (TxId -> TxIx -> TxIn)
-> GenT Identity TxId -> GenT Identity (TxIx -> TxIn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity TxId
genTxId GenT Identity (TxIx -> TxIn) -> GenT Identity TxIx -> Gen TxIn
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity TxIx
genTxIndex

genTxId :: Gen TxId
genTxId :: GenT Identity TxId
genTxId = Hash Blake2b_256 EraIndependentTxBody -> TxId
Hash StandardCrypto EraIndependentTxBody -> TxId
TxId (Hash Blake2b_256 EraIndependentTxBody -> TxId)
-> Gen (Hash Blake2b_256 EraIndependentTxBody)
-> GenT Identity TxId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Hash Blake2b_256 EraIndependentTxBody)
genShelleyHash

genTxIndex :: Gen TxIx
genTxIndex :: GenT Identity TxIx
genTxIndex = Word -> TxIx
TxIx (Word -> TxIx) -> (Word16 -> Word) -> Word16 -> TxIx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> TxIx) -> GenT Identity Word16 -> GenT Identity TxIx
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word16 -> GenT Identity Word16
forall (m :: * -> *). MonadGen m => Range Word16 -> m Word16
Gen.word16 Range Word16
forall a. (Bounded a, Num a) => Range a
Range.constantBounded

genTxOutValue :: ShelleyBasedEra era -> Gen (TxOutValue era)
genTxOutValue :: forall era. ShelleyBasedEra era -> Gen (TxOutValue era)
genTxOutValue ShelleyBasedEra era
sbe = ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => Gen (TxOutValue era))
-> Gen (TxOutValue era)
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => Gen (TxOutValue era))
 -> Gen (TxOutValue era))
-> (ShelleyBasedEraConstraints era => Gen (TxOutValue era))
-> Gen (TxOutValue era)
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (Value (ShelleyLedgerEra era) -> TxOutValue era)
-> GenT Identity (Value (ShelleyLedgerEra era))
-> Gen (TxOutValue era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (Value (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era -> Gen (Value (ShelleyLedgerEra era))
genValueForTxOut ShelleyBasedEra era
sbe

genTxOutTxContext :: ShelleyBasedEra era -> Gen (TxOut CtxTx era)
genTxOutTxContext :: forall era. ShelleyBasedEra era -> Gen (TxOut CtxTx era)
genTxOutTxContext ShelleyBasedEra era
era =
  AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
    (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> GenT Identity (AddressInEra era)
-> GenT
     Identity
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (AddressInEra era)
forall era. ShelleyBasedEra era -> Gen (AddressInEra era)
genAddressInEra ShelleyBasedEra era
era
    GenT
  Identity
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> GenT Identity (TxOutValue era)
-> GenT
     Identity
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (TxOutValue era)
forall era. ShelleyBasedEra era -> Gen (TxOutValue era)
genTxOutValue ShelleyBasedEra era
era
    GenT
  Identity
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> GenT Identity (TxOutDatum CtxTx era)
-> GenT Identity (ReferenceScript era -> TxOut CtxTx era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (TxOutDatum CtxTx era)
forall era. ShelleyBasedEra era -> Gen (TxOutDatum CtxTx era)
genTxOutDatumHashTxContext ShelleyBasedEra era
era
    GenT Identity (ReferenceScript era -> TxOut CtxTx era)
-> GenT Identity (ReferenceScript era)
-> GenT Identity (TxOut CtxTx era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (ReferenceScript era)
forall era. ShelleyBasedEra era -> Gen (ReferenceScript era)
genReferenceScript ShelleyBasedEra era
era

genTxOutUTxOContext :: ShelleyBasedEra era -> Gen (TxOut CtxUTxO era)
genTxOutUTxOContext :: forall era. ShelleyBasedEra era -> Gen (TxOut CtxUTxO era)
genTxOutUTxOContext ShelleyBasedEra era
era =
  AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxUTxO era
-> ReferenceScript era
-> TxOut CtxUTxO era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
    (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxUTxO era
 -> ReferenceScript era
 -> TxOut CtxUTxO era)
-> GenT Identity (AddressInEra era)
-> GenT
     Identity
     (TxOutValue era
      -> TxOutDatum CtxUTxO era
      -> ReferenceScript era
      -> TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (AddressInEra era)
forall era. ShelleyBasedEra era -> Gen (AddressInEra era)
genAddressInEra ShelleyBasedEra era
era
    GenT
  Identity
  (TxOutValue era
   -> TxOutDatum CtxUTxO era
   -> ReferenceScript era
   -> TxOut CtxUTxO era)
-> GenT Identity (TxOutValue era)
-> GenT
     Identity
     (TxOutDatum CtxUTxO era
      -> ReferenceScript era -> TxOut CtxUTxO era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (TxOutValue era)
forall era. ShelleyBasedEra era -> Gen (TxOutValue era)
genTxOutValue ShelleyBasedEra era
era
    GenT
  Identity
  (TxOutDatum CtxUTxO era
   -> ReferenceScript era -> TxOut CtxUTxO era)
-> GenT Identity (TxOutDatum CtxUTxO era)
-> GenT Identity (ReferenceScript era -> TxOut CtxUTxO era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (TxOutDatum CtxUTxO era)
forall era. ShelleyBasedEra era -> Gen (TxOutDatum CtxUTxO era)
genTxOutDatumHashUTxOContext ShelleyBasedEra era
era
    GenT Identity (ReferenceScript era -> TxOut CtxUTxO era)
-> GenT Identity (ReferenceScript era)
-> GenT Identity (TxOut CtxUTxO era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ShelleyBasedEra era -> GenT Identity (ReferenceScript era)
forall era. ShelleyBasedEra era -> Gen (ReferenceScript era)
genReferenceScript ShelleyBasedEra era
era

genReferenceScript :: ShelleyBasedEra era -> Gen (ReferenceScript era)
genReferenceScript :: forall era. ShelleyBasedEra era -> Gen (ReferenceScript era)
genReferenceScript ShelleyBasedEra era
era = ScriptInEra era -> ReferenceScript era
forall era. ScriptInEra era -> ReferenceScript era
scriptInEraToRefScript (ScriptInEra era -> ReferenceScript era)
-> GenT Identity (ScriptInEra era)
-> GenT Identity (ReferenceScript era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (ScriptInEra era)
forall era. ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra ShelleyBasedEra era
era

genUTxO :: ShelleyBasedEra era -> Gen (UTxO era)
genUTxO :: forall era. ShelleyBasedEra era -> Gen (UTxO era)
genUTxO ShelleyBasedEra era
era =
  Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO
    (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> GenT Identity (Map TxIn (TxOut CtxUTxO era))
-> GenT Identity (UTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity (TxIn, TxOut CtxUTxO era)
-> GenT Identity (Map TxIn (TxOut CtxUTxO era))
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
5) ((,) (TxIn -> TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> Gen TxIn
-> GenT Identity (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn GenT Identity (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> GenT Identity (TxOut CtxUTxO era)
-> GenT Identity (TxIn, TxOut CtxUTxO era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (TxOut CtxTx era -> TxOut CtxUTxO era
forall era. TxOut CtxTx era -> TxOut CtxUTxO era
toCtxUTxOTxOut (TxOut CtxTx era -> TxOut CtxUTxO era)
-> GenT Identity (TxOut CtxTx era)
-> GenT Identity (TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (TxOut CtxTx era)
forall era. ShelleyBasedEra era -> Gen (TxOut CtxTx era)
genTxOutTxContext ShelleyBasedEra era
era))

genTtl :: Gen SlotNo
genTtl :: GenT Identity SlotNo
genTtl = GenT Identity SlotNo
genSlotNo

-- TODO: Accept a range for generating ttl.
genTxValidityLowerBound :: CardanoEra era -> Gen (TxValidityLowerBound era)
genTxValidityLowerBound :: forall era. CardanoEra era -> Gen (TxValidityLowerBound era)
genTxValidityLowerBound =
  Gen (TxValidityLowerBound era)
-> (AllegraEraOnwards era -> Gen (TxValidityLowerBound era))
-> CardanoEra era
-> Gen (TxValidityLowerBound era)
forall a era.
a -> (AllegraEraOnwards era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxValidityLowerBound era -> Gen (TxValidityLowerBound era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxValidityLowerBound era
forall era. TxValidityLowerBound era
TxValidityNoLowerBound)
    (\AllegraEraOnwards era
w -> AllegraEraOnwards era -> SlotNo -> TxValidityLowerBound era
forall era.
AllegraEraOnwards era -> SlotNo -> TxValidityLowerBound era
TxValidityLowerBound AllegraEraOnwards era
w (SlotNo -> TxValidityLowerBound era)
-> GenT Identity SlotNo -> Gen (TxValidityLowerBound era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SlotNo
genTtl)

-- TODO: Accept a range for generating ttl.
genTxValidityUpperBound :: ShelleyBasedEra era -> Gen (TxValidityUpperBound era)
genTxValidityUpperBound :: forall era. ShelleyBasedEra era -> Gen (TxValidityUpperBound era)
genTxValidityUpperBound ShelleyBasedEra era
sbe =
  ShelleyBasedEra era -> Maybe SlotNo -> TxValidityUpperBound era
forall era.
ShelleyBasedEra era -> Maybe SlotNo -> TxValidityUpperBound era
TxValidityUpperBound ShelleyBasedEra era
sbe (Maybe SlotNo -> TxValidityUpperBound era)
-> GenT Identity (Maybe SlotNo)
-> GenT Identity (TxValidityUpperBound era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity SlotNo -> GenT Identity (Maybe SlotNo)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity SlotNo
genTtl

genTxMetadataInEra :: CardanoEra era -> Gen (TxMetadataInEra era)
genTxMetadataInEra :: forall era. CardanoEra era -> Gen (TxMetadataInEra era)
genTxMetadataInEra =
  Gen (TxMetadataInEra era)
-> (ShelleyBasedEra era -> Gen (TxMetadataInEra era))
-> CardanoEra era
-> Gen (TxMetadataInEra era)
forall a era.
a -> (ShelleyBasedEra era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxMetadataInEra era -> Gen (TxMetadataInEra era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMetadataInEra era
forall era. TxMetadataInEra era
TxMetadataNone)
    ( \ShelleyBasedEra era
w ->
        [Gen (TxMetadataInEra era)] -> Gen (TxMetadataInEra era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
          [ TxMetadataInEra era -> Gen (TxMetadataInEra era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMetadataInEra era
forall era. TxMetadataInEra era
TxMetadataNone
          , ShelleyBasedEra era -> TxMetadata -> TxMetadataInEra era
forall era.
ShelleyBasedEra era -> TxMetadata -> TxMetadataInEra era
TxMetadataInEra ShelleyBasedEra era
w (TxMetadata -> TxMetadataInEra era)
-> GenT Identity TxMetadata -> Gen (TxMetadataInEra era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity TxMetadata
genTxMetadata
          ]
    )

genTxAuxScripts :: ShelleyBasedEra era -> Gen (TxAuxScripts era)
genTxAuxScripts :: forall era. ShelleyBasedEra era -> Gen (TxAuxScripts era)
genTxAuxScripts ShelleyBasedEra era
era =
  CardanoEra era
-> Gen (TxAuxScripts era)
-> (AllegraEraOnwards era -> Gen (TxAuxScripts era))
-> Gen (TxAuxScripts era)
forall (eon :: * -> *) era a.
Eon eon =>
CardanoEra era -> a -> (eon era -> a) -> a
forEraInEon
    (ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyBasedEra era
era)
    (TxAuxScripts era -> Gen (TxAuxScripts era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxAuxScripts era
forall era. TxAuxScripts era
TxAuxScriptsNone)
    ( \AllegraEraOnwards era
w ->
        AllegraEraOnwards era -> [ScriptInEra era] -> TxAuxScripts era
forall era.
AllegraEraOnwards era -> [ScriptInEra era] -> TxAuxScripts era
TxAuxScripts AllegraEraOnwards era
w
          ([ScriptInEra era] -> TxAuxScripts era)
-> GenT Identity [ScriptInEra era] -> Gen (TxAuxScripts era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity (ScriptInEra era)
-> GenT Identity [ScriptInEra era]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
            (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
3)
            (ShelleyBasedEra era -> GenT Identity (ScriptInEra era)
forall era. ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra (ShelleyBasedEra era -> GenT Identity (ScriptInEra era))
-> ShelleyBasedEra era -> GenT Identity (ScriptInEra era)
forall a b. (a -> b) -> a -> b
$ AllegraEraOnwards era -> ShelleyBasedEra era
forall era. AllegraEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert AllegraEraOnwards era
w)
    )

genTxWithdrawals :: CardanoEra era -> Gen (TxWithdrawals build era)
genTxWithdrawals :: forall era build. CardanoEra era -> Gen (TxWithdrawals build era)
genTxWithdrawals =
  Gen (TxWithdrawals build era)
-> (ShelleyBasedEra era -> Gen (TxWithdrawals build era))
-> CardanoEra era
-> Gen (TxWithdrawals build era)
forall a era.
a -> (ShelleyBasedEra era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxWithdrawals build era -> Gen (TxWithdrawals build era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxWithdrawals build era
forall build era. TxWithdrawals build era
TxWithdrawalsNone)
    ( \ShelleyBasedEra era
w ->
        [Gen (TxWithdrawals build era)] -> Gen (TxWithdrawals build era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
          [ TxWithdrawals build era -> Gen (TxWithdrawals build era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxWithdrawals build era
forall build era. TxWithdrawals build era
TxWithdrawalsNone
          , TxWithdrawals build era -> Gen (TxWithdrawals build era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShelleyBasedEra era
-> [(StakeAddress, Coin,
     BuildTxWith build (Witness WitCtxStake era))]
-> TxWithdrawals build era
forall era build.
ShelleyBasedEra era
-> [(StakeAddress, Coin,
     BuildTxWith build (Witness WitCtxStake era))]
-> TxWithdrawals build era
TxWithdrawals ShelleyBasedEra era
w [(StakeAddress, Coin, BuildTxWith build (Witness WitCtxStake era))]
forall a. Monoid a => a
mempty)
          -- TODO: Generate withdrawals
          ]
    )

genTxCertificates :: CardanoEra era -> Gen (TxCertificates BuildTx era)
genTxCertificates :: forall era. CardanoEra era -> Gen (TxCertificates BuildTx era)
genTxCertificates =
  Gen (TxCertificates BuildTx era)
-> (ShelleyBasedEra era -> Gen (TxCertificates BuildTx era))
-> CardanoEra era
-> Gen (TxCertificates BuildTx era)
forall a era.
a -> (ShelleyBasedEra era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxCertificates BuildTx era -> Gen (TxCertificates BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxCertificates BuildTx era
forall build era. TxCertificates build era
TxCertificatesNone)
    ( \ShelleyBasedEra era
w -> do
        [Certificate era]
certs <- Range Int
-> GenT Identity (Certificate era)
-> GenT Identity [Certificate era]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
3) (GenT Identity (Certificate era)
 -> GenT Identity [Certificate era])
-> GenT Identity (Certificate era)
-> GenT Identity [Certificate era]
forall a b. (a -> b) -> a -> b
$ ShelleyBasedEra era -> GenT Identity (Certificate era)
forall era. ShelleyBasedEra era -> Gen (Certificate era)
genCertificate ShelleyBasedEra era
w
        [Gen (TxCertificates BuildTx era)]
-> Gen (TxCertificates BuildTx era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
          [ TxCertificates BuildTx era -> Gen (TxCertificates BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxCertificates BuildTx era
forall build era. TxCertificates build era
TxCertificatesNone
          , TxCertificates BuildTx era -> Gen (TxCertificates BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShelleyBasedEra era
-> OMap
     (Certificate era)
     (BuildTxWith
        BuildTx (Maybe (StakeCredential, Witness WitCtxStake era)))
-> TxCertificates BuildTx era
forall era build.
ShelleyBasedEra era
-> OMap
     (Certificate era)
     (BuildTxWith
        build (Maybe (StakeCredential, Witness WitCtxStake era)))
-> TxCertificates build era
TxCertificates ShelleyBasedEra era
w (OMap
   (Certificate era)
   (BuildTxWith
      BuildTx (Maybe (StakeCredential, Witness WitCtxStake era)))
 -> TxCertificates BuildTx era)
-> OMap
     (Certificate era)
     (BuildTxWith
        BuildTx (Maybe (StakeCredential, Witness WitCtxStake era)))
-> TxCertificates BuildTx era
forall a b. (a -> b) -> a -> b
$ [Item
   (OMap
      (Certificate era)
      (BuildTxWith
         BuildTx (Maybe (StakeCredential, Witness WitCtxStake era))))]
-> OMap
     (Certificate era)
     (BuildTxWith
        BuildTx (Maybe (StakeCredential, Witness WitCtxStake era)))
forall l. IsList l => [Item l] -> l
fromList ((,Maybe (StakeCredential, Witness WitCtxStake era)
-> BuildTxWith
     BuildTx (Maybe (StakeCredential, Witness WitCtxStake era))
forall a. a -> BuildTxWith BuildTx a
BuildTxWith Maybe (StakeCredential, Witness WitCtxStake era)
forall a. Maybe a
Nothing) (Certificate era
 -> (Certificate era,
     BuildTxWith
       BuildTx (Maybe (StakeCredential, Witness WitCtxStake era))))
-> [Certificate era]
-> [(Certificate era,
     BuildTxWith
       BuildTx (Maybe (StakeCredential, Witness WitCtxStake era)))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Certificate era]
certs))
          -- TODO: Generate certificates
          ]
    )

genCertificate :: forall era. ShelleyBasedEra era -> Gen (Certificate era)
genCertificate :: forall era. ShelleyBasedEra era -> Gen (Certificate era)
genCertificate ShelleyBasedEra era
sbe =
  [GenT Identity (Certificate era)]
-> GenT Identity (Certificate era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    ([GenT Identity (Certificate era)]
 -> GenT Identity (Certificate era))
-> [GenT Identity (Certificate era)]
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> a -> b
$ [Maybe (GenT Identity (Certificate era))]
-> [GenT Identity (Certificate era)]
forall a. [Maybe a] -> [a]
catMaybes
    [ GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a. a -> Maybe a
Just (GenT Identity (Certificate era)
 -> Maybe (GenT Identity (Certificate era)))
-> GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ StakeDelegationRequirements era -> Certificate era
forall era. StakeDelegationRequirements era -> Certificate era
makeStakeAddressDelegationCertificate (StakeDelegationRequirements era -> Certificate era)
-> GenT Identity (StakeDelegationRequirements era)
-> GenT Identity (Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (StakeDelegationRequirements era)
forall era.
ShelleyBasedEra era -> Gen (StakeDelegationRequirements era)
genStakeDelegationRequirements ShelleyBasedEra era
sbe
    , GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a. a -> Maybe a
Just (GenT Identity (Certificate era)
 -> Maybe (GenT Identity (Certificate era)))
-> GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ StakeAddressRequirements era -> Certificate era
forall era. StakeAddressRequirements era -> Certificate era
makeStakeAddressRegistrationCertificate (StakeAddressRequirements era -> Certificate era)
-> GenT Identity (StakeAddressRequirements era)
-> GenT Identity (Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (StakeAddressRequirements era)
forall era.
ShelleyBasedEra era -> Gen (StakeAddressRequirements era)
genStakeAddressRequirements ShelleyBasedEra era
sbe
    , GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a. a -> Maybe a
Just (GenT Identity (Certificate era)
 -> Maybe (GenT Identity (Certificate era)))
-> GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ StakeAddressRequirements era -> Certificate era
forall era. StakeAddressRequirements era -> Certificate era
makeStakeAddressUnregistrationCertificate (StakeAddressRequirements era -> Certificate era)
-> GenT Identity (StakeAddressRequirements era)
-> GenT Identity (Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (StakeAddressRequirements era)
forall era.
ShelleyBasedEra era -> Gen (StakeAddressRequirements era)
genStakeAddressRequirements ShelleyBasedEra era
sbe
    , GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a. a -> Maybe a
Just (GenT Identity (Certificate era)
 -> Maybe (GenT Identity (Certificate era)))
-> GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ StakePoolRegistrationRequirements era -> Certificate era
forall era.
StakePoolRegistrationRequirements era -> Certificate era
makeStakePoolRegistrationCertificate (StakePoolRegistrationRequirements era -> Certificate era)
-> GenT Identity (StakePoolRegistrationRequirements era)
-> GenT Identity (Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (StakePoolRegistrationRequirements era)
forall era.
ShelleyBasedEra era -> Gen (StakePoolRegistrationRequirements era)
genStakePoolRegistrationRequirements ShelleyBasedEra era
sbe
    , GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a. a -> Maybe a
Just (GenT Identity (Certificate era)
 -> Maybe (GenT Identity (Certificate era)))
-> GenT Identity (Certificate era)
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ StakePoolRetirementRequirements era -> Certificate era
forall era. StakePoolRetirementRequirements era -> Certificate era
makeStakePoolRetirementCertificate (StakePoolRetirementRequirements era -> Certificate era)
-> GenT Identity (StakePoolRetirementRequirements era)
-> GenT Identity (Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (StakePoolRetirementRequirements era)
forall era.
ShelleyBasedEra era -> Gen (StakePoolRetirementRequirements era)
genStakePoolRetirementRequirements ShelleyBasedEra era
sbe
    , (CommitteeColdkeyResignationRequirements era -> Certificate era)
-> GenT Identity (CommitteeColdkeyResignationRequirements era)
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CommitteeColdkeyResignationRequirements era -> Certificate era
forall era.
CommitteeColdkeyResignationRequirements era -> Certificate era
makeCommitteeColdkeyResignationCertificate (GenT Identity (CommitteeColdkeyResignationRequirements era)
 -> GenT Identity (Certificate era))
-> Maybe
     (GenT Identity (CommitteeColdkeyResignationRequirements era))
-> Maybe (GenT Identity (Certificate era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ConwayEraOnwards era
 -> GenT Identity (CommitteeColdkeyResignationRequirements era))
-> Maybe
     (GenT Identity (CommitteeColdkeyResignationRequirements era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ConwayEraOnwards era
-> GenT Identity (CommitteeColdkeyResignationRequirements era)
forall era.
ConwayEraOnwards era
-> Gen (CommitteeColdkeyResignationRequirements era)
genCommitteeColdkeyResignationRequirements
    , (CommitteeHotKeyAuthorizationRequirements era -> Certificate era)
-> GenT Identity (CommitteeHotKeyAuthorizationRequirements era)
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CommitteeHotKeyAuthorizationRequirements era -> Certificate era
forall era.
CommitteeHotKeyAuthorizationRequirements era -> Certificate era
makeCommitteeHotKeyAuthorizationCertificate (GenT Identity (CommitteeHotKeyAuthorizationRequirements era)
 -> GenT Identity (Certificate era))
-> Maybe
     (GenT Identity (CommitteeHotKeyAuthorizationRequirements era))
-> Maybe (GenT Identity (Certificate era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ConwayEraOnwards era
 -> GenT Identity (CommitteeHotKeyAuthorizationRequirements era))
-> Maybe
     (GenT Identity (CommitteeHotKeyAuthorizationRequirements era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ConwayEraOnwards era
-> GenT Identity (CommitteeHotKeyAuthorizationRequirements era)
forall era.
ConwayEraOnwards era
-> Gen (CommitteeHotKeyAuthorizationRequirements era)
genCommitteeHotKeyAuthorizationRequirements
    , (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ((ConwayEraOnwards era -> GenT Identity (Certificate era))
 -> Maybe (GenT Identity (Certificate era)))
-> (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ \ConwayEraOnwards era
w ->
        DRepRegistrationRequirements era
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> Certificate era
forall era.
DRepRegistrationRequirements era
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> Certificate era
makeDrepRegistrationCertificate
          (DRepRegistrationRequirements era
 -> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
 -> Certificate era)
-> GenT Identity (DRepRegistrationRequirements era)
-> GenT
     Identity
     (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
      -> Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ConwayEraOnwards era
-> GenT Identity (DRepRegistrationRequirements era)
forall era.
ConwayEraOnwards era -> Gen (DRepRegistrationRequirements era)
genDRepRegistrationRequirements ConwayEraOnwards era
w
          GenT
  Identity
  (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
   -> Certificate era)
-> GenT
     Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era))))
-> GenT Identity (Certificate era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    GenT Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))))
-> GenT
     Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era))))
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w (GenT Identity (Anchor StandardCrypto)
-> GenT Identity (Maybe (Anchor StandardCrypto))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity (Anchor StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary)
    , (DRepUnregistrationRequirements era -> Certificate era)
-> GenT Identity (DRepUnregistrationRequirements era)
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DRepUnregistrationRequirements era -> Certificate era
forall era. DRepUnregistrationRequirements era -> Certificate era
makeDrepUnregistrationCertificate (GenT Identity (DRepUnregistrationRequirements era)
 -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (DRepUnregistrationRequirements era))
-> Maybe (GenT Identity (Certificate era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ConwayEraOnwards era
 -> GenT Identity (DRepUnregistrationRequirements era))
-> Maybe (GenT Identity (DRepUnregistrationRequirements era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ConwayEraOnwards era
-> GenT Identity (DRepUnregistrationRequirements era)
forall era.
ConwayEraOnwards era -> Gen (DRepUnregistrationRequirements era)
genDRepUnregistrationRequirements
    , (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ((ConwayEraOnwards era -> GenT Identity (Certificate era))
 -> Maybe (GenT Identity (Certificate era)))
-> (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ \ConwayEraOnwards era
w ->
        DRepUpdateRequirements era
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> Certificate era
forall era.
DRepUpdateRequirements era
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> Certificate era
makeDrepUpdateCertificate
          (DRepUpdateRequirements era
 -> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
 -> Certificate era)
-> GenT Identity (DRepUpdateRequirements era)
-> GenT
     Identity
     (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
      -> Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ConwayEraOnwards era -> GenT Identity (DRepUpdateRequirements era)
forall era.
ConwayEraOnwards era -> Gen (DRepUpdateRequirements era)
genDRepUpdateRequirements ConwayEraOnwards era
w
          GenT
  Identity
  (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
   -> Certificate era)
-> GenT
     Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era))))
-> GenT Identity (Certificate era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    GenT Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))))
-> GenT
     Identity (Maybe (Anchor (EraCrypto (ShelleyLedgerEra era))))
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w (GenT Identity (Anchor StandardCrypto)
-> GenT Identity (Maybe (Anchor StandardCrypto))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity (Anchor StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary)
    , (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ((ConwayEraOnwards era -> GenT Identity (Certificate era))
 -> Maybe (GenT Identity (Certificate era)))
-> (ConwayEraOnwards era -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (Certificate era))
forall a b. (a -> b) -> a -> b
$ \ConwayEraOnwards era
w ->
      ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    GenT Identity (Certificate era))
-> GenT Identity (Certificate era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  GenT Identity (Certificate era))
 -> GenT Identity (Certificate era))
-> (ConwayEraOnwardsConstraints era =>
    GenT Identity (Certificate era))
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> a -> b
$
        ConwayEraOnwards era
-> StakeCredential
-> Delegatee (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> Certificate era
forall era.
ConwayEraOnwards era
-> StakeCredential
-> Delegatee (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> Certificate era
makeStakeAddressAndDRepDelegationCertificate ConwayEraOnwards era
w
          (StakeCredential
 -> Delegatee StandardCrypto -> Coin -> Certificate era)
-> GenT Identity StakeCredential
-> GenT
     Identity (Delegatee StandardCrypto -> Coin -> Certificate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity StakeCredential
genStakeCredential
          GenT Identity (Delegatee StandardCrypto -> Coin -> Certificate era)
-> GenT Identity (Delegatee StandardCrypto)
-> GenT Identity (Coin -> Certificate era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (Delegatee StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
          GenT Identity (Coin -> Certificate era)
-> Gen Coin -> GenT Identity (Certificate era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
genLovelace
    , (MirCertificateRequirements era -> Certificate era)
-> GenT Identity (MirCertificateRequirements era)
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MirCertificateRequirements era -> Certificate era
forall era. MirCertificateRequirements era -> Certificate era
makeMIRCertificate (GenT Identity (MirCertificateRequirements era)
 -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (MirCertificateRequirements era))
-> Maybe (GenT Identity (Certificate era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ShelleyToBabbageEra era
 -> GenT Identity (MirCertificateRequirements era))
-> Maybe (GenT Identity (MirCertificateRequirements era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ShelleyToBabbageEra era
-> GenT Identity (MirCertificateRequirements era)
forall era.
ShelleyToBabbageEra era -> Gen (MirCertificateRequirements era)
genMirCertificateRequirements
    , (GenesisKeyDelegationRequirements era -> Certificate era)
-> GenT Identity (GenesisKeyDelegationRequirements era)
-> GenT Identity (Certificate era)
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GenesisKeyDelegationRequirements era -> Certificate era
forall era. GenesisKeyDelegationRequirements era -> Certificate era
makeGenesisKeyDelegationCertificate (GenT Identity (GenesisKeyDelegationRequirements era)
 -> GenT Identity (Certificate era))
-> Maybe (GenT Identity (GenesisKeyDelegationRequirements era))
-> Maybe (GenT Identity (Certificate era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ShelleyToBabbageEra era
 -> GenT Identity (GenesisKeyDelegationRequirements era))
-> Maybe (GenT Identity (GenesisKeyDelegationRequirements era))
forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe ShelleyToBabbageEra era
-> GenT Identity (GenesisKeyDelegationRequirements era)
forall era.
ShelleyToBabbageEra era
-> Gen (GenesisKeyDelegationRequirements era)
genGenesisKeyDelegationRequirements
    ]
  where
    forEonMaybe :: forall eon a. Eon eon => (eon era -> a) -> Maybe a
    forEonMaybe :: forall (eon :: * -> *) a. Eon eon => (eon era -> a) -> Maybe a
forEonMaybe eon era -> a
f = (eon era -> a) -> ShelleyBasedEra era -> Maybe a
forall (eon :: * -> *) era a.
Eon eon =>
(eon era -> a) -> ShelleyBasedEra era -> Maybe a
inEonForShelleyBasedEraMaybe eon era -> a
f ShelleyBasedEra era
sbe

genStakeDelegationRequirements :: ShelleyBasedEra era -> Gen (StakeDelegationRequirements era)
genStakeDelegationRequirements :: forall era.
ShelleyBasedEra era -> Gen (StakeDelegationRequirements era)
genStakeDelegationRequirements =
  (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Gen (StakeDelegationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Gen (StakeDelegationRequirements era))
-> ShelleyBasedEra era
-> Gen (StakeDelegationRequirements era)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
    ( \ShelleyToBabbageEra era
w ->
      ShelleyToBabbageEra era
-> StakeCredential -> PoolId -> StakeDelegationRequirements era
forall era.
ShelleyToBabbageEra era
-> StakeCredential -> PoolId -> StakeDelegationRequirements era
StakeDelegationRequirementsPreConway ShelleyToBabbageEra era
w
          (StakeCredential -> PoolId -> StakeDelegationRequirements era)
-> GenT Identity StakeCredential
-> GenT Identity (PoolId -> StakeDelegationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity StakeCredential
genStakeCredential
          GenT Identity (PoolId -> StakeDelegationRequirements era)
-> GenT Identity PoolId -> Gen (StakeDelegationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AsType StakePoolKey -> GenT Identity PoolId
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType StakePoolKey
AsStakePoolKey
    )
    ( \ConwayEraOnwards era
w ->
      ConwayEraOnwards era
-> StakeCredential
-> Delegatee (EraCrypto (ShelleyLedgerEra era))
-> StakeDelegationRequirements era
forall era.
ConwayEraOnwards era
-> StakeCredential
-> Delegatee (EraCrypto (ShelleyLedgerEra era))
-> StakeDelegationRequirements era
StakeDelegationRequirementsConwayOnwards ConwayEraOnwards era
w
          (StakeCredential
 -> Delegatee StandardCrypto -> StakeDelegationRequirements era)
-> GenT Identity StakeCredential
-> GenT
     Identity
     (Delegatee StandardCrypto -> StakeDelegationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity StakeCredential
genStakeCredential
          GenT
  Identity
  (Delegatee StandardCrypto -> StakeDelegationRequirements era)
-> GenT Identity (Delegatee StandardCrypto)
-> Gen (StakeDelegationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (Delegatee StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
    )

genStakeAddressRequirements :: ShelleyBasedEra era -> Gen (StakeAddressRequirements era)
genStakeAddressRequirements :: forall era.
ShelleyBasedEra era -> Gen (StakeAddressRequirements era)
genStakeAddressRequirements =
  (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> Gen (StakeAddressRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Gen (StakeAddressRequirements era))
-> ShelleyBasedEra era
-> Gen (StakeAddressRequirements era)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
    ( \ShelleyToBabbageEra era
w ->
      ShelleyToBabbageEra era
-> StakeCredential -> StakeAddressRequirements era
forall era.
ShelleyToBabbageEra era
-> StakeCredential -> StakeAddressRequirements era
StakeAddrRegistrationPreConway ShelleyToBabbageEra era
w
          (StakeCredential -> StakeAddressRequirements era)
-> GenT Identity StakeCredential
-> Gen (StakeAddressRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity StakeCredential
genStakeCredential
    )
    ( \ConwayEraOnwards era
w ->
      ConwayEraOnwards era
-> Coin -> StakeCredential -> StakeAddressRequirements era
forall era.
ConwayEraOnwards era
-> Coin -> StakeCredential -> StakeAddressRequirements era
StakeAddrRegistrationConway ConwayEraOnwards era
w
          (Coin -> StakeCredential -> StakeAddressRequirements era)
-> Gen Coin
-> GenT Identity (StakeCredential -> StakeAddressRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genLovelace
          GenT Identity (StakeCredential -> StakeAddressRequirements era)
-> GenT Identity StakeCredential
-> Gen (StakeAddressRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity StakeCredential
genStakeCredential
    )

genStakePoolRegistrationRequirements :: ShelleyBasedEra era -> Gen (StakePoolRegistrationRequirements era)
genStakePoolRegistrationRequirements :: forall era.
ShelleyBasedEra era -> Gen (StakePoolRegistrationRequirements era)
genStakePoolRegistrationRequirements =
  (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era
 -> Gen (StakePoolRegistrationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era
    -> Gen (StakePoolRegistrationRequirements era))
-> ShelleyBasedEra era
-> Gen (StakePoolRegistrationRequirements era)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
    ( \ShelleyToBabbageEra era
w ->
      ShelleyToBabbageEra era
-> PoolParams (EraCrypto (ShelleyLedgerEra era))
-> StakePoolRegistrationRequirements era
forall era.
ShelleyToBabbageEra era
-> PoolParams (EraCrypto (ShelleyLedgerEra era))
-> StakePoolRegistrationRequirements era
StakePoolRegistrationRequirementsPreConway ShelleyToBabbageEra era
w
          (PoolParams StandardCrypto
 -> StakePoolRegistrationRequirements era)
-> GenT Identity (PoolParams StandardCrypto)
-> Gen (StakePoolRegistrationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (PoolParams StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
    )
    ( \ConwayEraOnwards era
w ->
      ConwayEraOnwards era
-> PoolParams (EraCrypto (ShelleyLedgerEra era))
-> StakePoolRegistrationRequirements era
forall era.
ConwayEraOnwards era
-> PoolParams (EraCrypto (ShelleyLedgerEra era))
-> StakePoolRegistrationRequirements era
StakePoolRegistrationRequirementsConwayOnwards ConwayEraOnwards era
w
          (PoolParams StandardCrypto
 -> StakePoolRegistrationRequirements era)
-> GenT Identity (PoolParams StandardCrypto)
-> Gen (StakePoolRegistrationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (PoolParams StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
    )

genStakePoolRetirementRequirements :: ShelleyBasedEra era -> Gen (StakePoolRetirementRequirements era)
genStakePoolRetirementRequirements :: forall era.
ShelleyBasedEra era -> Gen (StakePoolRetirementRequirements era)
genStakePoolRetirementRequirements =
  (ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era
 -> Gen (StakePoolRetirementRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    ConwayEraOnwards era -> Gen (StakePoolRetirementRequirements era))
-> ShelleyBasedEra era
-> Gen (StakePoolRetirementRequirements era)
forall era a.
(ShelleyToBabbageEraConstraints era =>
 ShelleyToBabbageEra era -> a)
-> (ConwayEraOnwardsConstraints era => ConwayEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToBabbageOrConwayEraOnwards
    ( \ShelleyToBabbageEra era
w ->
      ShelleyToBabbageEra era
-> PoolId -> EpochNo -> StakePoolRetirementRequirements era
forall era.
ShelleyToBabbageEra era
-> PoolId -> EpochNo -> StakePoolRetirementRequirements era
StakePoolRetirementRequirementsPreConway ShelleyToBabbageEra era
w
          (PoolId -> EpochNo -> StakePoolRetirementRequirements era)
-> GenT Identity PoolId
-> GenT Identity (EpochNo -> StakePoolRetirementRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType StakePoolKey -> GenT Identity PoolId
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType StakePoolKey
AsStakePoolKey
          GenT Identity (EpochNo -> StakePoolRetirementRequirements era)
-> GenT Identity EpochNo
-> Gen (StakePoolRetirementRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity EpochNo
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
    )
    ( \ConwayEraOnwards era
w ->
      ConwayEraOnwards era
-> PoolId -> EpochNo -> StakePoolRetirementRequirements era
forall era.
ConwayEraOnwards era
-> PoolId -> EpochNo -> StakePoolRetirementRequirements era
StakePoolRetirementRequirementsConwayOnwards ConwayEraOnwards era
w
          (PoolId -> EpochNo -> StakePoolRetirementRequirements era)
-> GenT Identity PoolId
-> GenT Identity (EpochNo -> StakePoolRetirementRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType StakePoolKey -> GenT Identity PoolId
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType StakePoolKey
AsStakePoolKey
          GenT Identity (EpochNo -> StakePoolRetirementRequirements era)
-> GenT Identity EpochNo
-> Gen (StakePoolRetirementRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity EpochNo
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
    )

genCommitteeColdkeyResignationRequirements :: ConwayEraOnwards era -> Gen (CommitteeColdkeyResignationRequirements era)
genCommitteeColdkeyResignationRequirements :: forall era.
ConwayEraOnwards era
-> Gen (CommitteeColdkeyResignationRequirements era)
genCommitteeColdkeyResignationRequirements ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (CommitteeColdkeyResignationRequirements era))
-> Gen (CommitteeColdkeyResignationRequirements era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (CommitteeColdkeyResignationRequirements era))
 -> Gen (CommitteeColdkeyResignationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (CommitteeColdkeyResignationRequirements era))
-> Gen (CommitteeColdkeyResignationRequirements era)
forall a b. (a -> b) -> a -> b
$
    ConwayEraOnwards era
-> Credential 'ColdCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> CommitteeColdkeyResignationRequirements era
forall era.
ConwayEraOnwards era
-> Credential 'ColdCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> Maybe (Anchor (EraCrypto (ShelleyLedgerEra era)))
-> CommitteeColdkeyResignationRequirements era
CommitteeColdkeyResignationRequirements ConwayEraOnwards era
w (Credential 'ColdCommitteeRole StandardCrypto
 -> Maybe (Anchor StandardCrypto)
 -> CommitteeColdkeyResignationRequirements era)
-> GenT Identity (Credential 'ColdCommitteeRole StandardCrypto)
-> GenT
     Identity
     (Maybe (Anchor StandardCrypto)
      -> CommitteeColdkeyResignationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Credential 'ColdCommitteeRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary GenT
  Identity
  (Maybe (Anchor StandardCrypto)
   -> CommitteeColdkeyResignationRequirements era)
-> GenT Identity (Maybe (Anchor StandardCrypto))
-> Gen (CommitteeColdkeyResignationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (Anchor StandardCrypto)
-> GenT Identity (Maybe (Anchor StandardCrypto))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity (Anchor StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genCommitteeHotKeyAuthorizationRequirements :: ConwayEraOnwards era -> Gen (CommitteeHotKeyAuthorizationRequirements era)
genCommitteeHotKeyAuthorizationRequirements :: forall era.
ConwayEraOnwards era
-> Gen (CommitteeHotKeyAuthorizationRequirements era)
genCommitteeHotKeyAuthorizationRequirements ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (CommitteeHotKeyAuthorizationRequirements era))
-> Gen (CommitteeHotKeyAuthorizationRequirements era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (CommitteeHotKeyAuthorizationRequirements era))
 -> Gen (CommitteeHotKeyAuthorizationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (CommitteeHotKeyAuthorizationRequirements era))
-> Gen (CommitteeHotKeyAuthorizationRequirements era)
forall a b. (a -> b) -> a -> b
$
    ConwayEraOnwards era
-> Credential 'ColdCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> Credential 'HotCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> CommitteeHotKeyAuthorizationRequirements era
forall era.
ConwayEraOnwards era
-> Credential 'ColdCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> Credential 'HotCommitteeRole (EraCrypto (ShelleyLedgerEra era))
-> CommitteeHotKeyAuthorizationRequirements era
CommitteeHotKeyAuthorizationRequirements ConwayEraOnwards era
w (Credential 'ColdCommitteeRole StandardCrypto
 -> Credential 'HotCommitteeRole StandardCrypto
 -> CommitteeHotKeyAuthorizationRequirements era)
-> GenT Identity (Credential 'ColdCommitteeRole StandardCrypto)
-> GenT
     Identity
     (Credential 'HotCommitteeRole StandardCrypto
      -> CommitteeHotKeyAuthorizationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Credential 'ColdCommitteeRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary GenT
  Identity
  (Credential 'HotCommitteeRole StandardCrypto
   -> CommitteeHotKeyAuthorizationRequirements era)
-> GenT Identity (Credential 'HotCommitteeRole StandardCrypto)
-> Gen (CommitteeHotKeyAuthorizationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (Credential 'HotCommitteeRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genDRepRegistrationRequirements :: ConwayEraOnwards era -> Gen (DRepRegistrationRequirements era)
genDRepRegistrationRequirements :: forall era.
ConwayEraOnwards era -> Gen (DRepRegistrationRequirements era)
genDRepRegistrationRequirements ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepRegistrationRequirements era))
-> Gen (DRepRegistrationRequirements era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (DRepRegistrationRequirements era))
 -> Gen (DRepRegistrationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepRegistrationRequirements era))
-> Gen (DRepRegistrationRequirements era)
forall a b. (a -> b) -> a -> b
$
    ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> DRepRegistrationRequirements era
forall era.
ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> DRepRegistrationRequirements era
DRepRegistrationRequirements ConwayEraOnwards era
w (Credential 'DRepRole StandardCrypto
 -> Coin -> DRepRegistrationRequirements era)
-> GenT Identity (Credential 'DRepRole StandardCrypto)
-> GenT Identity (Coin -> DRepRegistrationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Credential 'DRepRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary GenT Identity (Coin -> DRepRegistrationRequirements era)
-> Gen Coin -> Gen (DRepRegistrationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
genLovelace

genDRepUnregistrationRequirements :: ConwayEraOnwards era -> Gen (DRepUnregistrationRequirements era)
genDRepUnregistrationRequirements :: forall era.
ConwayEraOnwards era -> Gen (DRepUnregistrationRequirements era)
genDRepUnregistrationRequirements ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepUnregistrationRequirements era))
-> Gen (DRepUnregistrationRequirements era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (DRepUnregistrationRequirements era))
 -> Gen (DRepUnregistrationRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepUnregistrationRequirements era))
-> Gen (DRepUnregistrationRequirements era)
forall a b. (a -> b) -> a -> b
$
    ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> DRepUnregistrationRequirements era
forall era.
ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> Coin
-> DRepUnregistrationRequirements era
DRepUnregistrationRequirements ConwayEraOnwards era
w (Credential 'DRepRole StandardCrypto
 -> Coin -> DRepUnregistrationRequirements era)
-> GenT Identity (Credential 'DRepRole StandardCrypto)
-> GenT Identity (Coin -> DRepUnregistrationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Credential 'DRepRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary  GenT Identity (Coin -> DRepUnregistrationRequirements era)
-> Gen Coin -> Gen (DRepUnregistrationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
genLovelace

genDRepUpdateRequirements :: ConwayEraOnwards era -> Gen (DRepUpdateRequirements era)
genDRepUpdateRequirements :: forall era.
ConwayEraOnwards era -> Gen (DRepUpdateRequirements era)
genDRepUpdateRequirements ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepUpdateRequirements era))
-> Gen (DRepUpdateRequirements era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (DRepUpdateRequirements era))
 -> Gen (DRepUpdateRequirements era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (DRepUpdateRequirements era))
-> Gen (DRepUpdateRequirements era)
forall a b. (a -> b) -> a -> b
$
    ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> DRepUpdateRequirements era
forall era.
ConwayEraOnwards era
-> Credential 'DRepRole (EraCrypto (ShelleyLedgerEra era))
-> DRepUpdateRequirements era
DRepUpdateRequirements ConwayEraOnwards era
w (Credential 'DRepRole StandardCrypto -> DRepUpdateRequirements era)
-> GenT Identity (Credential 'DRepRole StandardCrypto)
-> Gen (DRepUpdateRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Credential 'DRepRole StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genGenesisKeyDelegationRequirements :: ShelleyToBabbageEra era -> Gen (GenesisKeyDelegationRequirements era)
genGenesisKeyDelegationRequirements :: forall era.
ShelleyToBabbageEra era
-> Gen (GenesisKeyDelegationRequirements era)
genGenesisKeyDelegationRequirements ShelleyToBabbageEra era
w =
  ShelleyToBabbageEra era
-> (ShelleyToBabbageEraConstraints era =>
    Gen (GenesisKeyDelegationRequirements era))
-> Gen (GenesisKeyDelegationRequirements era)
forall era a.
ShelleyToBabbageEra era
-> (ShelleyToBabbageEraConstraints era => a) -> a
shelleyToBabbageEraConstraints ShelleyToBabbageEra era
w ((ShelleyToBabbageEraConstraints era =>
  Gen (GenesisKeyDelegationRequirements era))
 -> Gen (GenesisKeyDelegationRequirements era))
-> (ShelleyToBabbageEraConstraints era =>
    Gen (GenesisKeyDelegationRequirements era))
-> Gen (GenesisKeyDelegationRequirements era)
forall a b. (a -> b) -> a -> b
$
    ShelleyToBabbageEra era
-> Hash GenesisKey
-> Hash GenesisDelegateKey
-> Hash VrfKey
-> GenesisKeyDelegationRequirements era
forall era.
ShelleyToBabbageEra era
-> Hash GenesisKey
-> Hash GenesisDelegateKey
-> Hash VrfKey
-> GenesisKeyDelegationRequirements era
GenesisKeyDelegationRequirements ShelleyToBabbageEra era
w
     (Hash GenesisKey
 -> Hash GenesisDelegateKey
 -> Hash VrfKey
 -> GenesisKeyDelegationRequirements era)
-> GenT Identity (Hash GenesisKey)
-> GenT
     Identity
     (Hash GenesisDelegateKey
      -> Hash VrfKey -> GenesisKeyDelegationRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType GenesisKey -> GenT Identity (Hash GenesisKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType GenesisKey
AsGenesisKey
     GenT
  Identity
  (Hash GenesisDelegateKey
   -> Hash VrfKey -> GenesisKeyDelegationRequirements era)
-> GenT Identity (Hash GenesisDelegateKey)
-> GenT
     Identity (Hash VrfKey -> GenesisKeyDelegationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AsType GenesisDelegateKey
-> GenT Identity (Hash GenesisDelegateKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType GenesisDelegateKey
AsGenesisDelegateKey
     GenT Identity (Hash VrfKey -> GenesisKeyDelegationRequirements era)
-> GenT Identity (Hash VrfKey)
-> Gen (GenesisKeyDelegationRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AsType VrfKey -> GenT Identity (Hash VrfKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType VrfKey
AsVrfKey

genMirCertificateRequirements :: ShelleyToBabbageEra era -> Gen (MirCertificateRequirements era)
genMirCertificateRequirements :: forall era.
ShelleyToBabbageEra era -> Gen (MirCertificateRequirements era)
genMirCertificateRequirements ShelleyToBabbageEra era
w =
  ShelleyToBabbageEra era
-> (ShelleyToBabbageEraConstraints era =>
    Gen (MirCertificateRequirements era))
-> Gen (MirCertificateRequirements era)
forall era a.
ShelleyToBabbageEra era
-> (ShelleyToBabbageEraConstraints era => a) -> a
shelleyToBabbageEraConstraints ShelleyToBabbageEra era
w ((ShelleyToBabbageEraConstraints era =>
  Gen (MirCertificateRequirements era))
 -> Gen (MirCertificateRequirements era))
-> (ShelleyToBabbageEraConstraints era =>
    Gen (MirCertificateRequirements era))
-> Gen (MirCertificateRequirements era)
forall a b. (a -> b) -> a -> b
$
    ShelleyToBabbageEra era
-> MIRPot
-> MIRTarget (EraCrypto (ShelleyLedgerEra era))
-> MirCertificateRequirements era
forall era.
ShelleyToBabbageEra era
-> MIRPot
-> MIRTarget (EraCrypto (ShelleyLedgerEra era))
-> MirCertificateRequirements era
MirCertificateRequirements ShelleyToBabbageEra era
w (MIRPot
 -> MIRTarget StandardCrypto -> MirCertificateRequirements era)
-> GenT Identity MIRPot
-> GenT
     Identity
     (MIRTarget StandardCrypto -> MirCertificateRequirements era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity MIRPot
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary GenT
  Identity
  (MIRTarget StandardCrypto -> MirCertificateRequirements era)
-> GenT Identity (MIRTarget StandardCrypto)
-> Gen (MirCertificateRequirements era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (MIRTarget StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genTxUpdateProposal :: CardanoEra era -> Gen (TxUpdateProposal era)
genTxUpdateProposal :: forall era. CardanoEra era -> Gen (TxUpdateProposal era)
genTxUpdateProposal CardanoEra era
sbe =
  [GenT Identity (TxUpdateProposal era)]
-> GenT Identity (TxUpdateProposal era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice ([GenT Identity (TxUpdateProposal era)]
 -> GenT Identity (TxUpdateProposal era))
-> [GenT Identity (TxUpdateProposal era)]
-> GenT Identity (TxUpdateProposal era)
forall a b. (a -> b) -> a -> b
$
    [Maybe (GenT Identity (TxUpdateProposal era))]
-> [GenT Identity (TxUpdateProposal era)]
forall a. [Maybe a] -> [a]
catMaybes
      [ GenT Identity (TxUpdateProposal era)
-> Maybe (GenT Identity (TxUpdateProposal era))
forall a. a -> Maybe a
Just (GenT Identity (TxUpdateProposal era)
 -> Maybe (GenT Identity (TxUpdateProposal era)))
-> GenT Identity (TxUpdateProposal era)
-> Maybe (GenT Identity (TxUpdateProposal era))
forall a b. (a -> b) -> a -> b
$ TxUpdateProposal era -> GenT Identity (TxUpdateProposal era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxUpdateProposal era
forall era. TxUpdateProposal era
TxUpdateProposalNone
      , CardanoEra era
-> Maybe (GenT Identity (TxUpdateProposal era))
-> (ShelleyToBabbageEra era
    -> Maybe (GenT Identity (TxUpdateProposal era)))
-> Maybe (GenT Identity (TxUpdateProposal era))
forall (eon :: * -> *) era a.
Eon eon =>
CardanoEra era -> a -> (eon era -> a) -> a
forEraInEon CardanoEra era
sbe Maybe (GenT Identity (TxUpdateProposal era))
forall a. Maybe a
Nothing ((ShelleyToBabbageEra era
  -> Maybe (GenT Identity (TxUpdateProposal era)))
 -> Maybe (GenT Identity (TxUpdateProposal era)))
-> (ShelleyToBabbageEra era
    -> Maybe (GenT Identity (TxUpdateProposal era)))
-> Maybe (GenT Identity (TxUpdateProposal era))
forall a b. (a -> b) -> a -> b
$ \ShelleyToBabbageEra era
w ->
          GenT Identity (TxUpdateProposal era)
-> Maybe (GenT Identity (TxUpdateProposal era))
forall a. a -> Maybe a
Just (GenT Identity (TxUpdateProposal era)
 -> Maybe (GenT Identity (TxUpdateProposal era)))
-> GenT Identity (TxUpdateProposal era)
-> Maybe (GenT Identity (TxUpdateProposal era))
forall a b. (a -> b) -> a -> b
$ ShelleyToBabbageEra era -> UpdateProposal -> TxUpdateProposal era
forall era.
ShelleyToBabbageEra era -> UpdateProposal -> TxUpdateProposal era
TxUpdateProposal ShelleyToBabbageEra era
w (UpdateProposal -> TxUpdateProposal era)
-> GenT Identity UpdateProposal
-> GenT Identity (TxUpdateProposal era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CardanoEra era -> GenT Identity UpdateProposal
forall era. CardanoEra era -> GenT Identity UpdateProposal
genUpdateProposal (ShelleyToBabbageEra era -> CardanoEra era
forall era. ShelleyToBabbageEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyToBabbageEra era
w)
      ]

genTxMintValue :: CardanoEra era -> Gen (TxMintValue BuildTx era)
genTxMintValue :: forall era. CardanoEra era -> Gen (TxMintValue BuildTx era)
genTxMintValue =
  Gen (TxMintValue BuildTx era)
-> (MaryEraOnwards era -> Gen (TxMintValue BuildTx era))
-> CardanoEra era
-> Gen (TxMintValue BuildTx era)
forall a era. a -> (MaryEraOnwards era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxMintValue BuildTx era -> Gen (TxMintValue BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMintValue BuildTx era
forall build era. TxMintValue build era
TxMintNone)
    ((MaryEraOnwards era -> Gen (TxMintValue BuildTx era))
 -> CardanoEra era -> Gen (TxMintValue BuildTx era))
-> (MaryEraOnwards era -> Gen (TxMintValue BuildTx era))
-> CardanoEra era
-> Gen (TxMintValue BuildTx era)
forall a b. (a -> b) -> a -> b
$ \MaryEraOnwards era
w -> do
      [PolicyId]
policies <- Range Int -> Gen PolicyId -> GenT Identity [PolicyId]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
3) Gen PolicyId
genPolicyId
      [(PolicyId,
  [(AssetName, Quantity,
    BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
assets <- [PolicyId]
-> (PolicyId
    -> GenT
         Identity
         (PolicyId,
          [(AssetName, Quantity,
            BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]))
-> GenT
     Identity
     [(PolicyId,
       [(AssetName, Quantity,
         BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [PolicyId]
policies ((PolicyId
  -> GenT
       Identity
       (PolicyId,
        [(AssetName, Quantity,
          BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]))
 -> GenT
      Identity
      [(PolicyId,
        [(AssetName, Quantity,
          BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])])
-> (PolicyId
    -> GenT
         Identity
         (PolicyId,
          [(AssetName, Quantity,
            BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]))
-> GenT
     Identity
     [(PolicyId,
       [(AssetName, Quantity,
         BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
forall a b. (a -> b) -> a -> b
$ \PolicyId
policy ->
        (,) PolicyId
policy ([(AssetName, Quantity,
   BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]
 -> (PolicyId,
     [(AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]))
-> GenT
     Identity
     [(AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]
-> GenT
     Identity
     (PolicyId,
      [(AssetName, Quantity,
        BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          Range Int
-> GenT
     Identity
     (AssetName, Quantity,
      BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
-> GenT
     Identity
     [(AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list
            (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
3)
            ((,,) (AssetName
 -> Quantity
 -> BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
 -> (AssetName, Quantity,
     BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
-> Gen AssetName
-> GenT
     Identity
     (Quantity
      -> BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
      -> (AssetName, Quantity,
          BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen AssetName
genAssetName
                  GenT
  Identity
  (Quantity
   -> BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
   -> (AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
-> Gen Quantity
-> GenT
     Identity
     (BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
      -> (AssetName, Quantity,
          BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Quantity
genPositiveQuantity
                  GenT
  Identity
  (BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
   -> (AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
-> GenT
     Identity (BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
-> GenT
     Identity
     (AssetName, Quantity,
      BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (GenT Identity (ScriptWitness WitCtxMint era)
 -> GenT
      Identity (BuildTxWith BuildTx (ScriptWitness WitCtxMint era)))
-> (ShelleyBasedEra era
    -> GenT Identity (ScriptWitness WitCtxMint era))
-> ShelleyBasedEra era
-> GenT
     Identity (BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
forall a b.
(a -> b) -> (ShelleyBasedEra era -> a) -> ShelleyBasedEra era -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((ScriptWitness WitCtxMint era
 -> BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
-> GenT Identity (ScriptWitness WitCtxMint era)
-> GenT
     Identity (BuildTxWith BuildTx (ScriptWitness WitCtxMint era))
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ScriptWitness WitCtxMint era
-> BuildTxWith BuildTx (ScriptWitness WitCtxMint era)
forall a. a -> BuildTxWith BuildTx a
forall (f :: * -> *) a. Applicative f => a -> f a
pure) ShelleyBasedEra era -> GenT Identity (ScriptWitness WitCtxMint era)
forall era.
ShelleyBasedEra era -> Gen (ScriptWitness WitCtxMint era)
genScriptWitnessForMint (MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
maryEraOnwardsToShelleyBasedEra MaryEraOnwards era
w))
      [Gen (TxMintValue BuildTx era)] -> Gen (TxMintValue BuildTx era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
        [ TxMintValue BuildTx era -> Gen (TxMintValue BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMintValue BuildTx era
forall build era. TxMintValue build era
TxMintNone
        , TxMintValue BuildTx era -> Gen (TxMintValue BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxMintValue BuildTx era -> Gen (TxMintValue BuildTx era))
-> TxMintValue BuildTx era -> Gen (TxMintValue BuildTx era)
forall a b. (a -> b) -> a -> b
$ MaryEraOnwards era
-> Map
     PolicyId
     [(AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]
-> TxMintValue BuildTx era
forall era build.
MaryEraOnwards era
-> Map
     PolicyId
     [(AssetName, Quantity,
       BuildTxWith build (ScriptWitness WitCtxMint era))]
-> TxMintValue build era
TxMintValue MaryEraOnwards era
w ([Item
   (Map
      PolicyId
      [(AssetName, Quantity,
        BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
-> Map
     PolicyId
     [(AssetName, Quantity,
       BuildTxWith BuildTx (ScriptWitness WitCtxMint era))]
forall l. IsList l => [Item l] -> l
fromList [(PolicyId,
  [(AssetName, Quantity,
    BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
[Item
   (Map
      PolicyId
      [(AssetName, Quantity,
        BuildTxWith BuildTx (ScriptWitness WitCtxMint era))])]
assets)
        ]

genTxBodyContent :: ShelleyBasedEra era -> Gen (TxBodyContent BuildTx era)
genTxBodyContent :: forall era. ShelleyBasedEra era -> Gen (TxBodyContent BuildTx era)
genTxBodyContent ShelleyBasedEra era
sbe = do
  let era :: CardanoEra era
era = ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyBasedEra era
sbe
  [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
txIns <-
    (TxIn -> (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era)))
-> [TxIn] -> [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
forall a b. (a -> b) -> [a] -> [b]
map (,Witness WitCtxTxIn era
-> BuildTxWith BuildTx (Witness WitCtxTxIn era)
forall a. a -> BuildTxWith BuildTx a
BuildTxWith (KeyWitnessInCtx WitCtxTxIn -> Witness WitCtxTxIn era
forall witctx era. KeyWitnessInCtx witctx -> Witness witctx era
KeyWitness KeyWitnessInCtx WitCtxTxIn
KeyWitnessForSpending)) ([TxIn] -> [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))])
-> GenT Identity [TxIn]
-> GenT
     Identity [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> Gen TxIn -> GenT Identity [TxIn]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) Gen TxIn
genTxIn
  TxInsCollateral era
txInsCollateral <- CardanoEra era -> Gen (TxInsCollateral era)
forall era. CardanoEra era -> Gen (TxInsCollateral era)
genTxInsCollateral CardanoEra era
era
  TxInsReference era
txInsReference <- CardanoEra era -> Gen (TxInsReference era)
forall era. CardanoEra era -> Gen (TxInsReference era)
genTxInsReference CardanoEra era
era
  [TxOut CtxTx era]
txOuts <- Range Int
-> GenT Identity (TxOut CtxTx era)
-> GenT Identity [TxOut CtxTx era]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) (ShelleyBasedEra era -> GenT Identity (TxOut CtxTx era)
forall era. ShelleyBasedEra era -> Gen (TxOut CtxTx era)
genTxOutTxContext ShelleyBasedEra era
sbe)
  TxTotalCollateral era
txTotalCollateral <- CardanoEra era -> Gen (TxTotalCollateral era)
forall era. CardanoEra era -> Gen (TxTotalCollateral era)
genTxTotalCollateral CardanoEra era
era
  TxReturnCollateral CtxTx era
txReturnCollateral <- ShelleyBasedEra era -> Gen (TxReturnCollateral CtxTx era)
forall era.
ShelleyBasedEra era -> Gen (TxReturnCollateral CtxTx era)
genTxReturnCollateral ShelleyBasedEra era
sbe
  TxFee era
txFee <- ShelleyBasedEra era -> Gen (TxFee era)
forall era. ShelleyBasedEra era -> Gen (TxFee era)
genTxFee ShelleyBasedEra era
sbe
  TxValidityLowerBound era
txValidityLowerBound <- CardanoEra era -> Gen (TxValidityLowerBound era)
forall era. CardanoEra era -> Gen (TxValidityLowerBound era)
genTxValidityLowerBound CardanoEra era
era
  TxValidityUpperBound era
txValidityUpperBound <- ShelleyBasedEra era -> Gen (TxValidityUpperBound era)
forall era. ShelleyBasedEra era -> Gen (TxValidityUpperBound era)
genTxValidityUpperBound ShelleyBasedEra era
sbe
  TxMetadataInEra era
txMetadata <- CardanoEra era -> Gen (TxMetadataInEra era)
forall era. CardanoEra era -> Gen (TxMetadataInEra era)
genTxMetadataInEra CardanoEra era
era
  TxAuxScripts era
txAuxScripts <- ShelleyBasedEra era -> Gen (TxAuxScripts era)
forall era. ShelleyBasedEra era -> Gen (TxAuxScripts era)
genTxAuxScripts ShelleyBasedEra era
sbe
  let txExtraKeyWits :: TxExtraKeyWitnesses era
txExtraKeyWits = TxExtraKeyWitnesses era
forall era. TxExtraKeyWitnesses era
TxExtraKeyWitnessesNone -- TODO: Alonzo era: Generate witness key hashes
  BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era))
txProtocolParams <-
    Maybe (LedgerProtocolParameters era)
-> BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era))
forall a. a -> BuildTxWith BuildTx a
BuildTxWith (Maybe (LedgerProtocolParameters era)
 -> BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era)))
-> GenT Identity (Maybe (LedgerProtocolParameters era))
-> GenT
     Identity
     (BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CardanoEra era
-> GenT Identity (Maybe (LedgerProtocolParameters era))
-> (ShelleyBasedEra era
    -> GenT Identity (Maybe (LedgerProtocolParameters era)))
-> GenT Identity (Maybe (LedgerProtocolParameters era))
forall (eon :: * -> *) era a.
Eon eon =>
CardanoEra era -> a -> (eon era -> a) -> a
forEraInEon CardanoEra era
era (Maybe (LedgerProtocolParameters era)
-> GenT Identity (Maybe (LedgerProtocolParameters era))
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (LedgerProtocolParameters era)
forall a. Maybe a
Nothing) (GenT Identity (LedgerProtocolParameters era)
-> GenT Identity (Maybe (LedgerProtocolParameters era))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe (GenT Identity (LedgerProtocolParameters era)
 -> GenT Identity (Maybe (LedgerProtocolParameters era)))
-> (ShelleyBasedEra era
    -> GenT Identity (LedgerProtocolParameters era))
-> ShelleyBasedEra era
-> GenT Identity (Maybe (LedgerProtocolParameters era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyBasedEra era -> GenT Identity (LedgerProtocolParameters era)
forall era.
ShelleyBasedEra era -> Gen (LedgerProtocolParameters era)
genValidProtocolParameters)
  TxWithdrawals BuildTx era
txWithdrawals <- CardanoEra era -> Gen (TxWithdrawals BuildTx era)
forall era build. CardanoEra era -> Gen (TxWithdrawals build era)
genTxWithdrawals CardanoEra era
era
  TxCertificates BuildTx era
txCertificates <- CardanoEra era -> Gen (TxCertificates BuildTx era)
forall era. CardanoEra era -> Gen (TxCertificates BuildTx era)
genTxCertificates CardanoEra era
era
  TxUpdateProposal era
txUpdateProposal <- CardanoEra era -> Gen (TxUpdateProposal era)
forall era. CardanoEra era -> Gen (TxUpdateProposal era)
genTxUpdateProposal CardanoEra era
era
  TxMintValue BuildTx era
txMintValue <- CardanoEra era -> Gen (TxMintValue BuildTx era)
forall era. CardanoEra era -> Gen (TxMintValue BuildTx era)
genTxMintValue CardanoEra era
era
  TxScriptValidity era
txScriptValidity <- CardanoEra era -> Gen (TxScriptValidity era)
forall era. CardanoEra era -> Gen (TxScriptValidity era)
genTxScriptValidity CardanoEra era
era
  Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures BuildTx era))
txProposalProcedures <- (ConwayEraOnwards era
 -> GenT Identity (TxProposalProcedures BuildTx era))
-> CardanoEra era
-> GenT
     Identity
     (Maybe
        (Featured ConwayEraOnwards era (TxProposalProcedures BuildTx era)))
forall (eon :: * -> *) (f :: * -> *) era a.
(Eon eon, Alternative f) =>
(eon era -> f a)
-> CardanoEra era -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra ConwayEraOnwards era
-> GenT Identity (TxProposalProcedures BuildTx era)
forall build era.
Applicative (BuildTxWith build) =>
ConwayEraOnwards era -> Gen (TxProposalProcedures build era)
genProposals CardanoEra era
era
  Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures BuildTx era))
txVotingProcedures <- (ConwayEraOnwards era
 -> GenT Identity (TxVotingProcedures BuildTx era))
-> CardanoEra era
-> GenT
     Identity
     (Maybe
        (Featured ConwayEraOnwards era (TxVotingProcedures BuildTx era)))
forall (eon :: * -> *) (f :: * -> *) era a.
(Eon eon, Alternative f) =>
(eon era -> f a)
-> CardanoEra era -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra ConwayEraOnwards era
-> GenT Identity (TxVotingProcedures BuildTx era)
forall build era.
Applicative (BuildTxWith build) =>
ConwayEraOnwards era -> Gen (TxVotingProcedures build era)
genVotingProcedures CardanoEra era
era
  Maybe (Featured ConwayEraOnwards era (Maybe Coin))
txCurrentTreasuryValue <- (ConwayEraOnwards era -> GenT Identity (Maybe Coin))
-> CardanoEra era
-> GenT
     Identity (Maybe (Featured ConwayEraOnwards era (Maybe Coin)))
forall (eon :: * -> *) (f :: * -> *) era a.
(Eon eon, Alternative f) =>
(eon era -> f a)
-> CardanoEra era -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra (Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe (Gen Coin -> GenT Identity (Maybe Coin))
-> (ConwayEraOnwards era -> Gen Coin)
-> ConwayEraOnwards era
-> GenT Identity (Maybe Coin)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayEraOnwards era -> Gen Coin
forall era. ConwayEraOnwards era -> Gen Coin
genCurrentTreasuryValue) CardanoEra era
era
  Maybe (Featured ConwayEraOnwards era Coin)
txTreasuryDonation <- (ConwayEraOnwards era -> Gen Coin)
-> CardanoEra era
-> GenT Identity (Maybe (Featured ConwayEraOnwards era Coin))
forall (eon :: * -> *) (f :: * -> *) era a.
(Eon eon, Alternative f) =>
(eon era -> f a)
-> CardanoEra era -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra ConwayEraOnwards era -> Gen Coin
forall era. ConwayEraOnwards era -> Gen Coin
genTreasuryDonation CardanoEra era
era
  TxBodyContent BuildTx era -> Gen (TxBodyContent BuildTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxBodyContent BuildTx era -> Gen (TxBodyContent BuildTx era))
-> TxBodyContent BuildTx era -> Gen (TxBodyContent BuildTx era)
forall a b. (a -> b) -> a -> b
$
    TxBodyContent
      { [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
txIns :: [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
txIns :: [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn era))]
Api.txIns
      , TxInsCollateral era
txInsCollateral :: TxInsCollateral era
txInsCollateral :: TxInsCollateral era
Api.txInsCollateral
      , TxInsReference era
txInsReference :: TxInsReference era
txInsReference :: TxInsReference era
Api.txInsReference
      , [TxOut CtxTx era]
txOuts :: [TxOut CtxTx era]
txOuts :: [TxOut CtxTx era]
Api.txOuts
      , TxTotalCollateral era
txTotalCollateral :: TxTotalCollateral era
txTotalCollateral :: TxTotalCollateral era
Api.txTotalCollateral
      , TxReturnCollateral CtxTx era
txReturnCollateral :: TxReturnCollateral CtxTx era
txReturnCollateral :: TxReturnCollateral CtxTx era
Api.txReturnCollateral
      , TxFee era
txFee :: TxFee era
txFee :: TxFee era
Api.txFee
      , TxValidityLowerBound era
txValidityLowerBound :: TxValidityLowerBound era
txValidityLowerBound :: TxValidityLowerBound era
Api.txValidityLowerBound
      , TxValidityUpperBound era
txValidityUpperBound :: TxValidityUpperBound era
txValidityUpperBound :: TxValidityUpperBound era
Api.txValidityUpperBound
      , TxMetadataInEra era
txMetadata :: TxMetadataInEra era
txMetadata :: TxMetadataInEra era
Api.txMetadata
      , TxAuxScripts era
txAuxScripts :: TxAuxScripts era
txAuxScripts :: TxAuxScripts era
Api.txAuxScripts
      , TxExtraKeyWitnesses era
forall era. TxExtraKeyWitnesses era
txExtraKeyWits :: forall era. TxExtraKeyWitnesses era
txExtraKeyWits :: TxExtraKeyWitnesses era
Api.txExtraKeyWits
      , BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era))
txProtocolParams :: BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era))
txProtocolParams :: BuildTxWith BuildTx (Maybe (LedgerProtocolParameters era))
Api.txProtocolParams
      , TxWithdrawals BuildTx era
txWithdrawals :: TxWithdrawals BuildTx era
txWithdrawals :: TxWithdrawals BuildTx era
Api.txWithdrawals
      , TxCertificates BuildTx era
txCertificates :: TxCertificates BuildTx era
txCertificates :: TxCertificates BuildTx era
Api.txCertificates
      , TxUpdateProposal era
txUpdateProposal :: TxUpdateProposal era
txUpdateProposal :: TxUpdateProposal era
Api.txUpdateProposal
      , TxMintValue BuildTx era
txMintValue :: TxMintValue BuildTx era
txMintValue :: TxMintValue BuildTx era
Api.txMintValue
      , TxScriptValidity era
txScriptValidity :: TxScriptValidity era
txScriptValidity :: TxScriptValidity era
Api.txScriptValidity
      , Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures BuildTx era))
txProposalProcedures :: Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures BuildTx era))
txProposalProcedures :: Maybe
  (Featured ConwayEraOnwards era (TxProposalProcedures BuildTx era))
Api.txProposalProcedures
      , Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures BuildTx era))
txVotingProcedures :: Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures BuildTx era))
txVotingProcedures :: Maybe
  (Featured ConwayEraOnwards era (TxVotingProcedures BuildTx era))
Api.txVotingProcedures
      , Maybe (Featured ConwayEraOnwards era (Maybe Coin))
txCurrentTreasuryValue :: Maybe (Featured ConwayEraOnwards era (Maybe Coin))
txCurrentTreasuryValue :: Maybe (Featured ConwayEraOnwards era (Maybe Coin))
Api.txCurrentTreasuryValue
      , Maybe (Featured ConwayEraOnwards era Coin)
txTreasuryDonation :: Maybe (Featured ConwayEraOnwards era Coin)
txTreasuryDonation :: Maybe (Featured ConwayEraOnwards era Coin)
Api.txTreasuryDonation
      }

genTxInsCollateral :: CardanoEra era -> Gen (TxInsCollateral era)
genTxInsCollateral :: forall era. CardanoEra era -> Gen (TxInsCollateral era)
genTxInsCollateral =
  Gen (TxInsCollateral era)
-> (AlonzoEraOnwards era -> Gen (TxInsCollateral era))
-> CardanoEra era
-> Gen (TxInsCollateral era)
forall a era.
a -> (AlonzoEraOnwards era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxInsCollateral era -> Gen (TxInsCollateral era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxInsCollateral era
forall era. TxInsCollateral era
TxInsCollateralNone)
    ( \AlonzoEraOnwards era
w ->
        [Gen (TxInsCollateral era)] -> Gen (TxInsCollateral era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
          [ TxInsCollateral era -> Gen (TxInsCollateral era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxInsCollateral era
forall era. TxInsCollateral era
TxInsCollateralNone
          , AlonzoEraOnwards era -> [TxIn] -> TxInsCollateral era
forall era. AlonzoEraOnwards era -> [TxIn] -> TxInsCollateral era
TxInsCollateral AlonzoEraOnwards era
w ([TxIn] -> TxInsCollateral era)
-> GenT Identity [TxIn] -> Gen (TxInsCollateral era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> Gen TxIn -> GenT Identity [TxIn]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10) Gen TxIn
genTxIn
          ]
    )

genTxInsReference :: CardanoEra era -> Gen (TxInsReference era)
genTxInsReference :: forall era. CardanoEra era -> Gen (TxInsReference era)
genTxInsReference =
  (ByronToAlonzoEraConstraints era =>
 ByronToAlonzoEra era -> Gen (TxInsReference era))
-> (BabbageEraOnwardsConstraints era =>
    BabbageEraOnwards era -> Gen (TxInsReference era))
-> CardanoEra era
-> Gen (TxInsReference era)
forall era a.
(ByronToAlonzoEraConstraints era => ByronToAlonzoEra era -> a)
-> (BabbageEraOnwardsConstraints era => BabbageEraOnwards era -> a)
-> CardanoEra era
-> a
caseByronToAlonzoOrBabbageEraOnwards
    (Gen (TxInsReference era)
-> ByronToAlonzoEra era -> Gen (TxInsReference era)
forall a b. a -> b -> a
const (TxInsReference era -> Gen (TxInsReference era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxInsReference era
forall era. TxInsReference era
TxInsReferenceNone))
    (\BabbageEraOnwards era
w -> BabbageEraOnwards era -> [TxIn] -> TxInsReference era
forall era. BabbageEraOnwards era -> [TxIn] -> TxInsReference era
TxInsReference BabbageEraOnwards era
w ([TxIn] -> TxInsReference era)
-> GenT Identity [TxIn] -> Gen (TxInsReference era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> Gen TxIn -> GenT Identity [TxIn]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10) Gen TxIn
genTxIn)

genTxReturnCollateral :: ShelleyBasedEra era -> Gen (TxReturnCollateral CtxTx era)
genTxReturnCollateral :: forall era.
ShelleyBasedEra era -> Gen (TxReturnCollateral CtxTx era)
genTxReturnCollateral ShelleyBasedEra era
era =
  CardanoEra era
-> Gen (TxReturnCollateral CtxTx era)
-> (BabbageEraOnwards era -> Gen (TxReturnCollateral CtxTx era))
-> Gen (TxReturnCollateral CtxTx era)
forall (eon :: * -> *) era a.
Eon eon =>
CardanoEra era -> a -> (eon era -> a) -> a
forEraInEon
    (ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyBasedEra era
era)
    (TxReturnCollateral CtxTx era -> Gen (TxReturnCollateral CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxReturnCollateral CtxTx era
forall ctx era. TxReturnCollateral ctx era
TxReturnCollateralNone)
    (\BabbageEraOnwards era
w -> BabbageEraOnwards era
-> TxOut CtxTx era -> TxReturnCollateral CtxTx era
forall era ctx.
BabbageEraOnwards era
-> TxOut ctx era -> TxReturnCollateral ctx era
TxReturnCollateral BabbageEraOnwards era
w (TxOut CtxTx era -> TxReturnCollateral CtxTx era)
-> GenT Identity (TxOut CtxTx era)
-> Gen (TxReturnCollateral CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (TxOut CtxTx era)
forall era. ShelleyBasedEra era -> Gen (TxOut CtxTx era)
genTxOutTxContext ShelleyBasedEra era
era)

genTxTotalCollateral :: CardanoEra era -> Gen (TxTotalCollateral era)
genTxTotalCollateral :: forall era. CardanoEra era -> Gen (TxTotalCollateral era)
genTxTotalCollateral =
  Gen (TxTotalCollateral era)
-> (BabbageEraOnwards era -> Gen (TxTotalCollateral era))
-> CardanoEra era
-> Gen (TxTotalCollateral era)
forall a era.
a -> (BabbageEraOnwards era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxTotalCollateral era -> Gen (TxTotalCollateral era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxTotalCollateral era
forall era. TxTotalCollateral era
TxTotalCollateralNone)
    (\BabbageEraOnwards era
w -> BabbageEraOnwards era -> Coin -> TxTotalCollateral era
forall era. BabbageEraOnwards era -> Coin -> TxTotalCollateral era
TxTotalCollateral BabbageEraOnwards era
w (Coin -> TxTotalCollateral era)
-> Gen Coin -> Gen (TxTotalCollateral era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genPositiveLovelace)

genTxFee :: ShelleyBasedEra era -> Gen (TxFee era)
genTxFee :: forall era. ShelleyBasedEra era -> Gen (TxFee era)
genTxFee ShelleyBasedEra era
w = ShelleyBasedEra era -> Coin -> TxFee era
forall era. ShelleyBasedEra era -> Coin -> TxFee era
TxFeeExplicit ShelleyBasedEra era
w (Coin -> TxFee era) -> Gen Coin -> GenT Identity (TxFee era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genLovelace

genAddressInEraByron :: Gen (AddressInEra ByronEra)
genAddressInEraByron :: Gen (AddressInEra ByronEra)
genAddressInEraByron = Address ByronAddr -> AddressInEra ByronEra
forall era. Address ByronAddr -> AddressInEra era
byronAddressInEra (Address ByronAddr -> AddressInEra ByronEra)
-> Gen (Address ByronAddr) -> Gen (AddressInEra ByronEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Address ByronAddr)
genAddressByron

genTxByron :: Gen (Byron.ATxAux ByteString)
genTxByron :: Gen (ATxAux ByteString)
genTxByron = do
  [KeyWitness ByronEra]
-> Annotated Tx ByteString -> ATxAux ByteString
forall era.
[KeyWitness era] -> Annotated Tx ByteString -> ATxAux ByteString
makeSignedByronTransaction
    ([KeyWitness ByronEra]
 -> Annotated Tx ByteString -> ATxAux ByteString)
-> GenT Identity [KeyWitness ByronEra]
-> GenT Identity (Annotated Tx ByteString -> ATxAux ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity [KeyWitness ByronEra]
genWitnessesByron
    GenT Identity (Annotated Tx ByteString -> ATxAux ByteString)
-> GenT Identity (Annotated Tx ByteString)
-> Gen (ATxAux ByteString)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity (Annotated Tx ByteString)
HasCallStack => GenT Identity (Annotated Tx ByteString)
genTxBodyByron

genTxOutValueByron :: Gen (TxOutValue ByronEra)
genTxOutValueByron :: Gen (TxOutValue ByronEra)
genTxOutValueByron = Coin -> TxOutValue ByronEra
forall era. Coin -> TxOutValue era
TxOutValueByron (Coin -> TxOutValue ByronEra)
-> Gen Coin -> Gen (TxOutValue ByronEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genPositiveLovelace

genTxOutByron :: Gen (TxOut CtxTx ByronEra)
genTxOutByron :: Gen (TxOut CtxTx ByronEra)
genTxOutByron =
  AddressInEra ByronEra
-> TxOutValue ByronEra
-> TxOutDatum CtxTx ByronEra
-> ReferenceScript ByronEra
-> TxOut CtxTx ByronEra
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
    (AddressInEra ByronEra
 -> TxOutValue ByronEra
 -> TxOutDatum CtxTx ByronEra
 -> ReferenceScript ByronEra
 -> TxOut CtxTx ByronEra)
-> Gen (AddressInEra ByronEra)
-> GenT
     Identity
     (TxOutValue ByronEra
      -> TxOutDatum CtxTx ByronEra
      -> ReferenceScript ByronEra
      -> TxOut CtxTx ByronEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (AddressInEra ByronEra)
genAddressInEraByron
    GenT
  Identity
  (TxOutValue ByronEra
   -> TxOutDatum CtxTx ByronEra
   -> ReferenceScript ByronEra
   -> TxOut CtxTx ByronEra)
-> Gen (TxOutValue ByronEra)
-> GenT
     Identity
     (TxOutDatum CtxTx ByronEra
      -> ReferenceScript ByronEra -> TxOut CtxTx ByronEra)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (TxOutValue ByronEra)
genTxOutValueByron
    GenT
  Identity
  (TxOutDatum CtxTx ByronEra
   -> ReferenceScript ByronEra -> TxOut CtxTx ByronEra)
-> GenT Identity (TxOutDatum CtxTx ByronEra)
-> GenT Identity (ReferenceScript ByronEra -> TxOut CtxTx ByronEra)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx ByronEra
-> GenT Identity (TxOutDatum CtxTx ByronEra)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx ByronEra
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
    GenT Identity (ReferenceScript ByronEra -> TxOut CtxTx ByronEra)
-> GenT Identity (ReferenceScript ByronEra)
-> Gen (TxOut CtxTx ByronEra)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript ByronEra
-> GenT Identity (ReferenceScript ByronEra)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ReferenceScript ByronEra
forall era. ReferenceScript era
ReferenceScriptNone

-- | Partial! It will throw if the generated transaction body is invalid.
genTxBodyByron :: HasCallStack => Gen (L.Annotated Byron.Tx ByteString)
genTxBodyByron :: HasCallStack => GenT Identity (Annotated Tx ByteString)
genTxBodyByron = do
  [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))]
txIns <-
    (TxIn -> (TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra)))
-> [TxIn]
-> [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))]
forall a b. (a -> b) -> [a] -> [b]
map (,Witness WitCtxTxIn ByronEra
-> BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra)
forall a. a -> BuildTxWith BuildTx a
BuildTxWith (KeyWitnessInCtx WitCtxTxIn -> Witness WitCtxTxIn ByronEra
forall witctx era. KeyWitnessInCtx witctx -> Witness witctx era
KeyWitness KeyWitnessInCtx WitCtxTxIn
KeyWitnessForSpending)) ([TxIn]
 -> [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))])
-> GenT Identity [TxIn]
-> GenT
     Identity
     [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> Gen TxIn -> GenT Identity [TxIn]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) Gen TxIn
genTxIn
  [TxOut CtxTx ByronEra]
txOuts <- Range Int
-> Gen (TxOut CtxTx ByronEra)
-> GenT Identity [TxOut CtxTx ByronEra]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) Gen (TxOut CtxTx ByronEra)
genTxOutByron
  case [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))]
-> [TxOut CtxTx ByronEra]
-> Either TxBodyError (Annotated Tx ByteString)
Api.makeByronTransactionBody [(TxIn, BuildTxWith BuildTx (Witness WitCtxTxIn ByronEra))]
txIns [TxOut CtxTx ByronEra]
txOuts of
    Left TxBodyError
err -> [Char] -> GenT Identity (Annotated Tx ByteString)
forall a. HasCallStack => [Char] -> a
error (TxBodyError -> [Char]
forall a. Error a => a -> [Char]
displayError TxBodyError
err)
    Right Annotated Tx ByteString
txBody -> Annotated Tx ByteString -> GenT Identity (Annotated Tx ByteString)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Annotated Tx ByteString
txBody

genWitnessesByron :: Gen [KeyWitness ByronEra]
genWitnessesByron :: GenT Identity [KeyWitness ByronEra]
genWitnessesByron = Range Int
-> GenT Identity (KeyWitness ByronEra)
-> GenT Identity [KeyWitness ByronEra]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) GenT Identity (KeyWitness ByronEra)
genByronKeyWitness

-- | This generator validates generated 'TxBodyContent' and backtracks when the generated body
-- fails the validation. That also means that it is quite slow.
genValidTxBody :: ShelleyBasedEra era
               -> Gen (TxBody era, TxBodyContent BuildTx era) -- ^ validated 'TxBody' and 'TxBodyContent'
genValidTxBody :: forall era.
ShelleyBasedEra era -> Gen (TxBody era, TxBodyContent BuildTx era)
genValidTxBody ShelleyBasedEra era
sbe =
  (TxBodyContent BuildTx era
 -> Maybe (TxBody era, TxBodyContent BuildTx era))
-> GenT Identity (TxBodyContent BuildTx era)
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
forall (m :: * -> *) a b.
(MonadGen m, GenBase m ~ Identity) =>
(a -> Maybe b) -> m a -> m b
Gen.mapMaybe
    (\TxBodyContent BuildTx era
content ->
        (TxBodyError -> Maybe (TxBody era, TxBodyContent BuildTx era))
-> (TxBody era -> Maybe (TxBody era, TxBodyContent BuildTx era))
-> Either TxBodyError (TxBody era)
-> Maybe (TxBody era, TxBodyContent BuildTx era)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe (TxBody era, TxBodyContent BuildTx era)
-> TxBodyError -> Maybe (TxBody era, TxBodyContent BuildTx era)
forall a b. a -> b -> a
const Maybe (TxBody era, TxBodyContent BuildTx era)
forall a. Maybe a
Nothing) ((TxBody era, TxBodyContent BuildTx era)
-> Maybe (TxBody era, TxBodyContent BuildTx era)
forall a. a -> Maybe a
Just ((TxBody era, TxBodyContent BuildTx era)
 -> Maybe (TxBody era, TxBodyContent BuildTx era))
-> (TxBody era -> (TxBody era, TxBodyContent BuildTx era))
-> TxBody era
-> Maybe (TxBody era, TxBodyContent BuildTx era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (, TxBodyContent BuildTx era
content)) (Either TxBodyError (TxBody era)
 -> Maybe (TxBody era, TxBodyContent BuildTx era))
-> Either TxBodyError (TxBody era)
-> Maybe (TxBody era, TxBodyContent BuildTx era)
forall a b. (a -> b) -> a -> b
$
          ShelleyBasedEra era
-> TxBodyContent BuildTx era -> Either TxBodyError (TxBody era)
forall era.
ShelleyBasedEra era
-> TxBodyContent BuildTx era -> Either TxBodyError (TxBody era)
createAndValidateTransactionBody ShelleyBasedEra era
sbe TxBodyContent BuildTx era
content
    )
    (ShelleyBasedEra era -> GenT Identity (TxBodyContent BuildTx era)
forall era. ShelleyBasedEra era -> Gen (TxBodyContent BuildTx era)
genTxBodyContent ShelleyBasedEra era
sbe)

-- | Partial! This function will throw an error when the generated transaction is invalid.
genTxBody :: HasCallStack => ShelleyBasedEra era -> Gen (TxBody era)
genTxBody :: forall era. HasCallStack => ShelleyBasedEra era -> Gen (TxBody era)
genTxBody ShelleyBasedEra era
era = do
  Either TxBodyError (TxBody era)
res <- ShelleyBasedEra era
-> TxBodyContent BuildTx era -> Either TxBodyError (TxBody era)
forall era.
HasCallStack =>
ShelleyBasedEra era
-> TxBodyContent BuildTx era -> Either TxBodyError (TxBody era)
Api.createTransactionBody ShelleyBasedEra era
era (TxBodyContent BuildTx era -> Either TxBodyError (TxBody era))
-> GenT Identity (TxBodyContent BuildTx era)
-> GenT Identity (Either TxBodyError (TxBody era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity (TxBodyContent BuildTx era)
forall era. ShelleyBasedEra era -> Gen (TxBodyContent BuildTx era)
genTxBodyContent ShelleyBasedEra era
era
  case Either TxBodyError (TxBody era)
res of
    Left TxBodyError
err -> [Char] -> Gen (TxBody era)
forall a. HasCallStack => [Char] -> a
error (Doc AnsiStyle -> [Char]
docToString (TxBodyError -> Doc AnsiStyle
forall e ann. Error e => e -> Doc ann
forall ann. TxBodyError -> Doc ann
prettyError TxBodyError
err))
    Right TxBody era
txBody -> TxBody era -> Gen (TxBody era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxBody era
txBody

-- | Generate a 'Featured' for the given 'CardanoEra' with the provided generator.
genFeaturedInEra
  :: ()
  => Alternative f
  => eon era
  -> f a
  -> f (Featured eon era a)
genFeaturedInEra :: forall (f :: * -> *) (eon :: * -> *) era a.
Alternative f =>
eon era -> f a -> f (Featured eon era a)
genFeaturedInEra eon era
witness f a
gen =
  eon era -> a -> Featured eon era a
forall (eon :: * -> *) era a. eon era -> a -> Featured eon era a
Featured eon era
witness (a -> Featured eon era a) -> f a -> f (Featured eon era a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a
gen

-- | Generate a 'Featured' for the given 'CardanoEra' with the provided generator.
genMaybeFeaturedInEra
  :: ()
  => Eon eon
  => Alternative f
  => (eon era -> f a)
  -> CardanoEra era
  -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra :: forall (eon :: * -> *) (f :: * -> *) era a.
(Eon eon, Alternative f) =>
(eon era -> f a)
-> CardanoEra era -> f (Maybe (Featured eon era a))
genMaybeFeaturedInEra eon era -> f a
f =
  f (Maybe (Featured eon era a))
-> (eon era -> f (Maybe (Featured eon era a)))
-> CardanoEra era
-> f (Maybe (Featured eon era a))
forall a era. a -> (eon era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra (Maybe (Featured eon era a) -> f (Maybe (Featured eon era a))
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Featured eon era a)
forall a. Maybe a
Nothing) ((eon era -> f (Maybe (Featured eon era a)))
 -> CardanoEra era -> f (Maybe (Featured eon era a)))
-> (eon era -> f (Maybe (Featured eon era a)))
-> CardanoEra era
-> f (Maybe (Featured eon era a))
forall a b. (a -> b) -> a -> b
$ \eon era
w ->
    Featured eon era a -> Maybe (Featured eon era a)
forall a. a -> Maybe a
Just (Featured eon era a -> Maybe (Featured eon era a))
-> f (Featured eon era a) -> f (Maybe (Featured eon era a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> eon era -> f a -> f (Featured eon era a)
forall (f :: * -> *) (eon :: * -> *) era a.
Alternative f =>
eon era -> f a -> f (Featured eon era a)
genFeaturedInEra eon era
w (eon era -> f a
f eon era
w)

genTxScriptValidity :: CardanoEra era -> Gen (TxScriptValidity era)
genTxScriptValidity :: forall era. CardanoEra era -> Gen (TxScriptValidity era)
genTxScriptValidity =
  Gen (TxScriptValidity era)
-> (AlonzoEraOnwards era -> Gen (TxScriptValidity era))
-> CardanoEra era
-> Gen (TxScriptValidity era)
forall a era.
a -> (AlonzoEraOnwards era -> a) -> CardanoEra era -> a
forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra
    (TxScriptValidity era -> Gen (TxScriptValidity era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxScriptValidity era
forall era. TxScriptValidity era
TxScriptValidityNone)
    (\AlonzoEraOnwards era
w -> AlonzoEraOnwards era -> ScriptValidity -> TxScriptValidity era
forall era.
AlonzoEraOnwards era -> ScriptValidity -> TxScriptValidity era
TxScriptValidity AlonzoEraOnwards era
w (ScriptValidity -> TxScriptValidity era)
-> GenT Identity ScriptValidity -> Gen (TxScriptValidity era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity ScriptValidity
genScriptValidity)

genScriptValidity :: Gen ScriptValidity
genScriptValidity :: GenT Identity ScriptValidity
genScriptValidity = [ScriptValidity] -> GenT Identity ScriptValidity
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, MonadGen m) =>
f a -> m a
Gen.element [ScriptValidity
ScriptInvalid, ScriptValidity
ScriptValid]

genTx
  :: ()
  => ShelleyBasedEra era
  -> Gen (Tx era)
genTx :: forall era. ShelleyBasedEra era -> Gen (Tx era)
genTx ShelleyBasedEra era
era =
  [KeyWitness era] -> TxBody era -> Tx era
forall era. [KeyWitness era] -> TxBody era -> Tx era
makeSignedTransaction
    ([KeyWitness era] -> TxBody era -> Tx era)
-> GenT Identity [KeyWitness era]
-> GenT Identity (TxBody era -> Tx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era -> GenT Identity [KeyWitness era]
forall era. ShelleyBasedEra era -> Gen [KeyWitness era]
genWitnesses ShelleyBasedEra era
era
    GenT Identity (TxBody era -> Tx era)
-> GenT Identity (TxBody era) -> GenT Identity (Tx era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((TxBody era, TxBodyContent BuildTx era) -> TxBody era
forall a b. (a, b) -> a
fst ((TxBody era, TxBodyContent BuildTx era) -> TxBody era)
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
-> GenT Identity (TxBody era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
forall era.
ShelleyBasedEra era -> Gen (TxBody era, TxBodyContent BuildTx era)
genValidTxBody ShelleyBasedEra era
era)

genWitnesses :: ShelleyBasedEra era -> Gen [KeyWitness era]
genWitnesses :: forall era. ShelleyBasedEra era -> Gen [KeyWitness era]
genWitnesses ShelleyBasedEra era
sbe = do
  [KeyWitness era]
bsWits <- Range Int -> GenT Identity (KeyWitness era) -> Gen [KeyWitness era]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
10) (ShelleyBasedEra era -> GenT Identity (KeyWitness era)
forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyBootstrapWitness ShelleyBasedEra era
sbe)
  [KeyWitness era]
keyWits <- Range Int -> GenT Identity (KeyWitness era) -> Gen [KeyWitness era]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
10) (ShelleyBasedEra era -> GenT Identity (KeyWitness era)
forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyKeyWitness ShelleyBasedEra era
sbe)
  [KeyWitness era] -> Gen [KeyWitness era]
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([KeyWitness era] -> Gen [KeyWitness era])
-> [KeyWitness era] -> Gen [KeyWitness era]
forall a b. (a -> b) -> a -> b
$ [KeyWitness era]
bsWits [KeyWitness era] -> [KeyWitness era] -> [KeyWitness era]
forall a. [a] -> [a] -> [a]
++ [KeyWitness era]
keyWits

genVerificationKey
  :: ()
#if MIN_VERSION_base(4,17,0)
  -- GHC 8.10 considers the HasTypeProxy constraint redundant but ghc-9.6 complains if its not
  -- present.
  => HasTypeProxy keyrole
#endif
  => Key keyrole
  => ShelleyApi.AsType keyrole
  -> Gen (VerificationKey keyrole)
genVerificationKey :: forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType keyrole
roletoken = SigningKey keyrole -> VerificationKey keyrole
forall keyrole.
(Key keyrole, HasTypeProxy keyrole) =>
SigningKey keyrole -> VerificationKey keyrole
getVerificationKey (SigningKey keyrole -> VerificationKey keyrole)
-> GenT Identity (SigningKey keyrole)
-> GenT Identity (VerificationKey keyrole)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType keyrole -> GenT Identity (SigningKey keyrole)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType keyrole
roletoken

genVerificationKeyHash
  :: ()
#if MIN_VERSION_base(4,17,0)
  -- GHC 8.10 considers the HasTypeProxy constraint redundant but ghc-9.6 complains if its not
  -- present.
  => HasTypeProxy keyrole
#endif
  => Key keyrole
  => ShelleyApi.AsType keyrole
  -> Gen (Hash keyrole)
genVerificationKeyHash :: forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType keyrole
roletoken =
  VerificationKey keyrole -> Hash keyrole
forall keyrole.
Key keyrole =>
VerificationKey keyrole -> Hash keyrole
verificationKeyHash (VerificationKey keyrole -> Hash keyrole)
-> GenT Identity (VerificationKey keyrole)
-> GenT Identity (Hash keyrole)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType keyrole -> GenT Identity (VerificationKey keyrole)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (VerificationKey keyrole)
genVerificationKey AsType keyrole
roletoken

genByronKeyWitness :: Gen (KeyWitness ByronEra)
genByronKeyWitness :: GenT Identity (KeyWitness ByronEra)
genByronKeyWitness = do
  ProtocolMagicId
pmId <- Gen ProtocolMagicId
genProtocolMagicId
  TxInWitness
txinWitness <- ProtocolMagicId -> Gen TxInWitness
genVKWitness ProtocolMagicId
pmId
  KeyWitness ByronEra -> GenT Identity (KeyWitness ByronEra)
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (KeyWitness ByronEra -> GenT Identity (KeyWitness ByronEra))
-> KeyWitness ByronEra -> GenT Identity (KeyWitness ByronEra)
forall a b. (a -> b) -> a -> b
$ TxInWitness -> KeyWitness ByronEra
ByronKeyWitness TxInWitness
txinWitness

genWitnessNetworkIdOrByronAddress :: Gen WitnessNetworkIdOrByronAddress
genWitnessNetworkIdOrByronAddress :: Gen WitnessNetworkIdOrByronAddress
genWitnessNetworkIdOrByronAddress =
  [Gen WitnessNetworkIdOrByronAddress]
-> Gen WitnessNetworkIdOrByronAddress
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ NetworkId -> WitnessNetworkIdOrByronAddress
WitnessNetworkId (NetworkId -> WitnessNetworkIdOrByronAddress)
-> GenT Identity NetworkId -> Gen WitnessNetworkIdOrByronAddress
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity NetworkId
genNetworkId
    , Address ByronAddr -> WitnessNetworkIdOrByronAddress
WitnessByronAddress (Address ByronAddr -> WitnessNetworkIdOrByronAddress)
-> Gen (Address ByronAddr) -> Gen WitnessNetworkIdOrByronAddress
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Address ByronAddr)
genAddressByron
    ]

genShelleyBootstrapWitness
  :: ()
  => ShelleyBasedEra era
  -> Gen (KeyWitness era)
genShelleyBootstrapWitness :: forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyBootstrapWitness ShelleyBasedEra era
sbe =
  ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody era
-> SigningKey ByronKey
-> KeyWitness era
forall era.
ShelleyBasedEra era
-> WitnessNetworkIdOrByronAddress
-> TxBody era
-> SigningKey ByronKey
-> KeyWitness era
makeShelleyBootstrapWitness ShelleyBasedEra era
sbe
    (WitnessNetworkIdOrByronAddress
 -> TxBody era -> SigningKey ByronKey -> KeyWitness era)
-> Gen WitnessNetworkIdOrByronAddress
-> GenT
     Identity (TxBody era -> SigningKey ByronKey -> KeyWitness era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen WitnessNetworkIdOrByronAddress
genWitnessNetworkIdOrByronAddress
    GenT Identity (TxBody era -> SigningKey ByronKey -> KeyWitness era)
-> GenT Identity (TxBody era)
-> GenT Identity (SigningKey ByronKey -> KeyWitness era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((TxBody era, TxBodyContent BuildTx era) -> TxBody era
forall a b. (a, b) -> a
fst ((TxBody era, TxBodyContent BuildTx era) -> TxBody era)
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
-> GenT Identity (TxBody era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
forall era.
ShelleyBasedEra era -> Gen (TxBody era, TxBodyContent BuildTx era)
genValidTxBody ShelleyBasedEra era
sbe)
    GenT Identity (SigningKey ByronKey -> KeyWitness era)
-> GenT Identity (SigningKey ByronKey)
-> GenT Identity (KeyWitness era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AsType ByronKey -> GenT Identity (SigningKey ByronKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType ByronKey
AsByronKey

genShelleyKeyWitness
  :: ()
  => ShelleyBasedEra era
  -> Gen (KeyWitness era)
genShelleyKeyWitness :: forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyKeyWitness ShelleyBasedEra era
sbe =
  ShelleyBasedEra era
-> TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era
forall era.
ShelleyBasedEra era
-> TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era
makeShelleyKeyWitness ShelleyBasedEra era
sbe (TxBody era -> ShelleyWitnessSigningKey -> KeyWitness era)
-> ((TxBody era, TxBodyContent BuildTx era) -> TxBody era)
-> (TxBody era, TxBodyContent BuildTx era)
-> ShelleyWitnessSigningKey
-> KeyWitness era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxBody era, TxBodyContent BuildTx era) -> TxBody era
forall a b. (a, b) -> a
fst
    ((TxBody era, TxBodyContent BuildTx era)
 -> ShelleyWitnessSigningKey -> KeyWitness era)
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
-> GenT Identity (ShelleyWitnessSigningKey -> KeyWitness era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (TxBody era, TxBodyContent BuildTx era)
forall era.
ShelleyBasedEra era -> Gen (TxBody era, TxBodyContent BuildTx era)
genValidTxBody ShelleyBasedEra era
sbe
    GenT Identity (ShelleyWitnessSigningKey -> KeyWitness era)
-> GenT Identity ShelleyWitnessSigningKey
-> GenT Identity (KeyWitness era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity ShelleyWitnessSigningKey
genShelleyWitnessSigningKey

genShelleyWitness
  :: ()
  => ShelleyBasedEra era
  -> Gen (KeyWitness era)
genShelleyWitness :: forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyWitness ShelleyBasedEra era
sbe =
  [GenT Identity (KeyWitness era)] -> GenT Identity (KeyWitness era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ ShelleyBasedEra era -> GenT Identity (KeyWitness era)
forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyKeyWitness ShelleyBasedEra era
sbe
    , ShelleyBasedEra era -> GenT Identity (KeyWitness era)
forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyBootstrapWitness ShelleyBasedEra era
sbe
    ]

genShelleyWitnessSigningKey :: Gen ShelleyWitnessSigningKey
genShelleyWitnessSigningKey :: GenT Identity ShelleyWitnessSigningKey
genShelleyWitnessSigningKey =
  [GenT Identity ShelleyWitnessSigningKey]
-> GenT Identity ShelleyWitnessSigningKey
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
    [ SigningKey PaymentKey -> ShelleyWitnessSigningKey
WitnessPaymentKey (SigningKey PaymentKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey PaymentKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType PaymentKey -> GenT Identity (SigningKey PaymentKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType PaymentKey
AsPaymentKey
    , SigningKey PaymentExtendedKey -> ShelleyWitnessSigningKey
WitnessPaymentExtendedKey (SigningKey PaymentExtendedKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey PaymentExtendedKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType PaymentExtendedKey
-> GenT Identity (SigningKey PaymentExtendedKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType PaymentExtendedKey
AsPaymentExtendedKey
    , SigningKey StakeKey -> ShelleyWitnessSigningKey
WitnessStakeKey (SigningKey StakeKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey StakeKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType StakeKey -> GenT Identity (SigningKey StakeKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType StakeKey
AsStakeKey
    , SigningKey StakePoolKey -> ShelleyWitnessSigningKey
WitnessStakePoolKey (SigningKey StakePoolKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey StakePoolKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType StakePoolKey -> GenT Identity (SigningKey StakePoolKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType StakePoolKey
AsStakePoolKey
    , SigningKey GenesisDelegateKey -> ShelleyWitnessSigningKey
WitnessGenesisDelegateKey (SigningKey GenesisDelegateKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey GenesisDelegateKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType GenesisDelegateKey
-> GenT Identity (SigningKey GenesisDelegateKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType GenesisDelegateKey
AsGenesisDelegateKey
    , SigningKey GenesisUTxOKey -> ShelleyWitnessSigningKey
WitnessGenesisUTxOKey (SigningKey GenesisUTxOKey -> ShelleyWitnessSigningKey)
-> GenT Identity (SigningKey GenesisUTxOKey)
-> GenT Identity ShelleyWitnessSigningKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType GenesisUTxOKey -> GenT Identity (SigningKey GenesisUTxOKey)
forall keyrole.
Key keyrole =>
AsType keyrole -> Gen (SigningKey keyrole)
genSigningKey AsType GenesisUTxOKey
AsGenesisUTxOKey
    ]

genCardanoKeyWitness
  :: ()
  => ShelleyBasedEra era
  -> Gen (KeyWitness era)
genCardanoKeyWitness :: forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genCardanoKeyWitness = ShelleyBasedEra era -> Gen (KeyWitness era)
forall era. ShelleyBasedEra era -> Gen (KeyWitness era)
genShelleyWitness

genSeed :: Int -> Gen Crypto.Seed
genSeed :: Int -> Gen Seed
genSeed Int
n = ByteString -> Seed
Crypto.mkSeedFromBytes (ByteString -> Seed) -> GenT Identity ByteString -> Gen Seed
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Int -> Range Int
forall a. a -> Range a
Range.singleton Int
n)

genNat :: Gen Natural
genNat :: Gen Natural
genNat = Range Natural -> Gen Natural
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Natural -> Natural -> Range Natural
forall a. Integral a => a -> a -> Range a
Range.linear Natural
0 Natural
10)

genWord16 :: Gen Word16
genWord16 :: GenT Identity Word16
genWord16 = Range Word16 -> GenT Identity Word16
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Word16 -> Word16 -> Range Word16
forall a. Integral a => a -> a -> Range a
Range.linear Word16
0 Word16
10)

genWord32 :: Gen Word32
genWord32 :: GenT Identity Word32
genWord32 = Range Word32 -> GenT Identity Word32
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Word32 -> Word32 -> Range Word32
forall a. Integral a => a -> a -> Range a
Range.linear Word32
0 Word32
10)

genRational :: Gen Rational
genRational :: Gen Rational
genRational =
  (\Word64
d -> Ratio Word64 -> Rational
ratioToRational (Word64
1 Word64 -> Word64 -> Ratio Word64
forall a. Integral a => a -> a -> Ratio a
% Word64
d)) (Word64 -> Rational) -> GenT Identity Word64 -> Gen Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity Word64
genDenominator
 where
  genDenominator :: Gen Word64
  genDenominator :: GenT Identity Word64
genDenominator = Range Word64 -> GenT Identity Word64
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Word64 -> Word64 -> Range Word64
forall a. Integral a => a -> a -> Range a
Range.linear Word64
1 Word64
forall a. Bounded a => a
maxBound)

  ratioToRational :: Ratio Word64 -> Rational
  ratioToRational :: Ratio Word64 -> Rational
ratioToRational = Ratio Word64 -> Rational
forall a. Real a => a -> Rational
toRational

-- TODO: consolidate this back to just genRational once this is merged:
-- https://github.com/input-output-hk/cardano-ledger-specs/pull/2330
genRationalInt64 :: Gen Rational
genRationalInt64 :: Gen Rational
genRationalInt64 =
  (\Int64
d -> Ratio Int64 -> Rational
ratioToRational (Int64
1 Int64 -> Int64 -> Ratio Int64
forall a. Integral a => a -> a -> Ratio a
% Int64
d)) (Int64 -> Rational) -> GenT Identity Int64 -> Gen Rational
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity Int64
genDenominator
 where
  genDenominator :: Gen Int64
  genDenominator :: GenT Identity Int64
genDenominator = Range Int64 -> GenT Identity Int64
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int64 -> Int64 -> Range Int64
forall a. Integral a => a -> a -> Range a
Range.linear Int64
1 Int64
forall a. Bounded a => a
maxBound)

  ratioToRational :: Ratio Int64 -> Rational
  ratioToRational :: Ratio Int64 -> Rational
ratioToRational = Ratio Int64 -> Rational
forall a. Real a => a -> Rational
toRational

genEpochNo :: Gen EpochNo
genEpochNo :: GenT Identity EpochNo
genEpochNo = Word64 -> EpochNo
EpochNo (Word64 -> EpochNo)
-> GenT Identity Word64 -> GenT Identity EpochNo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word64 -> GenT Identity Word64
forall (m :: * -> *). MonadGen m => Range Word64 -> m Word64
Gen.word64 (Word64 -> Word64 -> Range Word64
forall a. Integral a => a -> a -> Range a
Range.linear Word64
0 Word64
10)

genEpochInterval :: Gen Ledger.EpochInterval
genEpochInterval :: Gen EpochInterval
genEpochInterval = Word32 -> EpochInterval
Ledger.EpochInterval (Word32 -> EpochInterval)
-> GenT Identity Word32 -> Gen EpochInterval
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Word32 -> GenT Identity Word32
forall (m :: * -> *). MonadGen m => Range Word32 -> m Word32
Gen.word32 (Word32 -> Word32 -> Range Word32
forall a. Integral a => a -> a -> Range a
Range.linear Word32
0 Word32
10)

genPraosNonce :: Gen PraosNonce
genPraosNonce :: Gen PraosNonce
genPraosNonce = ByteString -> PraosNonce
makePraosNonce (ByteString -> PraosNonce)
-> GenT Identity ByteString -> Gen PraosNonce
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity ByteString
forall (m :: * -> *). MonadGen m => Range Int -> m ByteString
Gen.bytes (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
32)

genMaybePraosNonce :: Gen (Maybe PraosNonce)
genMaybePraosNonce :: Gen (Maybe PraosNonce)
genMaybePraosNonce = Gen PraosNonce -> Gen (Maybe PraosNonce)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen PraosNonce
genPraosNonce

genProtocolParameters :: CardanoEra era -> Gen ProtocolParameters
genProtocolParameters :: forall era. CardanoEra era -> Gen ProtocolParameters
genProtocolParameters CardanoEra era
era = do
  (Natural, Natural)
protocolParamProtocolVersion <- (,) (Natural -> Natural -> (Natural, Natural))
-> Gen Natural -> GenT Identity (Natural -> (Natural, Natural))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Natural
genNat GenT Identity (Natural -> (Natural, Natural))
-> Gen Natural -> GenT Identity (Natural, Natural)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Natural
genNat
  Maybe Rational
protocolParamDecentralization <- Gen Rational -> GenT Identity (Maybe Rational)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Rational
genRational
  Maybe PraosNonce
protocolParamExtraPraosEntropy <- Gen (Maybe PraosNonce)
genMaybePraosNonce
  Natural
protocolParamMaxBlockHeaderSize <- Gen Natural
genNat
  Natural
protocolParamMaxBlockBodySize <- Gen Natural
genNat
  Natural
protocolParamMaxTxSize <- Gen Natural
genNat
  Coin
protocolParamTxFeeFixed <- Gen Coin
genLovelace
  Coin
protocolParamTxFeePerByte <- Gen Coin
genLovelace
  Maybe Coin
protocolParamMinUTxOValue <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Coin
protocolParamStakeAddressDeposit <- Gen Coin
genLovelace
  Coin
protocolParamStakePoolDeposit <- Gen Coin
genLovelace
  Coin
protocolParamMinPoolCost <- Gen Coin
genLovelace
  EpochInterval
protocolParamPoolRetireMaxEpoch <- Gen EpochInterval
genEpochInterval
  Word16
protocolParamStakePoolTargetNum <- GenT Identity Word16
genWord16
  Rational
protocolParamPoolPledgeInfluence <- Gen Rational
genRationalInt64
  Rational
protocolParamMonetaryExpansion <- Gen Rational
genRational
  Rational
protocolParamTreasuryCut <- Gen Rational
genRational
  let protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels = Map AnyPlutusScriptVersion CostModel
forall a. Monoid a => a
mempty
  -- TODO: Babbage figure out how to deal with
  -- asymmetric cost model JSON instances
  Maybe ExecutionUnitPrices
protocolParamPrices <- GenT Identity ExecutionUnitPrices
-> GenT Identity (Maybe ExecutionUnitPrices)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnitPrices
genExecutionUnitPrices
  Maybe ExecutionUnits
protocolParamMaxTxExUnits <- GenT Identity ExecutionUnits
-> GenT Identity (Maybe ExecutionUnits)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnits
genExecutionUnits
  Maybe ExecutionUnits
protocolParamMaxBlockExUnits <- GenT Identity ExecutionUnits
-> GenT Identity (Maybe ExecutionUnits)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnits
genExecutionUnits
  Maybe Natural
protocolParamMaxValueSize <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Natural
protocolParamCollateralPercent <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Natural
protocolParamMaxCollateralInputs <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Coin
protocolParamUTxOCostPerByte <-
    forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra @BabbageEraOnwards (Maybe Coin -> GenT Identity (Maybe Coin)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Coin
forall a. Maybe a
Nothing) (GenT Identity (Maybe Coin)
-> BabbageEraOnwards era -> GenT Identity (Maybe Coin)
forall a b. a -> b -> a
const (Coin -> Maybe Coin
forall a. a -> Maybe a
Just (Coin -> Maybe Coin) -> Gen Coin -> GenT Identity (Maybe Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genLovelace)) CardanoEra era
era

  ProtocolParameters -> Gen ProtocolParameters
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ProtocolParameters{Natural
Maybe Natural
Maybe Rational
Maybe Coin
Maybe ExecutionUnits
Maybe ExecutionUnitPrices
Maybe PraosNonce
Rational
Word16
(Natural, Natural)
Coin
EpochInterval
Map AnyPlutusScriptVersion CostModel
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamDecentralization :: Maybe Rational
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxTxSize :: Natural
protocolParamTxFeeFixed :: Coin
protocolParamTxFeePerByte :: Coin
protocolParamMinUTxOValue :: Maybe Coin
protocolParamStakeAddressDeposit :: Coin
protocolParamStakePoolDeposit :: Coin
protocolParamMinPoolCost :: Coin
protocolParamPoolRetireMaxEpoch :: EpochInterval
protocolParamStakePoolTargetNum :: Word16
protocolParamPoolPledgeInfluence :: Rational
protocolParamMonetaryExpansion :: Rational
protocolParamTreasuryCut :: Rational
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxValueSize :: Maybe Natural
protocolParamCollateralPercent :: Maybe Natural
protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamUTxOCostPerByte :: Maybe Coin
protocolParamCollateralPercent :: Maybe Natural
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamDecentralization :: Maybe Rational
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamMaxTxSize :: Natural
protocolParamMaxValueSize :: Maybe Natural
protocolParamMinPoolCost :: Coin
protocolParamMinUTxOValue :: Maybe Coin
protocolParamMonetaryExpansion :: Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolRetireMaxEpoch :: EpochInterval
protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamStakeAddressDeposit :: Coin
protocolParamStakePoolDeposit :: Coin
protocolParamStakePoolTargetNum :: Word16
protocolParamTreasuryCut :: Rational
protocolParamTxFeeFixed :: Coin
protocolParamTxFeePerByte :: Coin
protocolParamUTxOCostPerByte :: Maybe Coin
..}

-- | Generate valid protocol parameters which pass validations in Cardano.Api.Internal.ProtocolParameters
genValidProtocolParameters :: ShelleyBasedEra era -> Gen (LedgerProtocolParameters era)
genValidProtocolParameters :: forall era.
ShelleyBasedEra era -> Gen (LedgerProtocolParameters era)
genValidProtocolParameters ShelleyBasedEra era
sbe = ShelleyBasedEra era
-> ((Era (ShelleyLedgerEra era),
     Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
     Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
    Gen (LedgerProtocolParameters era))
-> Gen (LedgerProtocolParameters era)
forall era a.
ShelleyBasedEra era
-> ((Era (ShelleyLedgerEra era),
     Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
     Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
    a)
-> a
shelleyBasedEraTestConstraints ShelleyBasedEra era
sbe (((Era (ShelleyLedgerEra era),
   Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
   Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
  Gen (LedgerProtocolParameters era))
 -> Gen (LedgerProtocolParameters era))
-> ((Era (ShelleyLedgerEra era),
     Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
     Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
    Gen (LedgerProtocolParameters era))
-> Gen (LedgerProtocolParameters era)
forall a b. (a -> b) -> a -> b
$ PParams (ShelleyLedgerEra era) -> LedgerProtocolParameters era
forall era.
PParams (ShelleyLedgerEra era) -> LedgerProtocolParameters era
LedgerProtocolParameters (PParams (ShelleyLedgerEra era) -> LedgerProtocolParameters era)
-> GenT Identity (PParams (ShelleyLedgerEra era))
-> Gen (LedgerProtocolParameters era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (PParams (ShelleyLedgerEra era))
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genProtocolParametersUpdate :: CardanoEra era -> Gen ProtocolParametersUpdate
genProtocolParametersUpdate :: forall era. CardanoEra era -> Gen ProtocolParametersUpdate
genProtocolParametersUpdate CardanoEra era
era = do
  Maybe (Natural, Natural)
protocolUpdateProtocolVersion <- GenT Identity (Natural, Natural)
-> GenT Identity (Maybe (Natural, Natural))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe ((,) (Natural -> Natural -> (Natural, Natural))
-> Gen Natural -> GenT Identity (Natural -> (Natural, Natural))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Natural
genNat GenT Identity (Natural -> (Natural, Natural))
-> Gen Natural -> GenT Identity (Natural, Natural)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Natural
genNat)
  Maybe Rational
protocolUpdateDecentralization <- Gen Rational -> GenT Identity (Maybe Rational)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Rational
genRational
  Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy <- Gen (Maybe PraosNonce) -> GenT Identity (Maybe (Maybe PraosNonce))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen (Maybe PraosNonce)
genMaybePraosNonce
  Maybe Word16
protocolUpdateMaxBlockHeaderSize <- GenT Identity Word16 -> GenT Identity (Maybe Word16)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity Word16
genWord16
  Maybe Word32
protocolUpdateMaxBlockBodySize <- GenT Identity Word32 -> GenT Identity (Maybe Word32)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity Word32
genWord32
  Maybe Word32
protocolUpdateMaxTxSize <- GenT Identity Word32 -> GenT Identity (Maybe Word32)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity Word32
genWord32
  Maybe Coin
protocolUpdateTxFeeFixed <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe Coin
protocolUpdateTxFeePerByte <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe Coin
protocolUpdateMinUTxOValue <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe Coin
protocolUpdateStakeAddressDeposit <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe Coin
protocolUpdateStakePoolDeposit <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe Coin
protocolUpdateMinPoolCost <- Gen Coin -> GenT Identity (Maybe Coin)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Coin
genLovelace
  Maybe EpochInterval
protocolUpdatePoolRetireMaxEpoch <- Gen EpochInterval -> GenT Identity (Maybe EpochInterval)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen EpochInterval
genEpochInterval
  Maybe Word16
protocolUpdateStakePoolTargetNum <- GenT Identity Word16 -> GenT Identity (Maybe Word16)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity Word16
genWord16
  Maybe Rational
protocolUpdatePoolPledgeInfluence <- Gen Rational -> GenT Identity (Maybe Rational)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Rational
genRationalInt64
  Maybe Rational
protocolUpdateMonetaryExpansion <- Gen Rational -> GenT Identity (Maybe Rational)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Rational
genRational
  Maybe Rational
protocolUpdateTreasuryCut <- Gen Rational -> GenT Identity (Maybe Rational)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Rational
genRational
  let protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels = Map AnyPlutusScriptVersion CostModel
forall a. Monoid a => a
mempty -- genCostModels
  -- TODO: Babbage figure out how to deal with
  -- asymmetric cost model JSON instances
  Maybe ExecutionUnitPrices
protocolUpdatePrices <- GenT Identity ExecutionUnitPrices
-> GenT Identity (Maybe ExecutionUnitPrices)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnitPrices
genExecutionUnitPrices
  Maybe ExecutionUnits
protocolUpdateMaxTxExUnits <- GenT Identity ExecutionUnits
-> GenT Identity (Maybe ExecutionUnits)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnits
genExecutionUnits
  Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits <- GenT Identity ExecutionUnits
-> GenT Identity (Maybe ExecutionUnits)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe GenT Identity ExecutionUnits
genExecutionUnits
  Maybe Natural
protocolUpdateMaxValueSize <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Natural
protocolUpdateCollateralPercent <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Natural
protocolUpdateMaxCollateralInputs <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  Maybe Coin
protocolUpdateUTxOCostPerByte <-
    forall (eon :: * -> *) a era.
Eon eon =>
a -> (eon era -> a) -> CardanoEra era -> a
inEonForEra @BabbageEraOnwards (Maybe Coin -> GenT Identity (Maybe Coin)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Coin
forall a. Maybe a
Nothing) (GenT Identity (Maybe Coin)
-> BabbageEraOnwards era -> GenT Identity (Maybe Coin)
forall a b. a -> b -> a
const (Coin -> Maybe Coin
forall a. a -> Maybe a
Just (Coin -> Maybe Coin) -> Gen Coin -> GenT Identity (Maybe Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
genLovelace)) CardanoEra era
era

  ProtocolParametersUpdate -> Gen ProtocolParametersUpdate
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ProtocolParametersUpdate{Maybe Natural
Maybe (Maybe PraosNonce)
Maybe Rational
Maybe Word16
Maybe Word32
Maybe (Natural, Natural)
Maybe Coin
Maybe EpochInterval
Maybe ExecutionUnits
Maybe ExecutionUnitPrices
Map AnyPlutusScriptVersion CostModel
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateMaxBlockHeaderSize :: Maybe Word16
protocolUpdateMaxBlockBodySize :: Maybe Word32
protocolUpdateMaxTxSize :: Maybe Word32
protocolUpdateTxFeeFixed :: Maybe Coin
protocolUpdateTxFeePerByte :: Maybe Coin
protocolUpdateMinUTxOValue :: Maybe Coin
protocolUpdateStakeAddressDeposit :: Maybe Coin
protocolUpdateStakePoolDeposit :: Maybe Coin
protocolUpdateMinPoolCost :: Maybe Coin
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochInterval
protocolUpdateStakePoolTargetNum :: Maybe Word16
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateUTxOCostPerByte :: Maybe Coin
protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateMaxBlockBodySize :: Maybe Word32
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockHeaderSize :: Maybe Word16
protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxSize :: Maybe Word32
protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMinPoolCost :: Maybe Coin
protocolUpdateMinUTxOValue :: Maybe Coin
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochInterval
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateStakeAddressDeposit :: Maybe Coin
protocolUpdateStakePoolDeposit :: Maybe Coin
protocolUpdateStakePoolTargetNum :: Maybe Word16
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTxFeeFixed :: Maybe Coin
protocolUpdateTxFeePerByte :: Maybe Coin
protocolUpdateUTxOCostPerByte :: Maybe Coin
..}

genUpdateProposal :: CardanoEra era -> Gen UpdateProposal
genUpdateProposal :: forall era. CardanoEra era -> GenT Identity UpdateProposal
genUpdateProposal CardanoEra era
era =
  Map (Hash GenesisKey) ProtocolParametersUpdate
-> EpochNo -> UpdateProposal
UpdateProposal
    (Map (Hash GenesisKey) ProtocolParametersUpdate
 -> EpochNo -> UpdateProposal)
-> GenT Identity (Map (Hash GenesisKey) ProtocolParametersUpdate)
-> GenT Identity (EpochNo -> UpdateProposal)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int
-> GenT Identity (Hash GenesisKey, ProtocolParametersUpdate)
-> GenT Identity (Map (Hash GenesisKey) ProtocolParametersUpdate)
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map
      (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
3)
      ( (,)
          (Hash GenesisKey
 -> ProtocolParametersUpdate
 -> (Hash GenesisKey, ProtocolParametersUpdate))
-> GenT Identity (Hash GenesisKey)
-> GenT
     Identity
     (ProtocolParametersUpdate
      -> (Hash GenesisKey, ProtocolParametersUpdate))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AsType GenesisKey -> GenT Identity (Hash GenesisKey)
forall keyrole.
(HasTypeProxy keyrole, Key keyrole) =>
AsType keyrole -> Gen (Hash keyrole)
genVerificationKeyHash AsType GenesisKey
AsGenesisKey
          GenT
  Identity
  (ProtocolParametersUpdate
   -> (Hash GenesisKey, ProtocolParametersUpdate))
-> Gen ProtocolParametersUpdate
-> GenT Identity (Hash GenesisKey, ProtocolParametersUpdate)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> CardanoEra era -> Gen ProtocolParametersUpdate
forall era. CardanoEra era -> Gen ProtocolParametersUpdate
genProtocolParametersUpdate CardanoEra era
era
      )
    GenT Identity (EpochNo -> UpdateProposal)
-> GenT Identity EpochNo -> GenT Identity UpdateProposal
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity EpochNo
genEpochNo

genCostModel :: MonadGen m => m Alonzo.CostModel
genCostModel :: forall (m :: * -> *). MonadGen m => m CostModel
genCostModel = m CostModel
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genCostModels :: MonadGen m => m Alonzo.CostModels
genCostModels :: forall (m :: * -> *). MonadGen m => m CostModels
genCostModels = m CostModels
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genExecutionUnits :: Gen ExecutionUnits
genExecutionUnits :: GenT Identity ExecutionUnits
genExecutionUnits =
  Natural -> Natural -> ExecutionUnits
ExecutionUnits
    (Natural -> Natural -> ExecutionUnits)
-> Gen Natural -> GenT Identity (Natural -> ExecutionUnits)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Natural -> Gen Natural
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Natural -> Natural -> Range Natural
forall a. a -> a -> Range a
Range.constant Natural
0 Natural
1000)
    GenT Identity (Natural -> ExecutionUnits)
-> Gen Natural -> GenT Identity ExecutionUnits
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Natural -> Gen Natural
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Natural -> Natural -> Range Natural
forall a. a -> a -> Range a
Range.constant Natural
0 Natural
1000)

genExecutionUnitPrices :: Gen ExecutionUnitPrices
genExecutionUnitPrices :: GenT Identity ExecutionUnitPrices
genExecutionUnitPrices = Rational -> Rational -> ExecutionUnitPrices
ExecutionUnitPrices (Rational -> Rational -> ExecutionUnitPrices)
-> Gen Rational -> GenT Identity (Rational -> ExecutionUnitPrices)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Rational
genRational GenT Identity (Rational -> ExecutionUnitPrices)
-> Gen Rational -> GenT Identity ExecutionUnitPrices
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Rational
genRational

genTxOutDatumHashTxContext :: ShelleyBasedEra era -> Gen (TxOutDatum CtxTx era)
genTxOutDatumHashTxContext :: forall era. ShelleyBasedEra era -> Gen (TxOutDatum CtxTx era)
genTxOutDatumHashTxContext ShelleyBasedEra era
era = case ShelleyBasedEra era
era of
  ShelleyBasedEra era
ShelleyBasedEraShelley -> TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraAllegra -> TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraMary -> TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraAlonzo ->
    [Gen (TxOutDatum CtxTx era)] -> Gen (TxOutDatum CtxTx era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo (Hash ScriptData -> TxOutDatum CtxTx era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      , AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo (HashableScriptData -> TxOutDatum CtxTx era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ]
  ShelleyBasedEra era
ShelleyBasedEraBabbage ->
    [Gen (TxOutDatum CtxTx era)] -> Gen (TxOutDatum CtxTx era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage (Hash ScriptData -> TxOutDatum CtxTx era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      , AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage (HashableScriptData -> TxOutDatum CtxTx era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      , BabbageEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage (HashableScriptData -> TxOutDatum CtxTx era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ]
  ShelleyBasedEra era
ShelleyBasedEraConway ->
    [Gen (TxOutDatum CtxTx era)] -> Gen (TxOutDatum CtxTx era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxTx era -> Gen (TxOutDatum CtxTx era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway (Hash ScriptData -> TxOutDatum CtxTx era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      , AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway (HashableScriptData -> TxOutDatum CtxTx era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      , BabbageEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway (HashableScriptData -> TxOutDatum CtxTx era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ]

genTxOutDatumHashUTxOContext :: ShelleyBasedEra era -> Gen (TxOutDatum CtxUTxO era)
genTxOutDatumHashUTxOContext :: forall era. ShelleyBasedEra era -> Gen (TxOutDatum CtxUTxO era)
genTxOutDatumHashUTxOContext ShelleyBasedEra era
era = case ShelleyBasedEra era
era of
  ShelleyBasedEra era
ShelleyBasedEraShelley -> TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraAllegra -> TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraMary -> TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  ShelleyBasedEra era
ShelleyBasedEraAlonzo ->
    [Gen (TxOutDatum CtxUTxO era)] -> Gen (TxOutDatum CtxUTxO era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo (Hash ScriptData -> TxOutDatum CtxUTxO era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      ]
  ShelleyBasedEra era
ShelleyBasedEraBabbage ->
    [Gen (TxOutDatum CtxUTxO era)] -> Gen (TxOutDatum CtxUTxO era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage (Hash ScriptData -> TxOutDatum CtxUTxO era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      , BabbageEraOnwards era
-> HashableScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage (HashableScriptData -> TxOutDatum CtxUTxO era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ]
  ShelleyBasedEra era
ShelleyBasedEraConway ->
    [Gen (TxOutDatum CtxUTxO era)] -> Gen (TxOutDatum CtxUTxO era)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
      [ TxOutDatum CtxUTxO era -> Gen (TxOutDatum CtxUTxO era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
      , AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway (Hash ScriptData -> TxOutDatum CtxUTxO era)
-> GenT Identity (Hash ScriptData) -> Gen (TxOutDatum CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash ScriptData)
genHashScriptData
      , BabbageEraOnwards era
-> HashableScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway (HashableScriptData -> TxOutDatum CtxUTxO era)
-> Gen HashableScriptData -> Gen (TxOutDatum CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ]

mkDummyHash :: forall h a. CRYPTO.HashAlgorithm h => Int -> CRYPTO.Hash h a
mkDummyHash :: forall h a. HashAlgorithm h => Int -> Hash h a
mkDummyHash = Hash h Int -> Hash h a
forall a b. Coercible a b => a -> b
coerce (Hash h Int -> Hash h a) -> (Int -> Hash h Int) -> Int -> Hash h a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall h a. HashAlgorithm h => (a -> Encoding) -> a -> Hash h a
CRYPTO.hashWithSerialiser @h Int -> Encoding
forall a. ToCBOR a => a -> Encoding
CBOR.toCBOR

genHashScriptData :: Gen (Cardano.Api.Hash ScriptData)
genHashScriptData :: GenT Identity (Hash ScriptData)
genHashScriptData = DataHash StandardCrypto -> Hash ScriptData
ScriptDataHash (DataHash StandardCrypto -> Hash ScriptData)
-> (Int -> DataHash StandardCrypto) -> Int -> Hash ScriptData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hash Blake2b_256 EraIndependentData -> DataHash StandardCrypto
Hash (HASH StandardCrypto) EraIndependentData
-> DataHash StandardCrypto
forall c index. Hash (HASH c) index -> SafeHash c index
unsafeMakeSafeHash (Hash Blake2b_256 EraIndependentData -> DataHash StandardCrypto)
-> (Int -> Hash Blake2b_256 EraIndependentData)
-> Int
-> DataHash StandardCrypto
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Hash Blake2b_256 EraIndependentData
forall h a. HashAlgorithm h => Int -> Hash h a
mkDummyHash (Int -> Hash ScriptData)
-> GenT Identity Int -> GenT Identity (Hash ScriptData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity Int
forall (m :: * -> *). MonadGen m => Range Int -> m Int
Gen.int (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10)

genGovernancePoll :: Gen GovernancePoll
genGovernancePoll :: Gen GovernancePoll
genGovernancePoll =
  Text -> [Text] -> Maybe Word -> GovernancePoll
GovernancePoll
    (Text -> [Text] -> Maybe Word -> GovernancePoll)
-> GenT Identity Text
-> GenT Identity ([Text] -> Maybe Word -> GovernancePoll)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity Char -> GenT Identity Text
forall (m :: * -> *). MonadGen m => Range Int -> m Char -> m Text
Gen.text (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
1 Int
255) GenT Identity Char
forall (m :: * -> *). MonadGen m => m Char
Gen.unicodeAll
    GenT Identity ([Text] -> Maybe Word -> GovernancePoll)
-> GenT Identity [Text]
-> GenT Identity (Maybe Word -> GovernancePoll)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Int -> GenT Identity Text -> GenT Identity [Text]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
1 Int
10) (Range Int -> GenT Identity Char -> GenT Identity Text
forall (m :: * -> *). MonadGen m => Range Int -> m Char -> m Text
Gen.text (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
1 Int
255) GenT Identity Char
forall (m :: * -> *). MonadGen m => m Char
Gen.unicodeAll)
    GenT Identity (Maybe Word -> GovernancePoll)
-> GenT Identity (Maybe Word) -> Gen GovernancePoll
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenT Identity Word -> GenT Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Range Word -> GenT Identity Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word (Word -> Word -> Range Word
forall a. a -> a -> Range a
Range.constant Word
0 Word
100))

genGovernancePollAnswer :: Gen GovernancePollAnswer
genGovernancePollAnswer :: Gen GovernancePollAnswer
genGovernancePollAnswer =
  Hash GovernancePoll -> Word -> GovernancePollAnswer
GovernancePollAnswer
    (Hash GovernancePoll -> Word -> GovernancePollAnswer)
-> GenT Identity (Hash GovernancePoll)
-> GenT Identity (Word -> GovernancePollAnswer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (Hash GovernancePoll)
genGovernancePollHash
    GenT Identity (Word -> GovernancePollAnswer)
-> GenT Identity Word -> Gen GovernancePollAnswer
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Range Word -> GenT Identity Word
forall (m :: * -> *). MonadGen m => Range Word -> m Word
Gen.word (Word -> Word -> Range Word
forall a. a -> a -> Range a
Range.constant Word
0 Word
10)
 where
  genGovernancePollHash :: GenT Identity (Hash GovernancePoll)
genGovernancePollHash =
    Hash Blake2b_256 GovernancePoll -> Hash GovernancePoll
Hash (HASH StandardCrypto) GovernancePoll -> Hash GovernancePoll
GovernancePollHash (Hash Blake2b_256 GovernancePoll -> Hash GovernancePoll)
-> (Int -> Hash Blake2b_256 GovernancePoll)
-> Int
-> Hash GovernancePoll
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Hash Blake2b_256 GovernancePoll
forall h a. HashAlgorithm h => Int -> Hash h a
mkDummyHash (Int -> Hash GovernancePoll)
-> GenT Identity Int -> GenT Identity (Hash GovernancePoll)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Range Int -> GenT Identity Int
forall (m :: * -> *). MonadGen m => Range Int -> m Int
Gen.int (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
10)

genProposals :: Applicative (BuildTxWith build)
             => ConwayEraOnwards era
             -> Gen (TxProposalProcedures build era)
genProposals :: forall build era.
Applicative (BuildTxWith build) =>
ConwayEraOnwards era -> Gen (TxProposalProcedures build era)
genProposals ConwayEraOnwards era
w = ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (TxProposalProcedures build era))
-> Gen (TxProposalProcedures build era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (TxProposalProcedures build era))
 -> Gen (TxProposalProcedures build era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (TxProposalProcedures build era))
-> Gen (TxProposalProcedures build era)
forall a b. (a -> b) -> a -> b
$ do
  [ProposalProcedure (ShelleyLedgerEra era)]
proposals <- Range Int
-> GenT Identity (ProposalProcedure (ShelleyLedgerEra era))
-> GenT Identity [ProposalProcedure (ShelleyLedgerEra era)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
15) (ConwayEraOnwards era
-> GenT Identity (ProposalProcedure (ShelleyLedgerEra era))
forall era.
ConwayEraOnwards era
-> Gen (ProposalProcedure (ShelleyLedgerEra era))
genProposal ConwayEraOnwards era
w)
  let sbe :: ShelleyBasedEra era
sbe = ConwayEraOnwards era -> ShelleyBasedEra era
forall era. ConwayEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert ConwayEraOnwards era
w
  [(ProposalProcedure (ShelleyLedgerEra era),
  Maybe (ScriptWitness WitCtxStake era))]
proposalsWithMaybeWitnesses <-
    [ProposalProcedure (ShelleyLedgerEra era)]
-> (ProposalProcedure (ShelleyLedgerEra era)
    -> GenT
         Identity
         (ProposalProcedure (ShelleyLedgerEra era),
          Maybe (ScriptWitness WitCtxStake era)))
-> GenT
     Identity
     [(ProposalProcedure (ShelleyLedgerEra era),
       Maybe (ScriptWitness WitCtxStake era))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [ProposalProcedure (ShelleyLedgerEra era)]
proposals ((ProposalProcedure (ShelleyLedgerEra era)
  -> GenT
       Identity
       (ProposalProcedure (ShelleyLedgerEra era),
        Maybe (ScriptWitness WitCtxStake era)))
 -> GenT
      Identity
      [(ProposalProcedure (ShelleyLedgerEra era),
        Maybe (ScriptWitness WitCtxStake era))])
-> (ProposalProcedure (ShelleyLedgerEra era)
    -> GenT
         Identity
         (ProposalProcedure (ShelleyLedgerEra era),
          Maybe (ScriptWitness WitCtxStake era)))
-> GenT
     Identity
     [(ProposalProcedure (ShelleyLedgerEra era),
       Maybe (ScriptWitness WitCtxStake era))]
forall a b. (a -> b) -> a -> b
$ \ProposalProcedure (ShelleyLedgerEra era)
proposal ->
      (ProposalProcedure (ShelleyLedgerEra era)
proposal,) (Maybe (ScriptWitness WitCtxStake era)
 -> (ProposalProcedure (ShelleyLedgerEra era),
     Maybe (ScriptWitness WitCtxStake era)))
-> GenT Identity (Maybe (ScriptWitness WitCtxStake era))
-> GenT
     Identity
     (ProposalProcedure (ShelleyLedgerEra era),
      Maybe (ScriptWitness WitCtxStake era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (ScriptWitness WitCtxStake era)
-> GenT Identity (Maybe (ScriptWitness WitCtxStake era))
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe (ShelleyBasedEra era
-> GenT Identity (ScriptWitness WitCtxStake era)
forall era.
ShelleyBasedEra era -> Gen (ScriptWitness WitCtxStake era)
genScriptWitnessForStake ShelleyBasedEra era
sbe)
  TxProposalProcedures build era
-> Gen (TxProposalProcedures build era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxProposalProcedures build era
 -> Gen (TxProposalProcedures build era))
-> TxProposalProcedures build era
-> Gen (TxProposalProcedures build era)
forall a b. (a -> b) -> a -> b
$ [(ProposalProcedure (ShelleyLedgerEra era),
  Maybe (ScriptWitness WitCtxStake era))]
-> TxProposalProcedures build era
forall era build.
(Applicative (BuildTxWith build), IsShelleyBasedEra era) =>
[(ProposalProcedure (ShelleyLedgerEra era),
  Maybe (ScriptWitness WitCtxStake era))]
-> TxProposalProcedures build era
mkTxProposalProcedures [(ProposalProcedure (ShelleyLedgerEra era),
  Maybe (ScriptWitness WitCtxStake era))]
proposalsWithMaybeWitnesses

genProposal :: ConwayEraOnwards era -> Gen (L.ProposalProcedure (ShelleyLedgerEra era))
genProposal :: forall era.
ConwayEraOnwards era
-> Gen (ProposalProcedure (ShelleyLedgerEra era))
genProposal ConwayEraOnwards era
w =
  ConwayEraOnwards era
-> ((Era (ShelleyLedgerEra era),
     Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
     Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
    Gen (ProposalProcedure (ShelleyLedgerEra era)))
-> Gen (ProposalProcedure (ShelleyLedgerEra era))
forall era a.
ConwayEraOnwards era
-> ((Era (ShelleyLedgerEra era),
     Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
     Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
    a)
-> a
conwayEraOnwardsTestConstraints ConwayEraOnwards era
w Gen (ProposalProcedure (ShelleyLedgerEra era))
(Era (ShelleyLedgerEra era),
 Arbitrary (PParamsHKD StrictMaybe (ShelleyLedgerEra era)),
 Arbitrary (PParamsHKD Identity (ShelleyLedgerEra era))) =>
Gen (ProposalProcedure (ShelleyLedgerEra era))
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genVotingProcedures :: Applicative (BuildTxWith build)
                    => ConwayEraOnwards era
                    -> Gen (Api.TxVotingProcedures build era)
genVotingProcedures :: forall build era.
Applicative (BuildTxWith build) =>
ConwayEraOnwards era -> Gen (TxVotingProcedures build era)
genVotingProcedures ConwayEraOnwards era
w = ConwayEraOnwards era
-> (ConwayEraOnwardsConstraints era =>
    Gen (TxVotingProcedures build era))
-> Gen (TxVotingProcedures build era)
forall era a.
ConwayEraOnwards era -> (ConwayEraOnwardsConstraints era => a) -> a
conwayEraOnwardsConstraints ConwayEraOnwards era
w ((ConwayEraOnwardsConstraints era =>
  Gen (TxVotingProcedures build era))
 -> Gen (TxVotingProcedures build era))
-> (ConwayEraOnwardsConstraints era =>
    Gen (TxVotingProcedures build era))
-> Gen (TxVotingProcedures build era)
forall a b. (a -> b) -> a -> b
$ do
  [Voter StandardCrypto]
voters <- Range Int
-> GenT Identity (Voter StandardCrypto)
-> GenT Identity [Voter StandardCrypto]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
10) GenT Identity (Voter StandardCrypto)
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary
  let sbe :: ShelleyBasedEra era
sbe = ConwayEraOnwards era -> ShelleyBasedEra era
forall era. ConwayEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert ConwayEraOnwards era
w
  Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)
votersWithWitnesses <- ([(Voter StandardCrypto, ScriptWitness WitCtxStake era)]
 -> Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
-> GenT
     Identity [(Voter StandardCrypto, ScriptWitness WitCtxStake era)]
-> GenT
     Identity
     (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
forall a b. (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(Voter StandardCrypto, ScriptWitness WitCtxStake era)]
-> Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)
[Item (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))]
-> Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)
forall l. IsList l => [Item l] -> l
fromList (GenT
   Identity [(Voter StandardCrypto, ScriptWitness WitCtxStake era)]
 -> GenT
      Identity
      (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)))
-> ((Voter StandardCrypto
     -> GenT
          Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era))
    -> GenT
         Identity [(Voter StandardCrypto, ScriptWitness WitCtxStake era)])
-> (Voter StandardCrypto
    -> GenT
         Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era))
-> GenT
     Identity
     (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Voter StandardCrypto]
-> (Voter StandardCrypto
    -> GenT
         Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era))
-> GenT
     Identity [(Voter StandardCrypto, ScriptWitness WitCtxStake era)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Voter StandardCrypto]
voters ((Voter StandardCrypto
  -> GenT
       Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era))
 -> GenT
      Identity
      (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)))
-> (Voter StandardCrypto
    -> GenT
         Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era))
-> GenT
     Identity
     (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
forall a b. (a -> b) -> a -> b
$ \Voter StandardCrypto
voter ->
    (Voter StandardCrypto
voter,) (ScriptWitness WitCtxStake era
 -> (Voter StandardCrypto, ScriptWitness WitCtxStake era))
-> GenT Identity (ScriptWitness WitCtxStake era)
-> GenT
     Identity (Voter StandardCrypto, ScriptWitness WitCtxStake era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ShelleyBasedEra era
-> GenT Identity (ScriptWitness WitCtxStake era)
forall era.
ShelleyBasedEra era -> Gen (ScriptWitness WitCtxStake era)
genScriptWitnessForStake ShelleyBasedEra era
sbe
  VotingProcedures (ShelleyLedgerEra era)
-> BuildTxWith
     build
     (Map
        (Voter (EraCrypto (ShelleyLedgerEra era)))
        (ScriptWitness WitCtxStake era))
-> TxVotingProcedures build era
VotingProcedures (ShelleyLedgerEra era)
-> BuildTxWith
     build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
-> TxVotingProcedures build era
forall era build.
VotingProcedures (ShelleyLedgerEra era)
-> BuildTxWith
     build
     (Map
        (Voter (EraCrypto (ShelleyLedgerEra era)))
        (ScriptWitness WitCtxStake era))
-> TxVotingProcedures build era
Api.TxVotingProcedures (VotingProcedures (ShelleyLedgerEra era)
 -> BuildTxWith
      build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
 -> TxVotingProcedures build era)
-> GenT Identity (VotingProcedures (ShelleyLedgerEra era))
-> GenT
     Identity
     (BuildTxWith
        build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
      -> TxVotingProcedures build era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity (VotingProcedures (ShelleyLedgerEra era))
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary GenT
  Identity
  (BuildTxWith
     build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
   -> TxVotingProcedures build era)
-> GenT
     Identity
     (BuildTxWith
        build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)))
-> Gen (TxVotingProcedures build era)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BuildTxWith
  build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
-> GenT
     Identity
     (BuildTxWith
        build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)))
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)
-> BuildTxWith
     build (Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era))
forall a. a -> BuildTxWith build a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map (Voter StandardCrypto) (ScriptWitness WitCtxStake era)
votersWithWitnesses)

genCurrentTreasuryValue :: ConwayEraOnwards era -> Gen L.Coin
genCurrentTreasuryValue :: forall era. ConwayEraOnwards era -> Gen Coin
genCurrentTreasuryValue ConwayEraOnwards era
_era = Gen Coin
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

genTreasuryDonation :: ConwayEraOnwards era -> Gen L.Coin
genTreasuryDonation :: forall era. ConwayEraOnwards era -> Gen Coin
genTreasuryDonation ConwayEraOnwards era
_era = Gen Coin
forall a (m :: * -> *). (Arbitrary a, MonadGen m) => m a
Q.arbitrary

-- | This generator does not generate a valid witness - just a random one.
genScriptWitnessForStake :: ShelleyBasedEra era -> Gen (Api.ScriptWitness WitCtxStake era)
genScriptWitnessForStake :: forall era.
ShelleyBasedEra era -> Gen (ScriptWitness WitCtxStake era)
genScriptWitnessForStake ShelleyBasedEra era
sbe = do
  ScriptInEra ScriptLanguageInEra lang era
scriptLangInEra Script lang
script' <- ShelleyBasedEra era -> Gen (ScriptInEra era)
forall era. ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra ShelleyBasedEra era
sbe
  case Script lang
script' of
    SimpleScript SimpleScript
simpleScript -> do
      SimpleScriptOrReferenceInput SimpleScript'
simpleScriptOrReferenceInput <- [GenT Identity (SimpleScriptOrReferenceInput SimpleScript')]
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
        [ SimpleScriptOrReferenceInput SimpleScript'
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SimpleScriptOrReferenceInput SimpleScript'
 -> GenT Identity (SimpleScriptOrReferenceInput SimpleScript'))
-> SimpleScriptOrReferenceInput SimpleScript'
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall a b. (a -> b) -> a -> b
$ SimpleScript -> SimpleScriptOrReferenceInput SimpleScript'
forall lang. SimpleScript -> SimpleScriptOrReferenceInput lang
SScript SimpleScript
simpleScript
        , TxIn -> SimpleScriptOrReferenceInput SimpleScript'
forall lang. TxIn -> SimpleScriptOrReferenceInput lang
SReferenceScript (TxIn -> SimpleScriptOrReferenceInput SimpleScript')
-> Gen TxIn
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn
        ]
      ScriptWitness WitCtxStake era
-> Gen (ScriptWitness WitCtxStake era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ScriptWitness WitCtxStake era
 -> Gen (ScriptWitness WitCtxStake era))
-> ScriptWitness WitCtxStake era
-> Gen (ScriptWitness WitCtxStake era)
forall a b. (a -> b) -> a -> b
$ ScriptLanguageInEra SimpleScript' era
-> SimpleScriptOrReferenceInput SimpleScript'
-> ScriptWitness WitCtxStake era
forall era witctx.
ScriptLanguageInEra SimpleScript' era
-> SimpleScriptOrReferenceInput SimpleScript'
-> ScriptWitness witctx era
Api.SimpleScriptWitness ScriptLanguageInEra lang era
ScriptLanguageInEra SimpleScript' era
scriptLangInEra SimpleScriptOrReferenceInput SimpleScript'
simpleScriptOrReferenceInput
    PlutusScript PlutusScriptVersion lang
plutusScriptVersion' PlutusScript lang
plutusScript -> do
      PlutusScriptOrReferenceInput lang
plutusScriptOrReferenceInput <- [GenT Identity (PlutusScriptOrReferenceInput lang)]
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
        [ PlutusScriptOrReferenceInput lang
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PlutusScriptOrReferenceInput lang
 -> GenT Identity (PlutusScriptOrReferenceInput lang))
-> PlutusScriptOrReferenceInput lang
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall a b. (a -> b) -> a -> b
$ PlutusScript lang -> PlutusScriptOrReferenceInput lang
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
PScript PlutusScript lang
plutusScript
        , TxIn -> PlutusScriptOrReferenceInput lang
forall lang. TxIn -> PlutusScriptOrReferenceInput lang
PReferenceScript (TxIn -> PlutusScriptOrReferenceInput lang)
-> Gen TxIn -> GenT Identity (PlutusScriptOrReferenceInput lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn
        ]
      HashableScriptData
scriptRedeemer <- Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum WitCtxStake
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness WitCtxStake era
forall lang era witctx.
IsPlutusScriptLanguage lang =>
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness witctx era
PlutusScriptWitness
        ScriptLanguageInEra lang era
scriptLangInEra
        PlutusScriptVersion lang
plutusScriptVersion'
        PlutusScriptOrReferenceInput lang
plutusScriptOrReferenceInput
        ScriptDatum WitCtxStake
NoScriptDatumForStake
        HashableScriptData
scriptRedeemer
        (ExecutionUnits -> ScriptWitness WitCtxStake era)
-> GenT Identity ExecutionUnits
-> Gen (ScriptWitness WitCtxStake era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity ExecutionUnits
genExecutionUnits

genScriptWitnessForMint :: ShelleyBasedEra era -> Gen (Api.ScriptWitness WitCtxMint era)
genScriptWitnessForMint :: forall era.
ShelleyBasedEra era -> Gen (ScriptWitness WitCtxMint era)
genScriptWitnessForMint ShelleyBasedEra era
sbe = do
  ScriptInEra ScriptLanguageInEra lang era
scriptLangInEra Script lang
script' <- ShelleyBasedEra era -> Gen (ScriptInEra era)
forall era. ShelleyBasedEra era -> Gen (ScriptInEra era)
genScriptInEra ShelleyBasedEra era
sbe
  case Script lang
script' of
    SimpleScript SimpleScript
simpleScript -> do
      SimpleScriptOrReferenceInput SimpleScript'
simpleScriptOrReferenceInput <- [GenT Identity (SimpleScriptOrReferenceInput SimpleScript')]
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
        [ SimpleScriptOrReferenceInput SimpleScript'
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SimpleScriptOrReferenceInput SimpleScript'
 -> GenT Identity (SimpleScriptOrReferenceInput SimpleScript'))
-> SimpleScriptOrReferenceInput SimpleScript'
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall a b. (a -> b) -> a -> b
$ SimpleScript -> SimpleScriptOrReferenceInput SimpleScript'
forall lang. SimpleScript -> SimpleScriptOrReferenceInput lang
SScript SimpleScript
simpleScript
        , TxIn -> SimpleScriptOrReferenceInput SimpleScript'
forall lang. TxIn -> SimpleScriptOrReferenceInput lang
SReferenceScript (TxIn -> SimpleScriptOrReferenceInput SimpleScript')
-> Gen TxIn
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn
        ]
      ScriptWitness WitCtxMint era -> Gen (ScriptWitness WitCtxMint era)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ScriptWitness WitCtxMint era
 -> Gen (ScriptWitness WitCtxMint era))
-> ScriptWitness WitCtxMint era
-> Gen (ScriptWitness WitCtxMint era)
forall a b. (a -> b) -> a -> b
$ ScriptLanguageInEra SimpleScript' era
-> SimpleScriptOrReferenceInput SimpleScript'
-> ScriptWitness WitCtxMint era
forall era witctx.
ScriptLanguageInEra SimpleScript' era
-> SimpleScriptOrReferenceInput SimpleScript'
-> ScriptWitness witctx era
Api.SimpleScriptWitness ScriptLanguageInEra lang era
ScriptLanguageInEra SimpleScript' era
scriptLangInEra SimpleScriptOrReferenceInput SimpleScript'
simpleScriptOrReferenceInput
    PlutusScript PlutusScriptVersion lang
plutusScriptVersion' PlutusScript lang
plutusScript -> do
      PlutusScriptOrReferenceInput lang
plutusScriptOrReferenceInput <- [GenT Identity (PlutusScriptOrReferenceInput lang)]
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
        [ PlutusScriptOrReferenceInput lang
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall a. a -> GenT Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PlutusScriptOrReferenceInput lang
 -> GenT Identity (PlutusScriptOrReferenceInput lang))
-> PlutusScriptOrReferenceInput lang
-> GenT Identity (PlutusScriptOrReferenceInput lang)
forall a b. (a -> b) -> a -> b
$ PlutusScript lang -> PlutusScriptOrReferenceInput lang
forall lang. PlutusScript lang -> PlutusScriptOrReferenceInput lang
PScript PlutusScript lang
plutusScript
        , TxIn -> PlutusScriptOrReferenceInput lang
forall lang. TxIn -> PlutusScriptOrReferenceInput lang
PReferenceScript (TxIn -> PlutusScriptOrReferenceInput lang)
-> Gen TxIn -> GenT Identity (PlutusScriptOrReferenceInput lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn
        ]
      HashableScriptData
scriptRedeemer <- Gen HashableScriptData
HasCallStack => Gen HashableScriptData
genHashableScriptData
      ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum WitCtxMint
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness WitCtxMint era
forall lang era witctx.
IsPlutusScriptLanguage lang =>
ScriptLanguageInEra lang era
-> PlutusScriptVersion lang
-> PlutusScriptOrReferenceInput lang
-> ScriptDatum witctx
-> HashableScriptData
-> ExecutionUnits
-> ScriptWitness witctx era
PlutusScriptWitness
        ScriptLanguageInEra lang era
scriptLangInEra
        PlutusScriptVersion lang
plutusScriptVersion'
        PlutusScriptOrReferenceInput lang
plutusScriptOrReferenceInput
        ScriptDatum WitCtxMint
NoScriptDatumForMint
        HashableScriptData
scriptRedeemer
        (ExecutionUnits -> ScriptWitness WitCtxMint era)
-> GenT Identity ExecutionUnits
-> Gen (ScriptWitness WitCtxMint era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenT Identity ExecutionUnits
genExecutionUnits