{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
-- Due to Delegation usage
{-# OPTIONS_GHC -Wno-orphans -Wno-deprecations #-}

module Test.Cardano.Ledger.Shelley.Arbitrary (
  collectionDatumMaxSize,
  metadataMaxSize,
  genMetadata,
  genMetadata',
  genUtf8StringOfSize,
  RawSeed (..),
  ASC (..),
  StakeProportion (..),
  sizedNativeScriptGens,
) where

import qualified Cardano.Chain.UTxO as Byron
import Cardano.Ledger.BaseTypes
import Cardano.Ledger.Binary (EncCBOR (..))
import Cardano.Ledger.Shelley (ShelleyEra)
import Cardano.Ledger.Shelley.API (
  ApplyTx (..),
  ApplyTxError (..),
  MultiSig,
  ShelleyDelegCert,
  ShelleyTx (ShelleyTx),
  TxBody (ShelleyTxBody),
 )
import Cardano.Ledger.Shelley.BlockBody
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.Genesis
import Cardano.Ledger.Shelley.LedgerState
import Cardano.Ledger.Shelley.PParams
import Cardano.Ledger.Shelley.PoolRank
import Cardano.Ledger.Shelley.RewardUpdate
import Cardano.Ledger.Shelley.Rewards (
  LeaderOnlyReward (..),
  PoolRewardInfo (..),
  StakeShare (..),
 )
import Cardano.Ledger.Shelley.Rules (
  PredicateFailure,
  ShelleyDelegPredFailure,
  ShelleyDelegsPredFailure,
  ShelleyDelplPredFailure,
  ShelleyLedgerPredFailure,
  ShelleyLedgersPredFailure,
  ShelleyPoolPredFailure (..),
  ShelleyPpupPredFailure,
  ShelleyUtxoPredFailure,
  ShelleyUtxowPredFailure,
  VotingPeriod,
 )
import Cardano.Ledger.Shelley.Scripts (
  ShelleyEraScript (..),
  pattern RequireAllOf,
  pattern RequireAnyOf,
  pattern RequireMOf,
  pattern RequireSignature,
 )
import Cardano.Ledger.Shelley.State
import Cardano.Ledger.Shelley.Transition
import Cardano.Ledger.Shelley.Translation (FromByronTranslationContext)
import Cardano.Ledger.Shelley.Tx (Tx (..))
import Cardano.Ledger.Shelley.TxAuxData
import Cardano.Ledger.Shelley.TxCert (
  GenesisDelegCert (..),
  ShelleyTxCert,
 )
import Cardano.Ledger.Shelley.TxOut
import Cardano.Ledger.Shelley.TxWits (ShelleyTxWits (ShelleyTxWits))
import Control.Exception (assert)
import Control.Monad.Identity (Identity)
import qualified Data.ListMap as LM
import qualified Data.Map.Strict as Map (fromList)
import Data.Sequence.Strict (fromList)
import qualified Data.Text as T (pack)
import qualified Data.Text.Foreign as T (lengthWord8)
import Data.Word (Word64)
import Generic.Random (genericArbitraryU)
import Test.Cardano.Base.Bytes (genByteArray)
import Test.Cardano.Chain.UTxO.Gen (genCompactTxOut)
import Test.Cardano.Data.Arbitrary ()
import Test.Cardano.Ledger.Common
import Test.Cardano.Ledger.Core.Arbitrary ()
import Test.Cardano.Ledger.Core.Utils (unsafeBoundRational)
import Test.QuickCheck.Hedgehog (hedgehog)

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.PParams --------------------------------------------------------
------------------------------------------------------------------------------------------

instance Era era => Arbitrary (ShelleyPParams Identity era) where
  arbitrary :: Gen (ShelleyPParams Identity era)
arbitrary = Gen (ShelleyPParams Identity era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyPParams Identity era -> [ShelleyPParams Identity era]
shrink = ShelleyPParams Identity era -> [ShelleyPParams Identity era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Era era => Arbitrary (ShelleyPParams StrictMaybe era) where
  arbitrary :: Gen (ShelleyPParams StrictMaybe era)
arbitrary = Gen (ShelleyPParams StrictMaybe era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyPParams StrictMaybe era -> [ShelleyPParams StrictMaybe era]
shrink = ShelleyPParams StrictMaybe era -> [ShelleyPParams StrictMaybe era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance (Era era, Arbitrary (PParamsUpdate era)) => Arbitrary (ProposedPPUpdates era) where
  arbitrary :: Gen (ProposedPPUpdates era)
arbitrary = Map (KeyHash GenesisRole) (PParamsUpdate era)
-> ProposedPPUpdates era
forall era.
Map (KeyHash GenesisRole) (PParamsUpdate era)
-> ProposedPPUpdates era
ProposedPPUpdates (Map (KeyHash GenesisRole) (PParamsUpdate era)
 -> ProposedPPUpdates era)
-> Gen (Map (KeyHash GenesisRole) (PParamsUpdate era))
-> Gen (ProposedPPUpdates era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Int)
-> Gen (Map (KeyHash GenesisRole) (PParamsUpdate era))
-> Gen (Map (KeyHash GenesisRole) (PParamsUpdate era))
forall a. (Int -> Int) -> Gen a -> Gen a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
15) Gen (Map (KeyHash GenesisRole) (PParamsUpdate era))
forall a. Arbitrary a => Gen a
arbitrary

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.TxOut ----------------------------------------------------------
------------------------------------------------------------------------------------------

instance (EraTxOut era, Arbitrary (Value era)) => Arbitrary (ShelleyTxOut era) where
  arbitrary :: Gen (ShelleyTxOut era)
arbitrary = Addr -> Value era -> ShelleyTxOut era
forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut (Addr -> Value era -> ShelleyTxOut era)
-> Gen Addr -> Gen (Value era -> ShelleyTxOut era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Addr
forall a. Arbitrary a => Gen a
arbitrary Gen (Value era -> ShelleyTxOut era)
-> Gen (Value era) -> Gen (ShelleyTxOut era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Int) -> Gen (Value era) -> Gen (Value era)
forall a. (Int -> Int) -> Gen a -> Gen a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
15) Gen (Value era)
forall a. Arbitrary a => Gen a
arbitrary

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.LedgerState ----------------------------------------------------
------------------------------------------------------------------------------------------

instance
  ( EraTxOut era
  , Arbitrary (TxOut era)
  , Arbitrary (Value era)
  , Arbitrary (PParams era)
  , Arbitrary (StashedAVVMAddresses era)
  , Arbitrary (GovState era)
  , Arbitrary (CertState era)
  , Arbitrary (InstantStake era)
  ) =>
  Arbitrary (NewEpochState era)
  where
  arbitrary :: Gen (NewEpochState era)
arbitrary =
    EpochNo
-> BlocksMade
-> BlocksMade
-> EpochState era
-> StrictMaybe PulsingRewUpdate
-> PoolDistr
-> StashedAVVMAddresses era
-> NewEpochState era
forall era.
EpochNo
-> BlocksMade
-> BlocksMade
-> EpochState era
-> StrictMaybe PulsingRewUpdate
-> PoolDistr
-> StashedAVVMAddresses era
-> NewEpochState era
NewEpochState
      (EpochNo
 -> BlocksMade
 -> BlocksMade
 -> EpochState era
 -> StrictMaybe PulsingRewUpdate
 -> PoolDistr
 -> StashedAVVMAddresses era
 -> NewEpochState era)
-> Gen EpochNo
-> Gen
     (BlocksMade
      -> BlocksMade
      -> EpochState era
      -> StrictMaybe PulsingRewUpdate
      -> PoolDistr
      -> StashedAVVMAddresses era
      -> NewEpochState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen EpochNo
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (BlocksMade
   -> BlocksMade
   -> EpochState era
   -> StrictMaybe PulsingRewUpdate
   -> PoolDistr
   -> StashedAVVMAddresses era
   -> NewEpochState era)
-> Gen BlocksMade
-> Gen
     (BlocksMade
      -> EpochState era
      -> StrictMaybe PulsingRewUpdate
      -> PoolDistr
      -> StashedAVVMAddresses era
      -> NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen BlocksMade
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (BlocksMade
   -> EpochState era
   -> StrictMaybe PulsingRewUpdate
   -> PoolDistr
   -> StashedAVVMAddresses era
   -> NewEpochState era)
-> Gen BlocksMade
-> Gen
     (EpochState era
      -> StrictMaybe PulsingRewUpdate
      -> PoolDistr
      -> StashedAVVMAddresses era
      -> NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen BlocksMade
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (EpochState era
   -> StrictMaybe PulsingRewUpdate
   -> PoolDistr
   -> StashedAVVMAddresses era
   -> NewEpochState era)
-> Gen (EpochState era)
-> Gen
     (StrictMaybe PulsingRewUpdate
      -> PoolDistr -> StashedAVVMAddresses era -> NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (EpochState era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (StrictMaybe PulsingRewUpdate
   -> PoolDistr -> StashedAVVMAddresses era -> NewEpochState era)
-> Gen (StrictMaybe PulsingRewUpdate)
-> Gen (PoolDistr -> StashedAVVMAddresses era -> NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictMaybe PulsingRewUpdate)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (PoolDistr -> StashedAVVMAddresses era -> NewEpochState era)
-> Gen PoolDistr
-> Gen (StashedAVVMAddresses era -> NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen PoolDistr
forall a. Arbitrary a => Gen a
arbitrary
      Gen (StashedAVVMAddresses era -> NewEpochState era)
-> Gen (StashedAVVMAddresses era) -> Gen (NewEpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StashedAVVMAddresses era)
forall a. Arbitrary a => Gen a
arbitrary

instance
  ( EraTxOut era
  , Arbitrary (TxOut era)
  , Arbitrary (GovState era)
  , Arbitrary (CertState era)
  , Arbitrary (InstantStake era)
  ) =>
  Arbitrary (EpochState era)
  where
  arbitrary :: Gen (EpochState era)
arbitrary =
    ChainAccountState
-> LedgerState era -> SnapShots -> NonMyopic -> EpochState era
forall era.
ChainAccountState
-> LedgerState era -> SnapShots -> NonMyopic -> EpochState era
EpochState
      (ChainAccountState
 -> LedgerState era -> SnapShots -> NonMyopic -> EpochState era)
-> Gen ChainAccountState
-> Gen
     (LedgerState era -> SnapShots -> NonMyopic -> EpochState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ChainAccountState
forall a. Arbitrary a => Gen a
arbitrary
      Gen (LedgerState era -> SnapShots -> NonMyopic -> EpochState era)
-> Gen (LedgerState era)
-> Gen (SnapShots -> NonMyopic -> EpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (LedgerState era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (SnapShots -> NonMyopic -> EpochState era)
-> Gen SnapShots -> Gen (NonMyopic -> EpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen SnapShots
forall a. Arbitrary a => Gen a
arbitrary
      Gen (NonMyopic -> EpochState era)
-> Gen NonMyopic -> Gen (EpochState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen NonMyopic
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: EpochState era -> [EpochState era]
shrink = EpochState era -> [EpochState era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance
  ( EraTxOut era
  , Arbitrary (TxOut era)
  , Arbitrary (GovState era)
  , Arbitrary (CertState era)
  , Arbitrary (InstantStake era)
  ) =>
  Arbitrary (LedgerState era)
  where
  arbitrary :: Gen (LedgerState era)
arbitrary =
    UTxOState era -> CertState era -> LedgerState era
forall era. UTxOState era -> CertState era -> LedgerState era
LedgerState
      (UTxOState era -> CertState era -> LedgerState era)
-> Gen (UTxOState era) -> Gen (CertState era -> LedgerState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (UTxOState era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (CertState era -> LedgerState era)
-> Gen (CertState era) -> Gen (LedgerState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (CertState era)
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: LedgerState era -> [LedgerState era]
shrink LedgerState {CertState era
UTxOState era
lsUTxOState :: UTxOState era
lsCertState :: CertState era
lsCertState :: forall era. LedgerState era -> CertState era
lsUTxOState :: forall era. LedgerState era -> UTxOState era
..} =
    -- We drop the first element in the list so the list does not contain the
    -- original LedgerState which would cause `shrink` to loop indefinitely.
    Int -> [LedgerState era] -> [LedgerState era]
forall a. Int -> [a] -> [a]
drop Int
1 ([LedgerState era] -> [LedgerState era])
-> [LedgerState era] -> [LedgerState era]
forall a b. (a -> b) -> a -> b
$
      UTxOState era -> CertState era -> LedgerState era
forall era. UTxOState era -> CertState era -> LedgerState era
LedgerState
        (UTxOState era -> CertState era -> LedgerState era)
-> [UTxOState era] -> [CertState era -> LedgerState era]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (UTxOState era
lsUTxOState UTxOState era -> [UTxOState era] -> [UTxOState era]
forall a. a -> [a] -> [a]
: UTxOState era -> [UTxOState era]
forall a. Arbitrary a => a -> [a]
shrink UTxOState era
lsUTxOState)
        [CertState era -> LedgerState era]
-> [CertState era] -> [LedgerState era]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (CertState era
lsCertState CertState era -> [CertState era] -> [CertState era]
forall a. a -> [a] -> [a]
: CertState era -> [CertState era]
forall a. Arbitrary a => a -> [a]
shrink CertState era
lsCertState)

instance
  ( EraTxOut era
  , Arbitrary (TxOut era)
  , Arbitrary (GovState era)
  , Arbitrary (InstantStake era)
  ) =>
  Arbitrary (UTxOState era)
  where
  arbitrary :: Gen (UTxOState era)
arbitrary =
    UTxO era
-> Coin
-> Coin
-> GovState era
-> InstantStake era
-> Coin
-> UTxOState era
forall era.
UTxO era
-> Coin
-> Coin
-> GovState era
-> InstantStake era
-> Coin
-> UTxOState era
UTxOState
      (UTxO era
 -> Coin
 -> Coin
 -> GovState era
 -> InstantStake era
 -> Coin
 -> UTxOState era)
-> Gen (UTxO era)
-> Gen
     (Coin
      -> Coin
      -> GovState era
      -> InstantStake era
      -> Coin
      -> UTxOState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (UTxO era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> Coin
   -> GovState era
   -> InstantStake era
   -> Coin
   -> UTxOState era)
-> Gen Coin
-> Gen
     (Coin -> GovState era -> InstantStake era -> Coin -> UTxOState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin -> GovState era -> InstantStake era -> Coin -> UTxOState era)
-> Gen Coin
-> Gen (GovState era -> InstantStake era -> Coin -> UTxOState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen (GovState era -> InstantStake era -> Coin -> UTxOState era)
-> Gen (GovState era)
-> Gen (InstantStake era -> Coin -> UTxOState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (GovState era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (InstantStake era -> Coin -> UTxOState era)
-> Gen (InstantStake era) -> Gen (Coin -> UTxOState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (InstantStake era)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (Coin -> UTxOState era) -> Gen Coin -> Gen (UTxOState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary

  -- The 'genericShrink' function returns first the immediate subterms of a
  -- value (in case it is a recursive data-type), and then shrinks the value
  -- itself. Since 'UTxOState' is not a recursive data-type, there are no
  -- subterms, and we can use `recursivelyShrink` directly. This is particularly
  -- important when abstracting away the different fields of the ledger state,
  -- since the generic subterms instances will overlap due to GHC not having
  -- enough context to infer if 'a' and 'b' are the same types (since in this
  -- case this will depend on the definition of 'era').
  --
  -- > instance OVERLAPPING_ GSubtermsIncl (K1 i a) a where
  -- > instance OVERLAPPING_ GSubtermsIncl (K1 i a) b where
  shrink :: UTxOState era -> [UTxOState era]
shrink = UTxOState era -> [UTxOState era]
forall a. (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
recursivelyShrink

instance Arbitrary (ShelleyInstantStake era) where
  arbitrary :: Gen (ShelleyInstantStake era)
arbitrary = Map (Credential Staking) (CompactForm Coin)
-> Map Ptr (CompactForm Coin) -> ShelleyInstantStake era
forall era.
Map (Credential Staking) (CompactForm Coin)
-> Map Ptr (CompactForm Coin) -> ShelleyInstantStake era
ShelleyInstantStake (Map (Credential Staking) (CompactForm Coin)
 -> Map Ptr (CompactForm Coin) -> ShelleyInstantStake era)
-> Gen (Map (Credential Staking) (CompactForm Coin))
-> Gen (Map Ptr (CompactForm Coin) -> ShelleyInstantStake era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map (Credential Staking) (CompactForm Coin))
forall a. Arbitrary a => Gen a
arbitrary Gen (Map Ptr (CompactForm Coin) -> ShelleyInstantStake era)
-> Gen (Map Ptr (CompactForm Coin))
-> Gen (ShelleyInstantStake era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map Ptr (CompactForm Coin))
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: ShelleyInstantStake era -> [ShelleyInstantStake era]
shrink = ShelleyInstantStake era -> [ShelleyInstantStake era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.PoolRank -------------------------------------------------------
------------------------------------------------------------------------------------------

instance Arbitrary Likelihood where
  arbitrary :: Gen Likelihood
arbitrary = StrictSeq LogWeight -> Likelihood
Likelihood (StrictSeq LogWeight -> Likelihood)
-> Gen (StrictSeq LogWeight) -> Gen Likelihood
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (StrictSeq LogWeight)
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary LogWeight where
  arbitrary :: Gen LogWeight
arbitrary = Float -> LogWeight
LogWeight (Float -> LogWeight) -> Gen Float -> Gen LogWeight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Float
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary PerformanceEstimate where
  arbitrary :: Gen PerformanceEstimate
arbitrary = Double -> PerformanceEstimate
PerformanceEstimate (Double -> PerformanceEstimate)
-> Gen Double -> Gen PerformanceEstimate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Double
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary NonMyopic where
  arbitrary :: Gen NonMyopic
arbitrary = VMap VB VB (KeyHash StakePool) Likelihood -> Coin -> NonMyopic
NonMyopic (VMap VB VB (KeyHash StakePool) Likelihood -> Coin -> NonMyopic)
-> Gen (VMap VB VB (KeyHash StakePool) Likelihood)
-> Gen (Coin -> NonMyopic)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (VMap VB VB (KeyHash StakePool) Likelihood)
forall a. Arbitrary a => Gen a
arbitrary Gen (Coin -> NonMyopic) -> Gen Coin -> Gen NonMyopic
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: NonMyopic -> [NonMyopic]
shrink = NonMyopic -> [NonMyopic]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.Rewards --------------------------------------------------------
------------------------------------------------------------------------------------------
deriving newtype instance Arbitrary StakeShare

instance Arbitrary LeaderOnlyReward where
  arbitrary :: Gen LeaderOnlyReward
arbitrary = KeyHash StakePool -> Coin -> LeaderOnlyReward
LeaderOnlyReward (KeyHash StakePool -> Coin -> LeaderOnlyReward)
-> Gen (KeyHash StakePool) -> Gen (Coin -> LeaderOnlyReward)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (KeyHash StakePool)
forall a. Arbitrary a => Gen a
arbitrary Gen (Coin -> LeaderOnlyReward) -> Gen Coin -> Gen LeaderOnlyReward
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: LeaderOnlyReward -> [LeaderOnlyReward]
shrink = LeaderOnlyReward -> [LeaderOnlyReward]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary PoolRewardInfo where
  arbitrary :: Gen PoolRewardInfo
arbitrary =
    StakeShare
-> Coin
-> StakePoolSnapShot
-> Nat
-> LeaderOnlyReward
-> PoolRewardInfo
PoolRewardInfo
      (StakeShare
 -> Coin
 -> StakePoolSnapShot
 -> Nat
 -> LeaderOnlyReward
 -> PoolRewardInfo)
-> Gen StakeShare
-> Gen
     (Coin
      -> StakePoolSnapShot -> Nat -> LeaderOnlyReward -> PoolRewardInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen StakeShare
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> StakePoolSnapShot -> Nat -> LeaderOnlyReward -> PoolRewardInfo)
-> Gen Coin
-> Gen
     (StakePoolSnapShot -> Nat -> LeaderOnlyReward -> PoolRewardInfo)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (StakePoolSnapShot -> Nat -> LeaderOnlyReward -> PoolRewardInfo)
-> Gen StakePoolSnapShot
-> Gen (Nat -> LeaderOnlyReward -> PoolRewardInfo)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen StakePoolSnapShot
forall a. Arbitrary a => Gen a
arbitrary
      Gen (Nat -> LeaderOnlyReward -> PoolRewardInfo)
-> Gen Nat -> Gen (LeaderOnlyReward -> PoolRewardInfo)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Nat
forall a. Arbitrary a => Gen a
arbitrary
      Gen (LeaderOnlyReward -> PoolRewardInfo)
-> Gen LeaderOnlyReward -> Gen PoolRewardInfo
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen LeaderOnlyReward
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: PoolRewardInfo -> [PoolRewardInfo]
shrink = PoolRewardInfo -> [PoolRewardInfo]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.RewardUpdate ---------------------------------------------------
------------------------------------------------------------------------------------------

instance Arbitrary RewardUpdate where
  arbitrary :: Gen RewardUpdate
arbitrary =
    DeltaCoin
-> DeltaCoin
-> Map (Credential Staking) (Set Reward)
-> DeltaCoin
-> NonMyopic
-> RewardUpdate
RewardUpdate
      (DeltaCoin
 -> DeltaCoin
 -> Map (Credential Staking) (Set Reward)
 -> DeltaCoin
 -> NonMyopic
 -> RewardUpdate)
-> Gen DeltaCoin
-> Gen
     (DeltaCoin
      -> Map (Credential Staking) (Set Reward)
      -> DeltaCoin
      -> NonMyopic
      -> RewardUpdate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen DeltaCoin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (DeltaCoin
   -> Map (Credential Staking) (Set Reward)
   -> DeltaCoin
   -> NonMyopic
   -> RewardUpdate)
-> Gen DeltaCoin
-> Gen
     (Map (Credential Staking) (Set Reward)
      -> DeltaCoin -> NonMyopic -> RewardUpdate)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen DeltaCoin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Map (Credential Staking) (Set Reward)
   -> DeltaCoin -> NonMyopic -> RewardUpdate)
-> Gen (Map (Credential Staking) (Set Reward))
-> Gen (DeltaCoin -> NonMyopic -> RewardUpdate)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map (Credential Staking) (Set Reward))
forall a. Arbitrary a => Gen a
arbitrary
      Gen (DeltaCoin -> NonMyopic -> RewardUpdate)
-> Gen DeltaCoin -> Gen (NonMyopic -> RewardUpdate)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen DeltaCoin
forall a. Arbitrary a => Gen a
arbitrary
      Gen (NonMyopic -> RewardUpdate)
-> Gen NonMyopic -> Gen RewardUpdate
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen NonMyopic
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: RewardUpdate -> [RewardUpdate]
shrink = RewardUpdate -> [RewardUpdate]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary RewardAns where
  arbitrary :: Gen RewardAns
arbitrary = Map (Credential Staking) Reward
-> Map (Credential Staking) (Set Reward) -> RewardAns
RewardAns (Map (Credential Staking) Reward
 -> Map (Credential Staking) (Set Reward) -> RewardAns)
-> Gen (Map (Credential Staking) Reward)
-> Gen (Map (Credential Staking) (Set Reward) -> RewardAns)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map (Credential Staking) Reward)
forall a. Arbitrary a => Gen a
arbitrary Gen (Map (Credential Staking) (Set Reward) -> RewardAns)
-> Gen (Map (Credential Staking) (Set Reward)) -> Gen RewardAns
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map (Credential Staking) (Set Reward))
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: RewardAns -> [RewardAns]
shrink = RewardAns -> [RewardAns]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary (RewardPulser ShelleyBase RewardAns) where
  arbitrary :: Gen (RewardPulser ShelleyBase RewardAns)
arbitrary = Int
-> FreeVars
-> VMap VB VB (Credential Staking) StakeWithDelegation
-> RewardAns
-> RewardPulser ShelleyBase RewardAns
forall ans (m :: * -> *).
(ans ~ RewardAns, m ~ ShelleyBase) =>
Int
-> FreeVars
-> VMap VB VB (Credential Staking) StakeWithDelegation
-> ans
-> RewardPulser m ans
RSLP (Int
 -> FreeVars
 -> VMap VB VB (Credential Staking) StakeWithDelegation
 -> RewardAns
 -> RewardPulser ShelleyBase RewardAns)
-> Gen Int
-> Gen
     (FreeVars
      -> VMap VB VB (Credential Staking) StakeWithDelegation
      -> RewardAns
      -> RewardPulser ShelleyBase RewardAns)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Int
forall a. Arbitrary a => Gen a
arbitrary Gen
  (FreeVars
   -> VMap VB VB (Credential Staking) StakeWithDelegation
   -> RewardAns
   -> RewardPulser ShelleyBase RewardAns)
-> Gen FreeVars
-> Gen
     (VMap VB VB (Credential Staking) StakeWithDelegation
      -> RewardAns -> RewardPulser ShelleyBase RewardAns)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen FreeVars
forall a. Arbitrary a => Gen a
arbitrary Gen
  (VMap VB VB (Credential Staking) StakeWithDelegation
   -> RewardAns -> RewardPulser ShelleyBase RewardAns)
-> Gen (VMap VB VB (Credential Staking) StakeWithDelegation)
-> Gen (RewardAns -> RewardPulser ShelleyBase RewardAns)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (VMap VB VB (Credential Staking) StakeWithDelegation)
forall a. Arbitrary a => Gen a
arbitrary Gen (RewardAns -> RewardPulser ShelleyBase RewardAns)
-> Gen RewardAns -> Gen (RewardPulser ShelleyBase RewardAns)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen RewardAns
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary PulsingRewUpdate where
  arbitrary :: Gen PulsingRewUpdate
arbitrary =
    [Gen PulsingRewUpdate] -> Gen PulsingRewUpdate
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ RewardSnapShot
-> RewardPulser ShelleyBase RewardAns -> PulsingRewUpdate
Pulsing (RewardSnapShot
 -> RewardPulser ShelleyBase RewardAns -> PulsingRewUpdate)
-> Gen RewardSnapShot
-> Gen (RewardPulser ShelleyBase RewardAns -> PulsingRewUpdate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen RewardSnapShot
forall a. Arbitrary a => Gen a
arbitrary Gen (RewardPulser ShelleyBase RewardAns -> PulsingRewUpdate)
-> Gen (RewardPulser ShelleyBase RewardAns) -> Gen PulsingRewUpdate
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (RewardPulser ShelleyBase RewardAns)
forall a. Arbitrary a => Gen a
arbitrary
      , RewardUpdate -> PulsingRewUpdate
Complete (RewardUpdate -> PulsingRewUpdate)
-> Gen RewardUpdate -> Gen PulsingRewUpdate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen RewardUpdate
forall a. Arbitrary a => Gen a
arbitrary
      ]
  shrink :: PulsingRewUpdate -> [PulsingRewUpdate]
shrink = PulsingRewUpdate -> [PulsingRewUpdate]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary RewardSnapShot where
  arbitrary :: Gen RewardSnapShot
arbitrary =
    Coin
-> ProtVer
-> NonMyopic
-> Coin
-> Coin
-> Coin
-> VMap VB VB (KeyHash StakePool) Likelihood
-> Map (Credential Staking) (Set Reward)
-> RewardSnapShot
RewardSnapShot
      (Coin
 -> ProtVer
 -> NonMyopic
 -> Coin
 -> Coin
 -> Coin
 -> VMap VB VB (KeyHash StakePool) Likelihood
 -> Map (Credential Staking) (Set Reward)
 -> RewardSnapShot)
-> Gen Coin
-> Gen
     (ProtVer
      -> NonMyopic
      -> Coin
      -> Coin
      -> Coin
      -> VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward)
      -> RewardSnapShot)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (ProtVer
   -> NonMyopic
   -> Coin
   -> Coin
   -> Coin
   -> VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward)
   -> RewardSnapShot)
-> Gen ProtVer
-> Gen
     (NonMyopic
      -> Coin
      -> Coin
      -> Coin
      -> VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward)
      -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ProtVer
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (NonMyopic
   -> Coin
   -> Coin
   -> Coin
   -> VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward)
   -> RewardSnapShot)
-> Gen NonMyopic
-> Gen
     (Coin
      -> Coin
      -> Coin
      -> VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward)
      -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen NonMyopic
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> Coin
   -> Coin
   -> VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward)
   -> RewardSnapShot)
-> Gen Coin
-> Gen
     (Coin
      -> Coin
      -> VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward)
      -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> Coin
   -> VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward)
   -> RewardSnapShot)
-> Gen Coin
-> Gen
     (Coin
      -> VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward)
      -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward)
   -> RewardSnapShot)
-> Gen Coin
-> Gen
     (VMap VB VB (KeyHash StakePool) Likelihood
      -> Map (Credential Staking) (Set Reward) -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (VMap VB VB (KeyHash StakePool) Likelihood
   -> Map (Credential Staking) (Set Reward) -> RewardSnapShot)
-> Gen (VMap VB VB (KeyHash StakePool) Likelihood)
-> Gen (Map (Credential Staking) (Set Reward) -> RewardSnapShot)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (VMap VB VB (KeyHash StakePool) Likelihood)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (Map (Credential Staking) (Set Reward) -> RewardSnapShot)
-> Gen (Map (Credential Staking) (Set Reward))
-> Gen RewardSnapShot
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map (Credential Staking) (Set Reward))
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: RewardSnapShot -> [RewardSnapShot]
shrink = RewardSnapShot -> [RewardSnapShot]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary FreeVars where
  arbitrary :: Gen FreeVars
arbitrary =
    Set (Credential Staking)
-> Coin
-> ProtVer
-> VMap VB VB (KeyHash StakePool) PoolRewardInfo
-> FreeVars
FreeVars
      (Set (Credential Staking)
 -> Coin
 -> ProtVer
 -> VMap VB VB (KeyHash StakePool) PoolRewardInfo
 -> FreeVars)
-> Gen (Set (Credential Staking))
-> Gen
     (Coin
      -> ProtVer
      -> VMap VB VB (KeyHash StakePool) PoolRewardInfo
      -> FreeVars)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Set (Credential Staking))
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> ProtVer
   -> VMap VB VB (KeyHash StakePool) PoolRewardInfo
   -> FreeVars)
-> Gen Coin
-> Gen
     (ProtVer
      -> VMap VB VB (KeyHash StakePool) PoolRewardInfo -> FreeVars)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (ProtVer
   -> VMap VB VB (KeyHash StakePool) PoolRewardInfo -> FreeVars)
-> Gen ProtVer
-> Gen (VMap VB VB (KeyHash StakePool) PoolRewardInfo -> FreeVars)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen ProtVer
forall a. Arbitrary a => Gen a
arbitrary
      Gen (VMap VB VB (KeyHash StakePool) PoolRewardInfo -> FreeVars)
-> Gen (VMap VB VB (KeyHash StakePool) PoolRewardInfo)
-> Gen FreeVars
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (VMap VB VB (KeyHash StakePool) PoolRewardInfo)
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: FreeVars -> [FreeVars]
shrink = FreeVars -> [FreeVars]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.Governance -----------------------------------------------------
------------------------------------------------------------------------------------------

instance Arbitrary (PParams era) => Arbitrary (FuturePParams era) where
  arbitrary :: Gen (FuturePParams era)
arbitrary = (Int -> Int) -> Gen (FuturePParams era) -> Gen (FuturePParams era)
forall a. (Int -> Int) -> Gen a -> Gen a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
10) Gen (FuturePParams era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU

instance
  ( Era era
  , Arbitrary (PParamsUpdate era)
  , Arbitrary (PParams era)
  ) =>
  Arbitrary (ShelleyGovState era)
  where
  arbitrary :: Gen (ShelleyGovState era)
arbitrary = ProposedPPUpdates era
-> ProposedPPUpdates era
-> PParams era
-> PParams era
-> FuturePParams era
-> ShelleyGovState era
forall era.
ProposedPPUpdates era
-> ProposedPPUpdates era
-> PParams era
-> PParams era
-> FuturePParams era
-> ShelleyGovState era
ShelleyGovState (ProposedPPUpdates era
 -> ProposedPPUpdates era
 -> PParams era
 -> PParams era
 -> FuturePParams era
 -> ShelleyGovState era)
-> Gen (ProposedPPUpdates era)
-> Gen
     (ProposedPPUpdates era
      -> PParams era
      -> PParams era
      -> FuturePParams era
      -> ShelleyGovState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ProposedPPUpdates era)
forall a. Arbitrary a => Gen a
arbitrary Gen
  (ProposedPPUpdates era
   -> PParams era
   -> PParams era
   -> FuturePParams era
   -> ShelleyGovState era)
-> Gen (ProposedPPUpdates era)
-> Gen
     (PParams era
      -> PParams era -> FuturePParams era -> ShelleyGovState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (ProposedPPUpdates era)
forall a. Arbitrary a => Gen a
arbitrary Gen
  (PParams era
   -> PParams era -> FuturePParams era -> ShelleyGovState era)
-> Gen (PParams era)
-> Gen (PParams era -> FuturePParams era -> ShelleyGovState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (PParams era)
forall a. Arbitrary a => Gen a
arbitrary Gen (PParams era -> FuturePParams era -> ShelleyGovState era)
-> Gen (PParams era)
-> Gen (FuturePParams era -> ShelleyGovState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (PParams era)
forall a. Arbitrary a => Gen a
arbitrary Gen (FuturePParams era -> ShelleyGovState era)
-> Gen (FuturePParams era) -> Gen (ShelleyGovState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (FuturePParams era)
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: ShelleyGovState era -> [ShelleyGovState era]
shrink = ShelleyGovState era -> [ShelleyGovState era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

------------------------------------------------------------------------------------------
-- Cardano.Ledger.Shelley.TxAuxData ------------------------------------------------------
------------------------------------------------------------------------------------------

-- | Max size of generated Metadatum List and Map
collectionDatumMaxSize :: Int
collectionDatumMaxSize :: Int
collectionDatumMaxSize = Int
5

-- | Max size of generated Metadata map
metadataMaxSize :: Int
metadataMaxSize :: Int
metadataMaxSize = Int
3

-- | Generate ShelleyTxAuxData (and compute hash) with given frequency
genMetadata :: Era era => Int -> Gen (StrictMaybe (ShelleyTxAuxData era))
genMetadata :: forall era.
Era era =>
Int -> Gen (StrictMaybe (ShelleyTxAuxData era))
genMetadata Int
metadataFrequency =
  [(Int, Gen (StrictMaybe (ShelleyTxAuxData era)))]
-> Gen (StrictMaybe (ShelleyTxAuxData era))
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
    [ (Int
metadataFrequency, ShelleyTxAuxData era -> StrictMaybe (ShelleyTxAuxData era)
forall a. a -> StrictMaybe a
SJust (ShelleyTxAuxData era -> StrictMaybe (ShelleyTxAuxData era))
-> Gen (ShelleyTxAuxData era)
-> Gen (StrictMaybe (ShelleyTxAuxData era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ShelleyTxAuxData era)
forall era. Era era => Gen (ShelleyTxAuxData era)
genMetadata')
    , (Int
100 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
metadataFrequency, StrictMaybe (ShelleyTxAuxData era)
-> Gen (StrictMaybe (ShelleyTxAuxData era))
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StrictMaybe (ShelleyTxAuxData era)
forall a. StrictMaybe a
SNothing)
    ]

-- | Generate Metadata (and compute hash) of size up to 'metadataMaxSize'
genMetadata' :: Era era => Gen (ShelleyTxAuxData era)
genMetadata' :: forall era. Era era => Gen (ShelleyTxAuxData era)
genMetadata' = do
  n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int
metadataMaxSize)
  ShelleyTxAuxData . Map.fromList
    <$> vectorOf n genMetadatum

-- | Generate one of the Metadatum
genMetadatum :: Gen (Word64, Metadatum)
genMetadatum :: Gen (Word64, Metadatum)
genMetadatum = do
  (,)
    (Word64 -> Metadatum -> (Word64, Metadatum))
-> Gen Word64 -> Gen (Metadatum -> (Word64, Metadatum))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word64
forall a. Arbitrary a => Gen a
arbitrary
    Gen (Metadatum -> (Word64, Metadatum))
-> Gen Metadatum -> Gen (Word64, Metadatum)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Gen Metadatum] -> Gen Metadatum
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ Gen Metadatum
genDatumInt
      , Gen Metadatum
genDatumString
      , Gen Metadatum
genDatumBytestring
      , Gen Metadatum
genMetadatumList
      , Gen Metadatum
genMetadatumMap
      ]

genDatumInt :: Gen Metadatum
genDatumInt :: Gen Metadatum
genDatumInt =
  Integer -> Metadatum
I
    (Integer -> Metadatum) -> Gen Integer -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, Gen Integer)] -> Gen Integer
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency
      [ (Int
8, (Integer, Integer) -> Gen Integer
forall a. Random a => (a, a) -> Gen a
choose (Integer
minVal, Integer
maxVal))
      , (Int
1, Integer -> Gen Integer
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
minVal)
      , (Int
1, Integer -> Gen Integer
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
maxVal)
      ]
  where
    minVal, maxVal :: Integer
    minVal :: Integer
minVal = -Integer
maxVal
    maxVal :: Integer
maxVal = Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
forall a. Bounded a => a
maxBound :: Word64)

genDatumString :: Gen Metadatum
genDatumString :: Gen Metadatum
genDatumString =
  (Int -> Gen Metadatum) -> Gen Metadatum
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Metadatum) -> Gen Metadatum)
-> (Int -> Gen Metadatum) -> Gen Metadatum
forall a b. (a -> b) -> a -> b
$ \Int
sz -> do
    n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0, Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
sz Int
64)
    cs <- genUtf8StringOfSize n
    let s = String -> Text
T.pack String
cs
    assert (T.lengthWord8 s == n) $
      return (S s)

-- | Produce an arbitrary Unicode string such that it's UTF8 encoding size in
-- bytes is exactly the given length.
genUtf8StringOfSize :: Int -> Gen [Char]
genUtf8StringOfSize :: Int -> Gen String
genUtf8StringOfSize Int
0 = String -> Gen String
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return []
genUtf8StringOfSize Int
n = do
  cz <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
n Int
4)
  c <- case cz of
    Int
1 -> (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
'\x00000', Char
'\x00007f')
    Int
2 -> (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
'\x00080', Char
'\x0007ff')
    Int
3 ->
      [Gen Char] -> Gen Char
forall a. HasCallStack => [Gen a] -> Gen a
oneof
        [ (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
'\x00800', Char
'\x00d7ff')
        , -- skipping UTF-16 surrogates d800--dfff
          (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
'\x0e000', Char
'\x00ffff')
        ]
    Int
_ -> (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
'\x10000', Char
'\x10ffff')
  cs <- genUtf8StringOfSize (n - cz)
  return (c : cs)

genDatumBytestring :: Gen Metadatum
genDatumBytestring :: Gen Metadatum
genDatumBytestring =
  (Int -> Gen Metadatum) -> Gen Metadatum
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Metadatum) -> Gen Metadatum)
-> (Int -> Gen Metadatum) -> Gen Metadatum
forall a b. (a -> b) -> a -> b
$ \Int
sz -> do
    n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0, Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
sz Int
64)
    B <$> genByteArray n

-- | Generate a 'MD.List [Metadatum]'
--
-- Note: to limit generated metadata size, impact on transaction fees and
-- cost of hashing, we generate only lists of "simple" Datums, not lists
-- of list or map Datum.
genMetadatumList :: Gen Metadatum
genMetadatumList :: Gen Metadatum
genMetadatumList = [Metadatum] -> Metadatum
List ([Metadatum] -> Metadatum) -> Gen [Metadatum] -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Metadatum]
vectorOfMetadatumSimple

-- | Generate a 'MD.Map ('[(Metadatum, Metadatum)]')
genMetadatumMap :: Gen Metadatum
genMetadatumMap :: Gen Metadatum
genMetadatumMap =
  [(Metadatum, Metadatum)] -> Metadatum
Map ([(Metadatum, Metadatum)] -> Metadatum)
-> Gen [(Metadatum, Metadatum)] -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Metadatum] -> [Metadatum] -> [(Metadatum, Metadatum)]
forall a b. [a] -> [b] -> [(a, b)]
zip ([Metadatum] -> [Metadatum] -> [(Metadatum, Metadatum)])
-> Gen [Metadatum] -> Gen ([Metadatum] -> [(Metadatum, Metadatum)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Metadatum]
vectorOfMetadatumSimple Gen ([Metadatum] -> [(Metadatum, Metadatum)])
-> Gen [Metadatum] -> Gen [(Metadatum, Metadatum)]
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen [Metadatum]
vectorOfMetadatumSimple)

vectorOfMetadatumSimple :: Gen [Metadatum]
vectorOfMetadatumSimple :: Gen [Metadatum]
vectorOfMetadatumSimple = do
  n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1, Int
collectionDatumMaxSize)
  vectorOf
    n
    ( oneof
        [ genDatumInt
        , genDatumString
        , genDatumBytestring
        ]
    )

------------------------------------------------------------------------------------------
-- Era-independent generators ------------------------------------------------------------
------------------------------------------------------------------------------------------

instance Era era => Arbitrary (ShelleyTxCert era) where
  arbitrary :: Gen (ShelleyTxCert era)
arbitrary = Gen (ShelleyTxCert era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyTxCert era -> [ShelleyTxCert era]
shrink = ShelleyTxCert era -> [ShelleyTxCert era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary ShelleyDelegCert where
  arbitrary :: Gen ShelleyDelegCert
arbitrary = Gen ShelleyDelegCert
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyDelegCert -> [ShelleyDelegCert]
shrink = ShelleyDelegCert -> [ShelleyDelegCert]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary GenesisDelegCert where
  arbitrary :: Gen GenesisDelegCert
arbitrary = Gen GenesisDelegCert
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: GenesisDelegCert -> [GenesisDelegCert]
shrink = GenesisDelegCert -> [GenesisDelegCert]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary MIRCert where
  arbitrary :: Gen MIRCert
arbitrary = Gen MIRCert
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: MIRCert -> [MIRCert]
shrink = MIRCert -> [MIRCert]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary MIRTarget where
  arbitrary :: Gen MIRTarget
arbitrary =
    [Gen MIRTarget] -> Gen MIRTarget
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ Map (Credential Staking) DeltaCoin -> MIRTarget
StakeAddressesMIR (Map (Credential Staking) DeltaCoin -> MIRTarget)
-> Gen (Map (Credential Staking) DeltaCoin) -> Gen MIRTarget
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map (Credential Staking) DeltaCoin)
forall a. Arbitrary a => Gen a
arbitrary
      , Coin -> MIRTarget
SendToOppositePotMIR (Coin -> MIRTarget) -> Gen Coin -> Gen MIRTarget
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      ]

instance Arbitrary MIRPot where
  arbitrary :: Gen MIRPot
arbitrary = Gen MIRPot
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU

instance (Era era, Arbitrary (PParamsUpdate era)) => Arbitrary (Update era) where
  arbitrary :: Gen (Update era)
arbitrary = Gen (Update era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: Update era -> [Update era]
shrink = Update era -> [Update era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary Byron.CompactTxOut where
  arbitrary :: Gen CompactTxOut
arbitrary = Gen CompactTxOut -> Gen CompactTxOut
forall a. Gen a -> Gen a
hedgehog Gen CompactTxOut
genCompactTxOut

instance Arbitrary ASC where
  arbitrary :: Gen ASC
arbitrary =
    ActiveSlotCoeff -> ASC
ASC
      (ActiveSlotCoeff -> ASC)
-> (Double -> ActiveSlotCoeff) -> Double -> ASC
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PositiveUnitInterval -> ActiveSlotCoeff
mkActiveSlotCoeff
      (PositiveUnitInterval -> ActiveSlotCoeff)
-> (Double -> PositiveUnitInterval) -> Double -> ActiveSlotCoeff
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> PositiveUnitInterval
forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational
      (Rational -> PositiveUnitInterval)
-> (Double -> Rational) -> Double -> PositiveUnitInterval
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. Fractional a => Rational -> a
fromRational
      (Rational -> Rational)
-> (Double -> Rational) -> Double -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational
      (Double -> ASC) -> Gen Double -> Gen ASC
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose @Double (Double
0.01, Double
0.5)

newtype ASC = ASC ActiveSlotCoeff
  deriving (Int -> ASC -> String -> String
[ASC] -> String -> String
ASC -> String
(Int -> ASC -> String -> String)
-> (ASC -> String) -> ([ASC] -> String -> String) -> Show ASC
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ASC -> String -> String
showsPrec :: Int -> ASC -> String -> String
$cshow :: ASC -> String
show :: ASC -> String
$cshowList :: [ASC] -> String -> String
showList :: [ASC] -> String -> String
Show)

instance Arbitrary StakeProportion where
  arbitrary :: Gen StakeProportion
arbitrary = Rational -> StakeProportion
StakeProportion (Rational -> StakeProportion)
-> (Double -> Rational) -> Double -> StakeProportion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational (Double -> StakeProportion) -> Gen Double -> Gen StakeProportion
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose @Double (Double
0, Double
1)
  shrink :: StakeProportion -> [StakeProportion]
shrink (StakeProportion Rational
r) = Rational -> StakeProportion
StakeProportion (Rational -> StakeProportion) -> [Rational] -> [StakeProportion]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Rational -> [Rational]
forall a. RealFrac a => a -> [a]
shrinkRealFrac Rational
r

newtype StakeProportion = StakeProportion Rational
  deriving (Int -> StakeProportion -> String -> String
[StakeProportion] -> String -> String
StakeProportion -> String
(Int -> StakeProportion -> String -> String)
-> (StakeProportion -> String)
-> ([StakeProportion] -> String -> String)
-> Show StakeProportion
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StakeProportion -> String -> String
showsPrec :: Int -> StakeProportion -> String -> String
$cshow :: StakeProportion -> String
show :: StakeProportion -> String
$cshowList :: [StakeProportion] -> String -> String
showList :: [StakeProportion] -> String -> String
Show)

instance Arbitrary (TxBody TopTx ShelleyEra) where
  arbitrary :: Gen (TxBody TopTx ShelleyEra)
arbitrary =
    Set TxIn
-> StrictSeq (TxOut ShelleyEra)
-> StrictSeq (TxCert ShelleyEra)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update ShelleyEra)
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx ShelleyEra
Set TxIn
-> StrictSeq (ShelleyTxOut ShelleyEra)
-> StrictSeq (ShelleyTxCert ShelleyEra)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update ShelleyEra)
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx ShelleyEra
ShelleyTxBody
      (Set TxIn
 -> StrictSeq (ShelleyTxOut ShelleyEra)
 -> StrictSeq (ShelleyTxCert ShelleyEra)
 -> Withdrawals
 -> Coin
 -> SlotNo
 -> StrictMaybe (Update ShelleyEra)
 -> StrictMaybe TxAuxDataHash
 -> TxBody TopTx ShelleyEra)
-> Gen (Set TxIn)
-> Gen
     (StrictSeq (ShelleyTxOut ShelleyEra)
      -> StrictSeq (ShelleyTxCert ShelleyEra)
      -> Withdrawals
      -> Coin
      -> SlotNo
      -> StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash
      -> TxBody TopTx ShelleyEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Set TxIn)
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (StrictSeq (ShelleyTxOut ShelleyEra)
   -> StrictSeq (ShelleyTxCert ShelleyEra)
   -> Withdrawals
   -> Coin
   -> SlotNo
   -> StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash
   -> TxBody TopTx ShelleyEra)
-> Gen (StrictSeq (ShelleyTxOut ShelleyEra))
-> Gen
     (StrictSeq (ShelleyTxCert ShelleyEra)
      -> Withdrawals
      -> Coin
      -> SlotNo
      -> StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash
      -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictSeq (ShelleyTxOut ShelleyEra))
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (StrictSeq (ShelleyTxCert ShelleyEra)
   -> Withdrawals
   -> Coin
   -> SlotNo
   -> StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash
   -> TxBody TopTx ShelleyEra)
-> Gen (StrictSeq (ShelleyTxCert ShelleyEra))
-> Gen
     (Withdrawals
      -> Coin
      -> SlotNo
      -> StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash
      -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictSeq (ShelleyTxCert ShelleyEra))
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Withdrawals
   -> Coin
   -> SlotNo
   -> StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash
   -> TxBody TopTx ShelleyEra)
-> Gen Withdrawals
-> Gen
     (Coin
      -> SlotNo
      -> StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash
      -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Withdrawals
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Coin
   -> SlotNo
   -> StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash
   -> TxBody TopTx ShelleyEra)
-> Gen Coin
-> Gen
     (SlotNo
      -> StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash
      -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Coin
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (SlotNo
   -> StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash
   -> TxBody TopTx ShelleyEra)
-> Gen SlotNo
-> Gen
     (StrictMaybe (Update ShelleyEra)
      -> StrictMaybe TxAuxDataHash -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen SlotNo
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (StrictMaybe (Update ShelleyEra)
   -> StrictMaybe TxAuxDataHash -> TxBody TopTx ShelleyEra)
-> Gen (StrictMaybe (Update ShelleyEra))
-> Gen (StrictMaybe TxAuxDataHash -> TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Int)
-> Gen (StrictMaybe (Update ShelleyEra))
-> Gen (StrictMaybe (Update ShelleyEra))
forall a. (Int -> Int) -> Gen a -> Gen a
scale (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
15) Gen (StrictMaybe (Update ShelleyEra))
forall a. Arbitrary a => Gen a
arbitrary
      Gen (StrictMaybe TxAuxDataHash -> TxBody TopTx ShelleyEra)
-> Gen (StrictMaybe TxAuxDataHash) -> Gen (TxBody TopTx ShelleyEra)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictMaybe TxAuxDataHash)
forall a. Arbitrary a => Gen a
arbitrary

genTx ::
  ( Arbitrary (TxBody TopTx era)
  , Arbitrary (TxAuxData era)
  , Arbitrary (TxWits era)
  ) =>
  Gen (ShelleyTx TopTx era)
genTx :: forall era.
(Arbitrary (TxBody TopTx era), Arbitrary (TxAuxData era),
 Arbitrary (TxWits era)) =>
Gen (ShelleyTx TopTx era)
genTx =
  TxBody TopTx era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era
forall era.
TxBody TopTx era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era
ShelleyTx
    (TxBody TopTx era
 -> TxWits era
 -> StrictMaybe (TxAuxData era)
 -> ShelleyTx TopTx era)
-> Gen (TxBody TopTx era)
-> Gen
     (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (TxBody TopTx era)
forall a. Arbitrary a => Gen a
arbitrary
    Gen
  (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era)
-> Gen (TxWits era)
-> Gen (StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen (TxWits era) -> Gen (TxWits era)
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxTxWits Gen (TxWits era)
forall a. Arbitrary a => Gen a
arbitrary
    Gen (StrictMaybe (TxAuxData era) -> ShelleyTx TopTx era)
-> Gen (StrictMaybe (TxAuxData era)) -> Gen (ShelleyTx TopTx era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictMaybe (TxAuxData era))
forall a. Arbitrary a => Gen a
arbitrary

maxTxWits :: Int
maxTxWits :: Int
maxTxWits = Int
5

instance Arbitrary Metadatum where
  arbitrary :: Gen Metadatum
arbitrary = Int -> Gen Metadatum
sizedMetadatum Int
maxMetadatumDepth

instance Era era => Arbitrary (ShelleyTxAuxData era) where
  arbitrary :: Gen (ShelleyTxAuxData era)
arbitrary = Map Word64 Metadatum -> ShelleyTxAuxData era
forall era. Era era => Map Word64 Metadatum -> ShelleyTxAuxData era
ShelleyTxAuxData (Map Word64 Metadatum -> ShelleyTxAuxData era)
-> Gen (Map Word64 Metadatum) -> Gen (ShelleyTxAuxData era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map Word64 Metadatum)
forall a. Arbitrary a => Gen a
arbitrary

deriving newtype instance Arbitrary NominalDiffTimeMicro

maxMetadatumDepth :: Int
maxMetadatumDepth :: Int
maxMetadatumDepth = Int
2

maxMetadatumListLens :: Int
maxMetadatumListLens :: Int
maxMetadatumListLens = Int
5

sizedMetadatum :: Int -> Gen Metadatum
sizedMetadatum :: Int -> Gen Metadatum
sizedMetadatum Int
0 =
  [Gen Metadatum] -> Gen Metadatum
forall a. HasCallStack => [Gen a] -> Gen a
oneof
    [ Integer -> Metadatum
I (Integer -> Metadatum) -> Gen Integer -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
forall a. Arbitrary a => Gen a
arbitrary
    , ByteArray -> Metadatum
B (ByteArray -> Metadatum) -> Gen ByteArray -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteArray
forall a. Arbitrary a => Gen a
arbitrary
    , Text -> Metadatum
S (Text -> Metadatum) -> (String -> Text) -> String -> Metadatum
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Metadatum) -> Gen String -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
forall a. Arbitrary a => Gen a
arbitrary
    ]
sizedMetadatum Int
n =
  let xsGen :: Gen [Metadatum]
xsGen = Gen Metadatum -> Gen [Metadatum]
forall a. Gen a -> Gen [a]
listOf (Int -> Gen Metadatum
sizedMetadatum (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))
   in [Gen Metadatum] -> Gen Metadatum
forall a. HasCallStack => [Gen a] -> Gen a
oneof
        [ [(Metadatum, Metadatum)] -> Metadatum
Map ([(Metadatum, Metadatum)] -> Metadatum)
-> Gen [(Metadatum, Metadatum)] -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Metadatum] -> [Metadatum] -> [(Metadatum, Metadatum)]
forall a b. [a] -> [b] -> [(a, b)]
zip ([Metadatum] -> [Metadatum] -> [(Metadatum, Metadatum)])
-> Gen [Metadatum] -> Gen ([Metadatum] -> [(Metadatum, Metadatum)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen [Metadatum] -> Gen [Metadatum]
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxMetadatumListLens Gen [Metadatum]
xsGen Gen ([Metadatum] -> [(Metadatum, Metadatum)])
-> Gen [Metadatum] -> Gen [(Metadatum, Metadatum)]
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen [Metadatum]
xsGen)
        , [Metadatum] -> Metadatum
List ([Metadatum] -> Metadatum) -> Gen [Metadatum] -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen [Metadatum] -> Gen [Metadatum]
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxMetadatumListLens Gen [Metadatum]
xsGen
        , Integer -> Metadatum
I (Integer -> Metadatum) -> Gen Integer -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
forall a. Arbitrary a => Gen a
arbitrary
        , ByteArray -> Metadatum
B (ByteArray -> Metadatum) -> Gen ByteArray -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteArray
forall a. Arbitrary a => Gen a
arbitrary
        , Text -> Metadatum
S (Text -> Metadatum) -> (String -> Text) -> String -> Metadatum
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Metadatum) -> Gen String -> Gen Metadatum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
forall a. Arbitrary a => Gen a
arbitrary
        ]

instance Arbitrary VotingPeriod where
  arbitrary :: Gen VotingPeriod
arbitrary = Gen VotingPeriod
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: VotingPeriod -> [VotingPeriod]
shrink = VotingPeriod -> [VotingPeriod]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance (Arbitrary k, Arbitrary v) => Arbitrary (LM.ListMap k v) where
  arbitrary :: Gen (ListMap k v)
arbitrary = Gen (ListMap k v)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ListMap k v -> [ListMap k v]
shrink = ListMap k v -> [ListMap k v]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance
  ( ShelleyEraScript era
  , NativeScript era ~ MultiSig era
  ) =>
  Arbitrary (MultiSig era)
  where
  arbitrary :: Gen (MultiSig era)
arbitrary = Int -> Gen (NativeScript era)
forall era. ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig Int
maxMultiSigDepth

maxMultiSigDepth :: Int
maxMultiSigDepth :: Int
maxMultiSigDepth = Int
3

maxMultiSigListLens :: Int
maxMultiSigListLens :: Int
maxMultiSigListLens = Int
4

sizedMultiSig :: ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig :: forall era. ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig Int
0 = KeyHash Witness -> NativeScript era
forall era.
ShelleyEraScript era =>
KeyHash Witness -> NativeScript era
RequireSignature (KeyHash Witness -> NativeScript era)
-> Gen (KeyHash Witness) -> Gen (NativeScript era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (KeyHash Witness)
forall a. Arbitrary a => Gen a
arbitrary
sizedMultiSig Int
n = [Gen (NativeScript era)] -> Gen (NativeScript era)
forall a. HasCallStack => [Gen a] -> Gen a
oneof ([Gen (NativeScript era)] -> Gen (NativeScript era))
-> [Gen (NativeScript era)] -> Gen (NativeScript era)
forall a b. (a -> b) -> a -> b
$ Int -> [Gen (NativeScript era)]
forall era. ShelleyEraScript era => Int -> [Gen (NativeScript era)]
sizedNativeScriptGens Int
n

sizedNativeScriptGens :: ShelleyEraScript era => Int -> [Gen (NativeScript era)]
sizedNativeScriptGens :: forall era. ShelleyEraScript era => Int -> [Gen (NativeScript era)]
sizedNativeScriptGens Int
n =
  [ KeyHash Witness -> NativeScript era
forall era.
ShelleyEraScript era =>
KeyHash Witness -> NativeScript era
RequireSignature (KeyHash Witness -> NativeScript era)
-> Gen (KeyHash Witness) -> Gen (NativeScript era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (KeyHash Witness)
forall a. Arbitrary a => Gen a
arbitrary
  , StrictSeq (NativeScript era) -> NativeScript era
forall era.
ShelleyEraScript era =>
StrictSeq (NativeScript era) -> NativeScript era
RequireAllOf (StrictSeq (NativeScript era) -> NativeScript era)
-> Gen (StrictSeq (NativeScript era)) -> Gen (NativeScript era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([NativeScript era] -> StrictSeq (NativeScript era)
forall a. [a] -> StrictSeq a
fromList ([NativeScript era] -> StrictSeq (NativeScript era))
-> Gen [NativeScript era] -> Gen (StrictSeq (NativeScript era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen [NativeScript era] -> Gen [NativeScript era]
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxMultiSigListLens (Gen (NativeScript era) -> Gen [NativeScript era]
forall a. Gen a -> Gen [a]
listOf (Int -> Gen (NativeScript era)
forall era. ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))))
  , StrictSeq (NativeScript era) -> NativeScript era
forall era.
ShelleyEraScript era =>
StrictSeq (NativeScript era) -> NativeScript era
RequireAnyOf (StrictSeq (NativeScript era) -> NativeScript era)
-> Gen (StrictSeq (NativeScript era)) -> Gen (NativeScript era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([NativeScript era] -> StrictSeq (NativeScript era)
forall a. [a] -> StrictSeq a
fromList ([NativeScript era] -> StrictSeq (NativeScript era))
-> Gen [NativeScript era] -> Gen (StrictSeq (NativeScript era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen [NativeScript era] -> Gen [NativeScript era]
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxMultiSigListLens (Gen (NativeScript era) -> Gen [NativeScript era]
forall a. Gen a -> Gen [a]
listOf (Int -> Gen (NativeScript era)
forall era. ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))))
  , do
      subs <- Int -> Gen [NativeScript era] -> Gen [NativeScript era]
forall a. HasCallStack => Int -> Gen a -> Gen a
resize Int
maxMultiSigListLens (Gen (NativeScript era) -> Gen [NativeScript era]
forall a. Gen a -> Gen [a]
listOf (Int -> Gen (NativeScript era)
forall era. ShelleyEraScript era => Int -> Gen (NativeScript era)
sizedMultiSig (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)))
      let i = [NativeScript era] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [NativeScript era]
subs
      RequireMOf <$> choose (0, i) <*> pure (fromList subs)
  ]

instance
  Arbitrary (PParams ShelleyEra) =>
  Arbitrary ShelleyGenesis
  where
  arbitrary :: Gen ShelleyGenesis
arbitrary = do
    sgSystemStart <- Gen UTCTime
forall a. Arbitrary a => Gen a
arbitrary
    sgNetworkMagic <- arbitrary
    sgNetworkId <- arbitrary
    sgActiveSlotsCoeff <- arbitrary
    sgSecurityParam <- arbitrary
    sgEpochLength <- arbitrary
    sgSlotsPerKESPeriod <- arbitrary
    sgMaxKESEvolutions <- arbitrary
    sgSlotLength <- (* 1000000) <$> arbitrary
    sgUpdateQuorum <- arbitrary
    sgMaxLovelaceSupply <- arbitrary
    sgProtocolParams <- arbitrary
    sgGenDelegs <- arbitrary
    sgInitialFunds <- arbitrary
    sgStaking <- arbitrary
    pure ShelleyGenesis {..}

instance Arbitrary ShelleyGenesisStaking where
  arbitrary :: Gen ShelleyGenesisStaking
arbitrary = ListMap (KeyHash StakePool) StakePoolParams
-> ListMap (KeyHash Staking) (KeyHash StakePool)
-> ShelleyGenesisStaking
ShelleyGenesisStaking (ListMap (KeyHash StakePool) StakePoolParams
 -> ListMap (KeyHash Staking) (KeyHash StakePool)
 -> ShelleyGenesisStaking)
-> Gen (ListMap (KeyHash StakePool) StakePoolParams)
-> Gen
     (ListMap (KeyHash Staking) (KeyHash StakePool)
      -> ShelleyGenesisStaking)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (ListMap (KeyHash StakePool) StakePoolParams)
forall a. Arbitrary a => Gen a
arbitrary Gen
  (ListMap (KeyHash Staking) (KeyHash StakePool)
   -> ShelleyGenesisStaking)
-> Gen (ListMap (KeyHash Staking) (KeyHash StakePool))
-> Gen ShelleyGenesisStaking
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (ListMap (KeyHash Staking) (KeyHash StakePool))
forall a. Arbitrary a => Gen a
arbitrary

instance
  ( Era era
  , EraScript era
  , Arbitrary (Script era)
  ) =>
  Arbitrary (ShelleyTxWits era)
  where
  arbitrary :: Gen (ShelleyTxWits era)
arbitrary =
    Set (WitVKey Witness)
-> Map ScriptHash (Script era)
-> Set BootstrapWitness
-> ShelleyTxWits era
forall era.
EraScript era =>
Set (WitVKey Witness)
-> Map ScriptHash (Script era)
-> Set BootstrapWitness
-> ShelleyTxWits era
ShelleyTxWits
      (Set (WitVKey Witness)
 -> Map ScriptHash (Script era)
 -> Set BootstrapWitness
 -> ShelleyTxWits era)
-> Gen (Set (WitVKey Witness))
-> Gen
     (Map ScriptHash (Script era)
      -> Set BootstrapWitness -> ShelleyTxWits era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Set (WitVKey Witness))
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Map ScriptHash (Script era)
   -> Set BootstrapWitness -> ShelleyTxWits era)
-> Gen (Map ScriptHash (Script era))
-> Gen (Set BootstrapWitness -> ShelleyTxWits era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Script era] -> Map ScriptHash (Script era)
mscriptsToWits ([Script era] -> Map ScriptHash (Script era))
-> Gen [Script era] -> Gen (Map ScriptHash (Script era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Script era]
forall a. Arbitrary a => Gen a
arbitrary)
      Gen (Set BootstrapWitness -> ShelleyTxWits era)
-> Gen (Set BootstrapWitness) -> Gen (ShelleyTxWits era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Set BootstrapWitness)
forall a. Arbitrary a => Gen a
arbitrary
    where
      mscriptsToWits :: [Script era] -> Map ScriptHash (Script era)
mscriptsToWits = [(ScriptHash, Script era)] -> Map ScriptHash (Script era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ScriptHash, Script era)] -> Map ScriptHash (Script era))
-> ([Script era] -> [(ScriptHash, Script era)])
-> [Script era]
-> Map ScriptHash (Script era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Script era -> (ScriptHash, Script era))
-> [Script era] -> [(ScriptHash, Script era)]
forall a b. (a -> b) -> [a] -> [b]
map (\Script era
s -> (forall era. EraScript era => Script era -> ScriptHash
hashScript @era Script era
s, Script era
s))

instance Era era => Arbitrary (ShelleyPpupPredFailure era) where
  arbitrary :: Gen (ShelleyPpupPredFailure era)
arbitrary = Gen (ShelleyPpupPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyPpupPredFailure era -> [ShelleyPpupPredFailure era]
shrink = ShelleyPpupPredFailure era -> [ShelleyPpupPredFailure era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Era era => Arbitrary (ShelleyPoolPredFailure era) where
  arbitrary :: Gen (ShelleyPoolPredFailure era)
arbitrary =
    [Gen (ShelleyPoolPredFailure era)]
-> Gen (ShelleyPoolPredFailure era)
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ KeyHash StakePool -> ShelleyPoolPredFailure era
forall era. KeyHash StakePool -> ShelleyPoolPredFailure era
StakePoolNotRegisteredOnKeyPOOL (KeyHash StakePool -> ShelleyPoolPredFailure era)
-> Gen (KeyHash StakePool) -> Gen (ShelleyPoolPredFailure era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (KeyHash StakePool)
forall a. Arbitrary a => Gen a
arbitrary
      , do
          a <- Gen EpochNo
forall a. Arbitrary a => Gen a
arbitrary
          b <- arbitrary
          StakePoolRetirementWrongEpochPOOL (Mismatch a b) . Mismatch a <$> arbitrary
      , Mismatch RelGTEQ Coin -> ShelleyPoolPredFailure era
forall era. Mismatch RelGTEQ Coin -> ShelleyPoolPredFailure era
StakePoolCostTooLowPOOL (Mismatch RelGTEQ Coin -> ShelleyPoolPredFailure era)
-> Gen (Mismatch RelGTEQ Coin) -> Gen (ShelleyPoolPredFailure era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Mismatch RelGTEQ Coin)
forall a. Arbitrary a => Gen a
arbitrary
      , Mismatch RelEQ Network
-> KeyHash StakePool -> ShelleyPoolPredFailure era
forall era.
Mismatch RelEQ Network
-> KeyHash StakePool -> ShelleyPoolPredFailure era
WrongNetworkPOOL (Mismatch RelEQ Network
 -> KeyHash StakePool -> ShelleyPoolPredFailure era)
-> Gen (Mismatch RelEQ Network)
-> Gen (KeyHash StakePool -> ShelleyPoolPredFailure era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Mismatch RelEQ Network)
forall a. Arbitrary a => Gen a
arbitrary Gen (KeyHash StakePool -> ShelleyPoolPredFailure era)
-> Gen (KeyHash StakePool) -> Gen (ShelleyPoolPredFailure era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (KeyHash StakePool)
forall a. Arbitrary a => Gen a
arbitrary
      , KeyHash StakePool -> Int -> ShelleyPoolPredFailure era
forall era. KeyHash StakePool -> Int -> ShelleyPoolPredFailure era
PoolMedataHashTooBig (KeyHash StakePool -> Int -> ShelleyPoolPredFailure era)
-> Gen (KeyHash StakePool)
-> Gen (Int -> ShelleyPoolPredFailure era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (KeyHash StakePool)
forall a. Arbitrary a => Gen a
arbitrary Gen (Int -> ShelleyPoolPredFailure era)
-> Gen Int -> Gen (ShelleyPoolPredFailure era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Int
forall a. Arbitrary a => Gen a
arbitrary
      ]
  shrink :: ShelleyPoolPredFailure era -> [ShelleyPoolPredFailure era]
shrink = ShelleyPoolPredFailure era -> [ShelleyPoolPredFailure era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance
  ( Era era
  , Arbitrary (PredicateFailure (EraRule "POOL" era))
  , Arbitrary (PredicateFailure (EraRule "DELEG" era))
  ) =>
  Arbitrary (ShelleyDelplPredFailure era)
  where
  arbitrary :: Gen (ShelleyDelplPredFailure era)
arbitrary = Gen (ShelleyDelplPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyDelplPredFailure era -> [ShelleyDelplPredFailure era]
shrink = ShelleyDelplPredFailure era -> [ShelleyDelplPredFailure era]
forall a. (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
recursivelyShrink

instance
  Era era =>
  Arbitrary (ShelleyDelegPredFailure era)
  where
  arbitrary :: Gen (ShelleyDelegPredFailure era)
arbitrary = Gen (ShelleyDelegPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyDelegPredFailure era -> [ShelleyDelegPredFailure era]
shrink = ShelleyDelegPredFailure era -> [ShelleyDelegPredFailure era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance
  ( Era era
  , Arbitrary (PredicateFailure (EraRule "DELPL" era))
  ) =>
  Arbitrary (ShelleyDelegsPredFailure era)
  where
  arbitrary :: Gen (ShelleyDelegsPredFailure era)
arbitrary = Gen (ShelleyDelegsPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyDelegsPredFailure era -> [ShelleyDelegsPredFailure era]
shrink = ShelleyDelegsPredFailure era -> [ShelleyDelegsPredFailure era]
forall a. (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
recursivelyShrink

instance
  ( Era era
  , Arbitrary (PredicateFailure (EraRule "LEDGER" era))
  ) =>
  Arbitrary (ShelleyLedgersPredFailure era)
  where
  arbitrary :: Gen (ShelleyLedgersPredFailure era)
arbitrary = Gen (ShelleyLedgersPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyLedgersPredFailure era -> [ShelleyLedgersPredFailure era]
shrink = ShelleyLedgersPredFailure era -> [ShelleyLedgersPredFailure era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance
  ( Era era
  , Arbitrary (PredicateFailure (EraRule "DELEGS" era))
  , Arbitrary (PredicateFailure (EraRule "UTXOW" era))
  ) =>
  Arbitrary (ShelleyLedgerPredFailure era)
  where
  arbitrary :: Gen (ShelleyLedgerPredFailure era)
arbitrary = Gen (ShelleyLedgerPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyLedgerPredFailure era -> [ShelleyLedgerPredFailure era]
shrink ShelleyLedgerPredFailure era
_ = []

instance
  ( Era era
  , Arbitrary (PredicateFailure (EraRule "UTXO" era))
  ) =>
  Arbitrary (ShelleyUtxowPredFailure era)
  where
  arbitrary :: Gen (ShelleyUtxowPredFailure era)
arbitrary = Gen (ShelleyUtxowPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyUtxowPredFailure era -> [ShelleyUtxowPredFailure era]
shrink ShelleyUtxowPredFailure era
_ = []

instance
  ( EraTx era
  , Arbitrary (TxBody TopTx era)
  , Arbitrary (Value era)
  , Arbitrary (TxAuxData era)
  , Arbitrary (Script era)
  , Arbitrary (TxWits era)
  ) =>
  Arbitrary (ShelleyTx TopTx era)
  where
  arbitrary :: Gen (ShelleyTx TopTx era)
arbitrary = Gen (ShelleyTx TopTx era)
forall era.
(Arbitrary (TxBody TopTx era), Arbitrary (TxAuxData era),
 Arbitrary (TxWits era)) =>
Gen (ShelleyTx TopTx era)
genTx

deriving newtype instance Arbitrary (Tx TopTx ShelleyEra)

deriving newtype instance Arbitrary (ApplyTxError ShelleyEra)

instance
  ( Era era
  , Arbitrary (Value era)
  , Arbitrary (TxOut era)
  , Arbitrary (EraRuleFailure "PPUP" era)
  ) =>
  Arbitrary (ShelleyUtxoPredFailure era)
  where
  arbitrary :: Gen (ShelleyUtxoPredFailure era)
arbitrary = Gen (ShelleyUtxoPredFailure era)
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: ShelleyUtxoPredFailure era -> [ShelleyUtxoPredFailure era]
shrink ShelleyUtxoPredFailure era
_ = []

data RawSeed = RawSeed !Word64 !Word64 !Word64 !Word64 !Word64
  deriving (RawSeed -> RawSeed -> Bool
(RawSeed -> RawSeed -> Bool)
-> (RawSeed -> RawSeed -> Bool) -> Eq RawSeed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RawSeed -> RawSeed -> Bool
== :: RawSeed -> RawSeed -> Bool
$c/= :: RawSeed -> RawSeed -> Bool
/= :: RawSeed -> RawSeed -> Bool
Eq, Int -> RawSeed -> String -> String
[RawSeed] -> String -> String
RawSeed -> String
(Int -> RawSeed -> String -> String)
-> (RawSeed -> String)
-> ([RawSeed] -> String -> String)
-> Show RawSeed
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RawSeed -> String -> String
showsPrec :: Int -> RawSeed -> String -> String
$cshow :: RawSeed -> String
show :: RawSeed -> String
$cshowList :: [RawSeed] -> String -> String
showList :: [RawSeed] -> String -> String
Show)

instance Arbitrary RawSeed where
  arbitrary :: Gen RawSeed
arbitrary =
    Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed
      (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed)
-> Gen Word64
-> Gen (Word64 -> Word64 -> Word64 -> Word64 -> RawSeed)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word64
forall a. Random a => Gen a
chooseAny
      Gen (Word64 -> Word64 -> Word64 -> Word64 -> RawSeed)
-> Gen Word64 -> Gen (Word64 -> Word64 -> Word64 -> RawSeed)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Word64
forall a. Random a => Gen a
chooseAny
      Gen (Word64 -> Word64 -> Word64 -> RawSeed)
-> Gen Word64 -> Gen (Word64 -> Word64 -> RawSeed)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Word64
forall a. Random a => Gen a
chooseAny
      Gen (Word64 -> Word64 -> RawSeed)
-> Gen Word64 -> Gen (Word64 -> RawSeed)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Word64
forall a. Random a => Gen a
chooseAny
      Gen (Word64 -> RawSeed) -> Gen Word64 -> Gen RawSeed
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Word64
forall a. Random a => Gen a
chooseAny

instance (Era era, Arbitrary (Accounts era)) => Arbitrary (ShelleyCertState era) where
  arbitrary :: Gen (ShelleyCertState era)
arbitrary = PState era -> DState era -> ShelleyCertState era
forall era. PState era -> DState era -> ShelleyCertState era
ShelleyCertState (PState era -> DState era -> ShelleyCertState era)
-> Gen (PState era) -> Gen (DState era -> ShelleyCertState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (PState era)
forall a. Arbitrary a => Gen a
arbitrary Gen (DState era -> ShelleyCertState era)
-> Gen (DState era) -> Gen (ShelleyCertState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (DState era)
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: ShelleyCertState era -> [ShelleyCertState era]
shrink = ShelleyCertState era -> [ShelleyCertState era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary (ShelleyAccountState era) where
  arbitrary :: Gen (ShelleyAccountState era)
arbitrary = Ptr
-> CompactForm Coin
-> CompactForm Coin
-> StrictMaybe (KeyHash StakePool)
-> ShelleyAccountState era
forall era.
Ptr
-> CompactForm Coin
-> CompactForm Coin
-> StrictMaybe (KeyHash StakePool)
-> ShelleyAccountState era
ShelleyAccountState (Ptr
 -> CompactForm Coin
 -> CompactForm Coin
 -> StrictMaybe (KeyHash StakePool)
 -> ShelleyAccountState era)
-> Gen Ptr
-> Gen
     (CompactForm Coin
      -> CompactForm Coin
      -> StrictMaybe (KeyHash StakePool)
      -> ShelleyAccountState era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ptr
forall a. Arbitrary a => Gen a
arbitrary Gen
  (CompactForm Coin
   -> CompactForm Coin
   -> StrictMaybe (KeyHash StakePool)
   -> ShelleyAccountState era)
-> Gen (CompactForm Coin)
-> Gen
     (CompactForm Coin
      -> StrictMaybe (KeyHash StakePool) -> ShelleyAccountState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (CompactForm Coin)
forall a. Arbitrary a => Gen a
arbitrary Gen
  (CompactForm Coin
   -> StrictMaybe (KeyHash StakePool) -> ShelleyAccountState era)
-> Gen (CompactForm Coin)
-> Gen (StrictMaybe (KeyHash StakePool) -> ShelleyAccountState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (CompactForm Coin)
forall a. Arbitrary a => Gen a
arbitrary Gen (StrictMaybe (KeyHash StakePool) -> ShelleyAccountState era)
-> Gen (StrictMaybe (KeyHash StakePool))
-> Gen (ShelleyAccountState era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (StrictMaybe (KeyHash StakePool))
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: ShelleyAccountState era -> [ShelleyAccountState era]
shrink = ShelleyAccountState era -> [ShelleyAccountState era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary (ShelleyAccounts era) where
  arbitrary :: Gen (ShelleyAccounts era)
arbitrary = Map (Credential Staking) (ShelleyAccountState era)
-> Map Ptr (Credential Staking) -> ShelleyAccounts era
forall era.
Map (Credential Staking) (ShelleyAccountState era)
-> Map Ptr (Credential Staking) -> ShelleyAccounts era
ShelleyAccounts (Map (Credential Staking) (ShelleyAccountState era)
 -> Map Ptr (Credential Staking) -> ShelleyAccounts era)
-> Gen (Map (Credential Staking) (ShelleyAccountState era))
-> Gen (Map Ptr (Credential Staking) -> ShelleyAccounts era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map (Credential Staking) (ShelleyAccountState era))
forall a. Arbitrary a => Gen a
arbitrary Gen (Map Ptr (Credential Staking) -> ShelleyAccounts era)
-> Gen (Map Ptr (Credential Staking)) -> Gen (ShelleyAccounts era)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map Ptr (Credential Staking))
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: ShelleyAccounts era -> [ShelleyAccounts era]
shrink = ShelleyAccounts era -> [ShelleyAccounts era]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance Arbitrary FromByronTranslationContext where
  arbitrary :: Gen FromByronTranslationContext
arbitrary = Gen FromByronTranslationContext
forall a. (GArbitrary UnsizedOpts a, GUniformWeight a) => Gen a
genericArbitraryU
  shrink :: FromByronTranslationContext -> [FromByronTranslationContext]
shrink FromByronTranslationContext
_ = []

deriving newtype instance Arbitrary (TransitionConfig ShelleyEra)

instance EncCBOR RawSeed where
  encCBOR :: RawSeed -> Encoding
encCBOR (RawSeed Word64
w1 Word64
w2 Word64
w3 Word64
w4 Word64
w5) = (Word64, Word64, Word64, Word64, Word64) -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (Word64
w1, Word64
w2, Word64
w3, Word64
w4, Word64
w5)

instance
  ( EraBlockBody era
  , BlockBody era ~ ShelleyBlockBody era
  , Arbitrary (Tx TopTx era)
  , SafeToHash (TxWits era)
  ) =>
  Arbitrary (ShelleyBlockBody era)
  where
  arbitrary :: Gen (ShelleyBlockBody era)
arbitrary = StrictSeq (Tx TopTx era) -> ShelleyBlockBody era
forall era.
(EraTx era, SafeToHash (TxWits era)) =>
StrictSeq (Tx TopTx era) -> ShelleyBlockBody era
ShelleyBlockBody (StrictSeq (Tx TopTx era) -> ShelleyBlockBody era)
-> Gen (StrictSeq (Tx TopTx era)) -> Gen (ShelleyBlockBody era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (StrictSeq (Tx TopTx era))
forall a. Arbitrary a => Gen a
arbitrary