{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# 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
  , genWitnessesByron
  , genAddressInEra
  , genAddressShelley
  , genCertificate
  , genCostModel
  , genCostModels
  , genMaybePraosNonce
  , genPraosNonce
  , genValidProtocolParameters
  , genProtocolParameters
  , genValueNestedRep
  , genValueNestedBundle
  , genByronKeyWitness
  , genCardanoKeyWitness
  , genShelleyKeyWitness
  , genTxId
  , genTxIn
  , genTxOutTxContext
  , genTxOutUTxOContext
  , genUTxO

    -- * Scripts
  , genHashableScriptData
  , genReferenceScript
  , genScript
  , genSimpleScript
  , genPlutusScript
  , 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
  , 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
  )
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.Eon.AllegraEraOnwards (allegraEraOnwardsToShelleyBasedEra)
import           Cardano.Api.Error
import qualified Cardano.Api.Ledger as L
import qualified Cardano.Api.Ledger.Lens as A
import           Cardano.Api.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           Data.Ratio (Ratio, (%))
import           Data.String
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
--

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.
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

genSimpleScript :: Gen SimpleScript
genSimpleScript :: GenT Identity SimpleScript
genSimpleScript =
  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 Int
0 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 :: PlutusScriptVersion lang -> Gen (PlutusScript lang)
genPlutusScript :: forall lang. PlutusScriptVersion lang -> Gen (PlutusScript lang)
genPlutusScript PlutusScriptVersion lang
_ =
  -- We make no attempt to create a valid script
  ShortByteString -> PlutusScript lang
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised (ShortByteString -> PlutusScript lang)
-> (ByteString -> ShortByteString)
-> ByteString
-> PlutusScript lang
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ShortByteString
SBS.toShort (ByteString -> PlutusScript lang)
-> GenT Identity ByteString -> GenT Identity (PlutusScript lang)
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)

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)
genScript 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
  :: MaryEraOnwards era -> Gen AssetId -> Gen Quantity -> Gen (L.Value (ShelleyLedgerEra era))
genValue :: forall era.
MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
genValue 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))
-> ([(AssetId, Quantity)] -> Value)
-> [(AssetId, Quantity)]
-> Value (ShelleyLedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(AssetId, Quantity)] -> Value
valueFromList
    ([(AssetId, Quantity)] -> Value (ShelleyLedgerEra era))
-> GenT Identity [(AssetId, Quantity)]
-> GenT Identity (Value (ShelleyLedgerEra era))
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)

-- | 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))
genValue MaryEraOnwards era
w Gen AssetId
genAssetId Gen Quantity
genSignedNonZeroQuantity

-- | Generate a 'Value' suitable for minting, i.e. non-ADA asset ID and a
-- positive or negative quantity.
genValueForMinting :: MaryEraOnwards era -> Gen Value
genValueForMinting :: forall era. MaryEraOnwards era -> Gen Value
genValueForMinting MaryEraOnwards era
w =
  ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
fromLedgerValue ShelleyBasedEra era
sbe (Value (ShelleyLedgerEra era) -> Value)
-> GenT Identity (Value (ShelleyLedgerEra era)) -> Gen Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> GenT Identity (Value (ShelleyLedgerEra era))
forall era.
MaryEraOnwards era
-> Gen AssetId
-> Gen Quantity
-> Gen (Value (ShelleyLedgerEra era))
genValue MaryEraOnwards era
w Gen AssetId
genAssetIdNoAda Gen Quantity
genSignedNonZeroQuantity
 where
  sbe :: ShelleyBasedEra era
sbe = MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
maryEraOnwardsToShelleyBasedEra MaryEraOnwards era
w
  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))
genValue 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 (AllegraEraOnwards era -> ShelleyBasedEra era
forall era. AllegraEraOnwards era -> ShelleyBasedEra era
allegraEraOnwardsToShelleyBasedEra 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
-> [Certificate era]
-> BuildTxWith BuildTx [(StakeCredential, Witness WitCtxStake era)]
-> TxCertificates BuildTx era
forall era build.
ShelleyBasedEra era
-> [Certificate era]
-> BuildTxWith build [(StakeCredential, Witness WitCtxStake era)]
-> TxCertificates build era
TxCertificates ShelleyBasedEra era
w [Certificate era]
certs (BuildTxWith BuildTx [(StakeCredential, Witness WitCtxStake era)]
 -> TxCertificates BuildTx era)
-> BuildTxWith BuildTx [(StakeCredential, Witness WitCtxStake era)]
-> TxCertificates BuildTx era
forall a b. (a -> b) -> a -> b
$ [(StakeCredential, Witness WitCtxStake era)]
-> BuildTxWith BuildTx [(StakeCredential, Witness WitCtxStake era)]
forall a. a -> BuildTxWith BuildTx a
BuildTxWith [(StakeCredential, Witness WitCtxStake era)]
forall a. Monoid a => a
mempty)
          -- TODO: Generate certificates
          ]
    )

-- TODO: Add remaining certificates
-- TODO: This should be parameterised on ShelleyBasedEra
genCertificate :: 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
    [ 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
    , 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
    ]

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
    )

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
supported ->
      [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
        -- TODO write a generator for the last parameter of 'TxMintValue' constructor
        , MaryEraOnwards era
-> Value
-> BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
-> TxMintValue BuildTx era
forall era build.
MaryEraOnwards era
-> Value
-> BuildTxWith build (Map PolicyId (ScriptWitness WitCtxMint era))
-> TxMintValue build era
TxMintValue MaryEraOnwards era
supported (Value
 -> BuildTxWith
      BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
 -> TxMintValue BuildTx era)
-> Gen Value
-> GenT
     Identity
     (BuildTxWith BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
      -> TxMintValue BuildTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MaryEraOnwards era -> Gen Value
forall era. MaryEraOnwards era -> Gen Value
genValueForMinting MaryEraOnwards era
supported GenT
  Identity
  (BuildTxWith BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
   -> TxMintValue BuildTx era)
-> GenT
     Identity
     (BuildTxWith BuildTx (Map PolicyId (ScriptWitness WitCtxMint era)))
-> Gen (TxMintValue BuildTx 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 BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
-> GenT
     Identity
     (BuildTxWith BuildTx (Map PolicyId (ScriptWitness WitCtxMint era)))
forall a. a -> GenT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Map PolicyId (ScriptWitness WitCtxMint era)
-> BuildTxWith
     BuildTx (Map PolicyId (ScriptWitness WitCtxMint era))
forall a. a -> BuildTxWith BuildTx a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map PolicyId (ScriptWitness WitCtxMint era)
forall a. Monoid a => a
mempty)
        ]

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 L.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.
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 :: Gen EpochNo
genEpochNo = Word64 -> EpochNo
EpochNo (Word64 -> EpochNo) -> GenT Identity Word64 -> Gen 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
  Natural
protocolParamStakePoolTargetNum <- Gen Natural
genNat
  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 ExecutionUnitPrices
Maybe PraosNonce
Maybe ExecutionUnits
Rational
(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 :: Natural
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 :: Natural
protocolParamTreasuryCut :: Rational
protocolParamTxFeeFixed :: Coin
protocolParamTxFeePerByte :: Coin
protocolParamUTxOCostPerByte :: Maybe Coin
..}

-- | Generate valid protocol parameters which pass validations in Cardano.Api.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 Natural
protocolUpdateStakePoolTargetNum <- Gen Natural -> GenT Identity (Maybe Natural)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen Natural
genNat
  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 ExecutionUnitPrices
Maybe ExecutionUnits
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 Natural
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 Natural
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)
-> Gen 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
<*> Gen 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
TxOutDatumInTx 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
TxOutDatumInTx 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
TxOutDatumInTx 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
10) (ConwayEraOnwards era
-> GenT Identity (ProposalProcedure (ShelleyLedgerEra era))
forall era.
ConwayEraOnwards era
-> Gen (ProposalProcedure (ShelleyLedgerEra era))
genProposal ConwayEraOnwards era
w)
  [ProposalProcedure (ShelleyLedgerEra era)]
proposalsToBeWitnessed <- [ProposalProcedure (ShelleyLedgerEra era)]
-> GenT Identity [ProposalProcedure (ShelleyLedgerEra era)]
forall (m :: * -> *) a. MonadGen m => [a] -> m [a]
Gen.subsequence [ProposalProcedure (ShelleyLedgerEra era)]
proposals
  -- We're generating also some extra proposals, purposely not included in the proposals list, which results
  -- in an invalid state of 'TxProposalProcedures'.
  -- We're doing it for the complete representation of possible values space of TxProposalProcedures.
  -- Proposal procedures code in cardano-api should handle such invalid values just fine.
  [ProposalProcedure (ShelleyLedgerEra era)]
extraProposals <- 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
10) (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
conwayEraOnwardsToShelleyBasedEra ConwayEraOnwards era
w
  [(ProposalProcedure (ShelleyLedgerEra era),
  ScriptWitness WitCtxStake era)]
proposalsWithWitnesses <-
    [ProposalProcedure (ShelleyLedgerEra era)]
-> (ProposalProcedure (ShelleyLedgerEra era)
    -> GenT
         Identity
         (ProposalProcedure (ShelleyLedgerEra era),
          ScriptWitness WitCtxStake era))
-> GenT
     Identity
     [(ProposalProcedure (ShelleyLedgerEra era),
       ScriptWitness WitCtxStake era)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM ([ProposalProcedure (ShelleyLedgerEra era)]
extraProposals [ProposalProcedure (ShelleyLedgerEra era)]
-> [ProposalProcedure (ShelleyLedgerEra era)]
-> [ProposalProcedure (ShelleyLedgerEra era)]
forall a. Semigroup a => a -> a -> a
<> [ProposalProcedure (ShelleyLedgerEra era)]
proposalsToBeWitnessed) ((ProposalProcedure (ShelleyLedgerEra era)
  -> GenT
       Identity
       (ProposalProcedure (ShelleyLedgerEra era),
        ScriptWitness WitCtxStake era))
 -> GenT
      Identity
      [(ProposalProcedure (ShelleyLedgerEra era),
        ScriptWitness WitCtxStake era)])
-> (ProposalProcedure (ShelleyLedgerEra era)
    -> GenT
         Identity
         (ProposalProcedure (ShelleyLedgerEra era),
          ScriptWitness WitCtxStake era))
-> GenT
     Identity
     [(ProposalProcedure (ShelleyLedgerEra era),
       ScriptWitness WitCtxStake era)]
forall a b. (a -> b) -> a -> b
$ \ProposalProcedure (ShelleyLedgerEra era)
proposal ->
      (ProposalProcedure (ShelleyLedgerEra era)
proposal,) (ScriptWitness WitCtxStake era
 -> (ProposalProcedure (ShelleyLedgerEra era),
     ScriptWitness WitCtxStake era))
-> GenT Identity (ScriptWitness WitCtxStake era)
-> GenT
     Identity
     (ProposalProcedure (ShelleyLedgerEra era),
      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
  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
$ OSet (ProposalProcedure (ShelleyLedgerEra era))
-> BuildTxWith
     build
     (Map
        (ProposalProcedure (ShelleyLedgerEra era))
        (ScriptWitness WitCtxStake era))
-> TxProposalProcedures build era
forall era build.
EraPParams (ShelleyLedgerEra era) =>
OSet (ProposalProcedure (ShelleyLedgerEra era))
-> BuildTxWith
     build
     (Map
        (ProposalProcedure (ShelleyLedgerEra era))
        (ScriptWitness WitCtxStake era))
-> TxProposalProcedures build era
TxProposalProcedures ([Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
-> OSet (ProposalProcedure (ShelleyLedgerEra era))
forall l. IsList l => [Item l] -> l
fromList [Item (OSet (ProposalProcedure (ShelleyLedgerEra era)))]
[ProposalProcedure (ShelleyLedgerEra era)]
proposals) (Map
  (ProposalProcedure (ShelleyLedgerEra era))
  (ScriptWitness WitCtxStake era)
-> BuildTxWith
     build
     (Map
        (ProposalProcedure (ShelleyLedgerEra era))
        (ScriptWitness WitCtxStake era))
forall a. a -> BuildTxWith build a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map
   (ProposalProcedure (ShelleyLedgerEra era))
   (ScriptWitness WitCtxStake era)
 -> BuildTxWith
      build
      (Map
         (ProposalProcedure (ShelleyLedgerEra era))
         (ScriptWitness WitCtxStake era)))
-> Map
     (ProposalProcedure (ShelleyLedgerEra era))
     (ScriptWitness WitCtxStake era)
-> BuildTxWith
     build
     (Map
        (ProposalProcedure (ShelleyLedgerEra era))
        (ScriptWitness WitCtxStake era))
forall a b. (a -> b) -> a -> b
$ [Item
   (Map
      (ProposalProcedure (ShelleyLedgerEra era))
      (ScriptWitness WitCtxStake era))]
-> Map
     (ProposalProcedure (ShelleyLedgerEra era))
     (ScriptWitness WitCtxStake era)
forall l. IsList l => [Item l] -> l
fromList [(ProposalProcedure (ShelleyLedgerEra era),
  ScriptWitness WitCtxStake era)]
[Item
   (Map
      (ProposalProcedure (ShelleyLedgerEra era))
      (ScriptWitness WitCtxStake era))]
proposalsWithWitnesses)

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
conwayEraOnwardsToShelleyBasedEra 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
-> Maybe ScriptHash -> SimpleScriptOrReferenceInput SimpleScript'
forall lang.
TxIn -> Maybe ScriptHash -> SimpleScriptOrReferenceInput lang
SReferenceScript (TxIn
 -> Maybe ScriptHash -> SimpleScriptOrReferenceInput SimpleScript')
-> Gen TxIn
-> GenT
     Identity
     (Maybe ScriptHash -> SimpleScriptOrReferenceInput SimpleScript')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn GenT
  Identity
  (Maybe ScriptHash -> SimpleScriptOrReferenceInput SimpleScript')
-> GenT Identity (Maybe ScriptHash)
-> GenT Identity (SimpleScriptOrReferenceInput SimpleScript')
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 ScriptHash -> GenT Identity (Maybe ScriptHash)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen ScriptHash
genScriptHash
        ]
      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 -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
forall lang.
TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang
PReferenceScript (TxIn -> Maybe ScriptHash -> PlutusScriptOrReferenceInput lang)
-> Gen TxIn
-> GenT
     Identity (Maybe ScriptHash -> PlutusScriptOrReferenceInput lang)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TxIn
genTxIn GenT
  Identity (Maybe ScriptHash -> PlutusScriptOrReferenceInput lang)
-> GenT Identity (Maybe ScriptHash)
-> GenT Identity (PlutusScriptOrReferenceInput lang)
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 ScriptHash -> GenT Identity (Maybe ScriptHash)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen ScriptHash
genScriptHash
        ]
      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.
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