Added ToExpr instances Moved ImpTest to cardano-ledger-conway:testlib Moved ConwayEpochs to cardano-ledger-conway:test
### `testlib`
* Add `ToExpr` instances for:
* `CollectError`
* `AlonzoUtxoPredFailure`
* `FailureDescription`
* `TagMismatchDescription`
* `AlonzoUtxosPredFailure`
* `AlonzoUtxowPredFailure`
* `BinaryData`
* `Datum`
* `IsValid`
* `ScriptPurpose`
* `TxOutSource`
* `TranslationError`
* `Addr28Extra`
* `DataHash32`
* `RdmrPtr`
* Add `Test.Cardano.Ledger.Alonzo.Binary.RoundTrip` module with:
* `roundTripAlonzoCommonSpec`
* `roundTripAlonzoEraTypesSpec`
import Cardano.Ledger.Binary (DecCBOR (..), EncCBOR (..))
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.Language (BinaryPlutus (..), Language (..), Plutus (..))
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.TxIn (TxIn (..))
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..))
import Cardano.Slotting.EpochInfo (EpochInfo)
| BadTranslation !(TranslationError (EraCrypto era))
deriving (Generic)
instance ToExpr (TxCert era) => ToExpr (CollectError era)
deriving instance (Era era, Eq (TxCert era)) => Eq (CollectError era)
deriving instance (Era era, Show (TxCert era)) => Show (CollectError era)
deriving instance (Era era, NoThunks (TxCert era)) => NoThunks (CollectError era)
import Cardano.Ledger.Shelley.Rules (ShelleyUtxoPredFailure, UtxoEnv (..))
import qualified Cardano.Ledger.Shelley.Rules as Shelley
import Cardano.Ledger.Shelley.Tx (TxIn)
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..), areAllAdaOnly, coinBalance, sumAllValue)
import qualified Cardano.Ledger.Val as Val
import Cardano.Slotting.EpochInfo.API (EpochInfo, epochInfoSlotToUTCTime)
| NoCollateralInputs
deriving (Generic)
instance
( ToExpr (Value era)
, ToExpr (TxOut era)
, ToExpr (PredicateFailure (EraRule "UTXOS" era))
) =>
ToExpr (AlonzoUtxoPredFailure era)
deriving stock instance
( Era era
, Show (Value era)
updateUTxOState,
)
import Cardano.Ledger.Shelley.TxCert (ShelleyTxCert)
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..), coinBalance)
import Cardano.Ledger.Val ((<->))
import Cardano.Slotting.EpochInfo.Extend (unsafeLinearExtendEpochInfo)
= PlutusFailure Text BS.ByteString
deriving (Show, Eq, Generic, NoThunks)
instance ToExpr FailureDescription
instance EncCBOR FailureDescription where
-- This strange encoding results from the fact that 'FailureDescription'
-- used to have another constructor, which used key 0.
| FailedUnexpectedly (NonEmpty FailureDescription)
deriving (Show, Eq, Generic, NoThunks)
instance ToExpr TagMismatchDescription
instance EncCBOR TagMismatchDescription where
encCBOR PassedUnexpectedly = encode (Sum PassedUnexpectedly 0)
encCBOR (FailedUnexpectedly fs) = encode (Sum FailedUnexpectedly 1 !> To fs)
deriving
(Generic)
instance
( ToExpr (PPUPPredFailure era)
, ToExpr (TxCert era)
) =>
ToExpr (AlonzoUtxosPredFailure era)
instance PPUPPredFailure era ~ () => Inject () (AlonzoUtxosPredFailure era) where
inject () = UpdateFailure ()
)
where
import Cardano.Crypto.DSIGN.Class (Signable)
import Cardano.Crypto.DSIGN.Class (DSIGNAlgorithm, Signable)
import Cardano.Crypto.Hash.Class (Hash)
import Cardano.Ledger.Alonzo.Era (AlonzoUTXOW)
import Cardano.Ledger.Alonzo.PParams (getLanguageView)
import qualified Cardano.Ledger.Shelley.Rules as Shelley
import Cardano.Ledger.Shelley.Tx (TxIn (..))
import Cardano.Ledger.Shelley.UTxO (ShelleyScriptsNeeded (..))
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..))
import Control.Monad.Trans.Reader (asks)
import Control.SetAlgebra (domain, eval, (⊆), (➖))
![RdmrPtr]
deriving (Generic)
instance
( DSIGNAlgorithm (DSIGN (EraCrypto era))
, ToExpr (PredicateFailure (EraRule "UTXO" era))
, ToExpr (TxCert era)
) =>
ToExpr (AlonzoUtxowPredFailure era)
deriving instance
( Era era
, Show (TxCert era)
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import NoThunks.Class (NoThunks)
import qualified PlutusLedgerApi.V1 as PV1 -- NOTE PV1.Data === PV2.Data
-- NOTE PV1.Data === PV2.Data
import Cardano.Ledger.TreeDiff (ToExpr)
import qualified PlutusLedgerApi.V1 as PV1
-- ============================================================================
-- the newtype Data is a wrapper around the type that Plutus expects as data.
-- exported, in order to prevent invalid creation of data from arbitrary binary
-- data. Use `makeBinaryData` for smart construction.
newtype BinaryData era = BinaryData ShortByteString
deriving newtype (Eq, NoThunks, Ord, Show, SafeToHash)
deriving newtype (Eq, NoThunks, Ord, Show, SafeToHash, ToExpr)
deriving (Generic)
instance EraCrypto era ~ c => HashAnnotated (BinaryData era) EraIndependentData c
= NoDatum
| DatumHash !(DataHash (EraCrypto era))
| Datum !(BinaryData era)
deriving (Eq, Generic, NoThunks, Ord, Show)
deriving (Eq, Generic, NoThunks, Ord, Show, ToExpr)
instance Era era => EncCBOR (Datum era) where
encCBOR d = encode $ case d of
import Cardano.Ledger.SafeHash (HashAnnotated, SafeToHash (..), hashAnnotated)
import Cardano.Ledger.Shelley.Tx (shelleyEqTxRaw)
import Cardano.Ledger.Shelley.TxBody (Withdrawals (..), unWithdrawals)
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.TxIn (TxIn (..))
import qualified Cardano.Ledger.UTxO as Shelley
import Cardano.Ledger.Val (Val ((<+>), (<×>)))
deriving (Eq, Show, Generic)
deriving newtype (NoThunks, NFData, ToCBOR, EncCBOR, DecCBOR)
instance ToExpr IsValid
data AlonzoTx era = AlonzoTx
{ body :: !(TxBody era)
, wits :: !(TxWits era)
| Certifying !(TxCert era)
deriving (Generic)
instance ToExpr (TxCert era) => ToExpr (ScriptPurpose era)
deriving instance (Era era, Eq (TxCert era)) => Eq (ScriptPurpose era)
deriving instance (Era era, Show (TxCert era)) => Show (ScriptPurpose era)
deriving instance (Era era, NoThunks (TxCert era)) => NoThunks (ScriptPurpose era)
fromSLanguage,
withSLanguage,
)
import Cardano.Ledger.Mary.Value (AssetName (..), MaryValue (..), MultiAsset (..), PolicyID (..))
import Cardano.Ledger.Mary.Value (AssetName (..), MaryValue (..), MultiAsset (..), PolicyID (..), ToExpr)
import Cardano.Ledger.PoolParams (PoolParams (..))
import Cardano.Ledger.SafeHash (SafeHash, extractHash, hashAnnotated)
import qualified Cardano.Ledger.Shelley.HardForks as HardForks
| TxOutFromOutput !TxIx
deriving (Eq, Show, Generic, NoThunks)
instance ToExpr (TxOutSource era)
instance Crypto c => EncCBOR (TxOutSource c) where
encCBOR = \case
TxOutFromInput txIn -> encode $ Sum TxOutFromInput 0 !> To txIn
| TimeTranslationPastHorizon !Text
deriving (Eq, Show, Generic, NoThunks)
instance ToExpr (TranslationError c)
instance Crypto c => EncCBOR (TranslationError c) where
encCBOR = \case
ByronTxOutInContext txOutSource ->
unsafeMakeSafeHash,
)
import qualified Cardano.Ledger.Shelley.TxOut as Shelley
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.Val (Val (..))
import Control.DeepSeq (NFData (..), rwhnf)
import Control.Monad (guard, (<$!>))
{-# UNPACK #-} !Word64 -- Payment Addr
{-# UNPACK #-} !Word64 -- Payment Addr
{-# UNPACK #-} !Word64 -- Payment Addr (32bits) + ... + 0/1 for Testnet/Mainnet + 0/1 Script/Pubkey
deriving (Eq, Generic, NoThunks)
deriving (Eq, Generic, NoThunks, ToExpr)
data DataHash32
= DataHash32
{-# UNPACK #-} !Word64 -- DataHash
{-# UNPACK #-} !Word64 -- DataHash
{-# UNPACK #-} !Word64 -- DataHash
{-# UNPACK #-} !Word64 -- DataHash
deriving (Eq, Generic, NoThunks)
deriving (Eq, Generic, NoThunks, ToExpr)
decodeAddress28 ::
forall c.
import Cardano.Ledger.SafeHash (SafeToHash (..))
import Cardano.Ledger.Shelley.TxBody (WitVKey)
import Cardano.Ledger.Shelley.TxWits (keyBy, shelleyEqTxWitsRaw)
import Cardano.Ledger.TreeDiff (ToExpr)
import Control.DeepSeq (NFData)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
{-# UNPACK #-} !Word64
deriving (Eq, Ord, Show, Generic)
instance ToExpr RdmrPtr
instance NoThunks RdmrPtr
instance NFData RdmrPtr
# Version history for `cardano-ledger-babbage`
## 1.4.4.1
*
## 1.4.5.0
* Add `Generic` instance for:
* `BabbageUtxoPredFailure`
* `BabbageUtxowPredFailure`
* Add `ToExpr` instance for:
* `BabbageUtxoPredFailure`
* `BabbageUtxowPredFailure`
* `BabbageTxOut`
## 1.4.4.0
cabal-version: 3.0
name: cardano-ledger-babbage
version: 1.4.4.0
version: 1.4.5.0
license: Apache-2.0
maintainer: [email protected]
author: IOHK
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
import qualified Cardano.Ledger.Shelley.LedgerState as Shelley
import Cardano.Ledger.Shelley.Rules (ShelleyUtxoPredFailure, UtxoEnv)
import qualified Cardano.Ledger.Shelley.Rules as Shelley
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.TxIn (TxIn)
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..), areAllAdaOnly, balance)
import Cardano.Ledger.Val ((<->))
import qualified Data.Map.Strict as Map
import Data.Maybe.Strict (StrictMaybe (..))
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (InspectHeapNamed (..), NoThunks (..))
import Validation (Validation, failureIf, failureUnless)
-- together with the minimum value for the given output.
BabbageOutputTooSmallUTxO
![(TxOut era, Coin)]
deriving (Generic)
instance
( ToExpr (AlonzoUtxoPredFailure era)
, ToExpr (TxOut era)
) =>
ToExpr (BabbageUtxoPredFailure era)
deriving instance
( Era era
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
)
where
import Cardano.Crypto.DSIGN.Class (Signable)
import Cardano.Crypto.DSIGN.Class (DSIGNAlgorithm, Signable)
import Cardano.Crypto.Hash.Class (Hash)
import Cardano.Ledger.Alonzo.Rules (
AlonzoUtxowEvent (WrappedShelleyEraEvent),
validateNeededWitnesses,
)
import qualified Cardano.Ledger.Shelley.Rules as Shelley
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.UTxO (EraUTxO (..), UTxO (..))
import Control.Monad.Trans.Reader (asks)
import Control.State.Transition.Extended (
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Typeable
import GHC.Generics (Generic)
import Lens.Micro
import Lens.Micro.Extras (view)
import NoThunks.Class (InspectHeapNamed (..), NoThunks (..))
| -- | the set of malformed script witnesses
MalformedReferenceScripts
!(Set (ScriptHash (EraCrypto era)))
deriving (Generic)
instance
( ToExpr (PredicateFailure (EraRule "UTXO" era))
, DSIGNAlgorithm (DSIGN (EraCrypto era))
, ToExpr (TxCert era)
) =>
ToExpr (BabbageUtxowPredFailure era)
deriving instance
( Era era
import Cardano.Ledger.Credential (Credential (..), StakeReference (..))
import Cardano.Ledger.Crypto (Crypto (ADDRHASH), StandardCrypto)
import Cardano.Ledger.Keys (KeyRole (..))
import Cardano.Ledger.TreeDiff (ToExpr)
import Cardano.Ledger.Val (Val (..))
import Control.DeepSeq (NFData (rnf), rwhnf)
import Control.Monad ((<$!>))
internBabbageTxOut (interns credsInterns) <$!> decodeBabbageTxOut fromCborBackwardsBothAddr
{-# INLINEABLE decShareCBOR #-}
instance
( ToExpr (CompactAddr (EraCrypto era))
, ToExpr (CompactForm (Value era))
, ToExpr (Script era)
) =>
ToExpr (BabbageTxOut era)
internBabbageTxOut ::
(Credential 'Staking (EraCrypto era) -> Credential 'Staking (EraCrypto era)) ->
BabbageTxOut era ->
## 1.9.0.0
* Add `ToExpr` instance for:
* `Voter`
* `ConwayCertPredFailure`
* `ConwayCertsPredFailure`
* `ConwayDelegPredFailure`
* `ConwayGovPredFailure`
* `ConwayGovCertPredFailure`
* `ConwayLedgerPredFailure`
* Add `totalObligation`
* Add `utxosDepositedL`
* Add `conwayWitsVKeyNeeded`
* Rename `ConwayPParams` to be consistent with the Agda specification. #3739
* `govActionExpiration` to `govActionLifetime`
* `committeeTermLimit` to `committeeMaxTermLength`
### testlib
* Add `Test.Cardano.Ledger.Conway.ImpTest`
* Rename `genNewCommittee` to `genUpdateCommitteee`
* Add `genNewCommittee`
* Add `genNoConfidence`
exposed-modules:
Test.Cardano.Ledger.Conway.Arbitrary
Test.Cardano.Ledger.Conway.Binary.RoundTrip
Test.Cardano.Ledger.Conway.ImpTest
visibility: public
hs-source-dirs: testlib
build-depends:
base,
transformers,
bytestring,
cardano-data:testlib,
cardano-ledger-binary,
data-default-class,
containers,
microlens,
cardano-ledger-binary:{cardano-ledger-binary, testlib},
cardano-crypto-class,
cardano-ledger-core:{cardano-ledger-core, testlib},
cardano-ledger-babbage:testlib,
cardano-ledger-alonzo:{cardano-ledger-alonzo, testlib},
cardano-slotting,
cardano-ledger-conway,
small-steps-test,
cardano-ledger-shelley,
cardano-ledger-babbage,
mtl,
time,
cardano-strict-containers,
small-steps
small-steps,
microlens-mtl
test-suite tests
type: exitcode-stdio-1.0
Test.Cardano.Ledger.Conway.RatifySpec
Test.Cardano.Ledger.Conway.GenesisSpec
Test.Cardano.Ledger.Conway.GovActionReorderSpec
Test.Cardano.Ledger.Conway.ConwayEpochs
Paths_cardano_ledger_conway
default-language: Haskell2010
base,
cardano-ledger-core:testlib,
cardano-ledger-conway,
cardano-ledger-shelley,
cardano-ledger-core,
cardano-ledger-binary:testlib,
cardano-ledger-binary:{cardano-ledger-binary, testlib},
containers,
data-default-class,
testlib,
text,
cardano-strict-containers,
cardano-ledger-binary:testlib
microlens
| StakePoolVoter !(KeyHash 'StakePool c)
deriving (Generic, Eq, Ord, Show)
instance ToExpr (Voter c)
instance Crypto c => ToJSON (Voter c)
instance Crypto c => ToJSONKey (Voter c) where
VState,
)
import Cardano.Ledger.Shelley.Rules (ShelleyPoolPredFailure)
import Cardano.Ledger.TreeDiff (ToExpr)
import Control.DeepSeq (NFData)
import Control.State.Transition.Extended (
Embed,
| GovCertFailure (PredicateFailure (EraRule "GOVCERT" era))
deriving (Generic)
instance
( ToExpr (PredicateFailure (EraRule "DELEG" era))
, ToExpr (PredicateFailure (EraRule "GOVCERT" era))
, ToExpr (PredicateFailure (EraRule "POOL" era))
) =>
ToExpr (ConwayCertPredFailure era)
deriving stock instance
( Show (PredicateFailure (EraRule "DELEG" era))
, Show (PredicateFailure (EraRule "POOL" era))
validateDelegationRegistered,
validateZeroRewards,
)
import Cardano.Ledger.TreeDiff (ToExpr)
import Control.Monad.Trans.Reader (asks)
import Control.State.Transition.Extended (
Embed (..),
CertFailure !(PredicateFailure (EraRule "CERT" era))
deriving (Generic)
instance
ToExpr (PredicateFailure (EraRule "CERT" era)) =>
ToExpr (ConwayCertsPredFailure era)
deriving stock instance
Eq (PredicateFailure (EraRule "CERT" era)) =>
Eq (ConwayCertsPredFailure era)
Alonzo builds
