{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}

module Test.Cardano.Ledger.Conway.Examples.Consensus where

import Cardano.Ledger.Alonzo.Scripts (AlonzoScript (..), ExUnits (..))
import Cardano.Ledger.Alonzo.Tx (IsValid (..))
import Cardano.Ledger.Alonzo.TxAuxData (mkAlonzoTxAuxData)
import Cardano.Ledger.Alonzo.TxWits (Redeemers (..), TxDats (..))
import Cardano.Ledger.Babbage.TxBody (BabbageTxOut (..))
import Cardano.Ledger.BaseTypes
import Cardano.Ledger.Binary (mkSized)
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Conway (ConwayEra)
import Cardano.Ledger.Conway.Core
import Cardano.Ledger.Conway.Genesis (ConwayGenesis (..))
import Cardano.Ledger.Conway.Governance (VotingProcedures (..))
import Cardano.Ledger.Conway.Rules (ConwayDELEG, ConwayDelegPredFailure (..), ConwayLEDGER)
import Cardano.Ledger.Conway.Scripts (ConwayPlutusPurpose (..))
import Cardano.Ledger.Conway.Translation ()
import Cardano.Ledger.Conway.Tx (AlonzoTx (..))
import Cardano.Ledger.Conway.TxBody (TxBody (..))
import Cardano.Ledger.Conway.TxCert
import Cardano.Ledger.Conway.TxWits (AlonzoTxWits (..))
import Cardano.Ledger.Credential (Credential (KeyHashObj, ScriptHashObj))
import Cardano.Ledger.Keys (asWitness)
import Cardano.Ledger.Mary.Value (MaryValue (..))
import Cardano.Ledger.Plutus.Data (
  Data (..),
  Datum (..),
  dataToBinaryData,
  hashData,
 )
import Cardano.Ledger.Plutus.Language (Language (..))
import Cardano.Ledger.Shelley.API (
  ApplyTxError (..),
  NewEpochState (..),
  ProposedPPUpdates (..),
  RewardAccount (..),
  TxId (..),
 )
import Cardano.Ledger.Shelley.Scripts (
  pattern RequireAllOf,
 )
import Cardano.Ledger.Shelley.Tx (ShelleyTx (..))
import Cardano.Ledger.TxIn (mkTxInPartial)
import Control.State.Transition.Extended (Embed (..))
import Data.Default (Default (def))
import qualified Data.Map.Strict as Map
import qualified Data.OSet.Strict as OSet
import qualified Data.Sequence.Strict as StrictSeq
import qualified Data.Set as Set
import Lens.Micro
import qualified PlutusLedgerApi.Common as P
import Test.Cardano.Ledger.Alonzo.Arbitrary (alwaysFails, alwaysSucceeds)
import Test.Cardano.Ledger.Conway.Genesis (expectedConwayGenesis)
import Test.Cardano.Ledger.Core.KeyPair (mkAddr, mkWitnessesVKey)
import Test.Cardano.Ledger.Core.Utils (mkDummySafeHash)
import qualified Test.Cardano.Ledger.Mary.Examples.Consensus as MarySLE
import Test.Cardano.Ledger.Shelley.Examples.Consensus (examplePoolParams)
import qualified Test.Cardano.Ledger.Shelley.Examples.Consensus as SLE

-- ==============================================================

-- | ShelleyLedgerExamples for Conway era
ledgerExamplesConway ::
  SLE.ShelleyLedgerExamples ConwayEra
ledgerExamplesConway :: ShelleyLedgerExamples ConwayEra
ledgerExamplesConway =
  SLE.ShelleyLedgerExamples
    { sleBlock :: Block (BHeader StandardCrypto) ConwayEra
SLE.sleBlock = Tx ConwayEra -> Block (BHeader StandardCrypto) ConwayEra
forall era.
EraSegWits era =>
Tx era -> Block (BHeader StandardCrypto) era
SLE.exampleShelleyLedgerBlock Tx ConwayEra
AlonzoTx ConwayEra
exampleTransactionInBlock
    , sleHashHeader :: HashHeader
SLE.sleHashHeader = HashHeader
SLE.exampleHashHeader
    , sleTx :: Tx ConwayEra
SLE.sleTx = Tx ConwayEra
AlonzoTx ConwayEra
exampleTransactionInBlock
    , sleApplyTxError :: ApplyTxError ConwayEra
SLE.sleApplyTxError =
        NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra))
-> ApplyTxError ConwayEra
forall era.
NonEmpty (PredicateFailure (EraRule "LEDGER" era))
-> ApplyTxError era
ApplyTxError (NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra))
 -> ApplyTxError ConwayEra)
-> NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra))
-> ApplyTxError ConwayEra
forall a b. (a -> b) -> a -> b
$
          PredicateFailure (EraRule "LEDGER" ConwayEra)
-> NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra))
forall a. a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PredicateFailure (EraRule "LEDGER" ConwayEra)
 -> NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra)))
-> PredicateFailure (EraRule "LEDGER" ConwayEra)
-> NonEmpty (PredicateFailure (EraRule "LEDGER" ConwayEra))
forall a b. (a -> b) -> a -> b
$
            forall sub super.
Embed sub super =>
PredicateFailure sub -> PredicateFailure super
wrapFailed @(ConwayDELEG ConwayEra) @(ConwayLEDGER ConwayEra) (PredicateFailure (ConwayDELEG ConwayEra)
 -> PredicateFailure (ConwayLEDGER ConwayEra))
-> PredicateFailure (ConwayDELEG ConwayEra)
-> PredicateFailure (ConwayLEDGER ConwayEra)
forall a b. (a -> b) -> a -> b
$
              forall era. KeyHash 'StakePool -> ConwayDelegPredFailure era
DelegateeStakePoolNotRegisteredDELEG @ConwayEra (Int -> KeyHash 'StakePool
forall (discriminator :: KeyRole). Int -> KeyHash discriminator
SLE.mkKeyHash Int
1)
    , sleRewardsCredentials :: Set (Either Coin (Credential 'Staking))
SLE.sleRewardsCredentials =
        [Either Coin (Credential 'Staking)]
-> Set (Either Coin (Credential 'Staking))
forall a. Ord a => [a] -> Set a
Set.fromList
          [ Coin -> Either Coin (Credential 'Staking)
forall a b. a -> Either a b
Left (Integer -> Coin
Coin Integer
100)
          , Credential 'Staking -> Either Coin (Credential 'Staking)
forall a b. b -> Either a b
Right (ScriptHash -> Credential 'Staking
forall (kr :: KeyRole). ScriptHash -> Credential kr
ScriptHashObj (Int -> ScriptHash
SLE.mkScriptHash Int
1))
          , Credential 'Staking -> Either Coin (Credential 'Staking)
forall a b. b -> Either a b
Right (KeyHash 'Staking -> Credential 'Staking
forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj (Int -> KeyHash 'Staking
forall (discriminator :: KeyRole). Int -> KeyHash discriminator
SLE.mkKeyHash Int
2))
          ]
    , sleResultExamples :: ShelleyResultExamples ConwayEra
SLE.sleResultExamples = ShelleyResultExamples ConwayEra
resultExamples
    , sleNewEpochState :: NewEpochState ConwayEra
SLE.sleNewEpochState = NewEpochState ConwayEra
exampleConwayNewEpochState
    , sleChainDepState :: ChainDepState
SLE.sleChainDepState = Word64 -> ChainDepState
SLE.exampleLedgerChainDepState Word64
1
    , sleTranslationContext :: TranslationContext ConwayEra
SLE.sleTranslationContext = TranslationContext ConwayEra
ConwayGenesis
exampleConwayGenesis
    }
  where
    resultExamples :: ShelleyResultExamples ConwayEra
resultExamples =
      SLE.ShelleyResultExamples
        { srePParams :: PParams ConwayEra
SLE.srePParams = PParams ConwayEra
forall a. Default a => a
def
        , sreProposedPPUpdates :: ProposedPPUpdates ConwayEra
SLE.sreProposedPPUpdates = ProposedPPUpdates ConwayEra
examplePPPU
        , srePoolDistr :: PoolDistr
SLE.srePoolDistr = PoolDistr
SLE.examplePoolDistr
        , sreNonMyopicRewards :: Map
  (Either Coin (Credential 'Staking)) (Map (KeyHash 'StakePool) Coin)
SLE.sreNonMyopicRewards = Map
  (Either Coin (Credential 'Staking)) (Map (KeyHash 'StakePool) Coin)
SLE.exampleNonMyopicRewards
        , sreShelleyGenesis :: ShelleyGenesis
SLE.sreShelleyGenesis = ShelleyGenesis
SLE.testShelleyGenesis
        }
    examplePPPU :: ProposedPPUpdates ConwayEra
examplePPPU =
      Map (KeyHash 'Genesis) (PParamsUpdate ConwayEra)
-> ProposedPPUpdates ConwayEra
forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates (Map (KeyHash 'Genesis) (PParamsUpdate ConwayEra)
 -> ProposedPPUpdates ConwayEra)
-> Map (KeyHash 'Genesis) (PParamsUpdate ConwayEra)
-> ProposedPPUpdates ConwayEra
forall a b. (a -> b) -> a -> b
$
        KeyHash 'Genesis
-> PParamsUpdate ConwayEra
-> Map (KeyHash 'Genesis) (PParamsUpdate ConwayEra)
forall k a. k -> a -> Map k a
Map.singleton
          (Int -> KeyHash 'Genesis
forall (discriminator :: KeyRole). Int -> KeyHash discriminator
SLE.mkKeyHash Int
0)
          (PParamsUpdate ConwayEra
forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate PParamsUpdate ConwayEra
-> (PParamsUpdate ConwayEra -> PParamsUpdate ConwayEra)
-> PParamsUpdate ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe Natural -> Identity (StrictMaybe Natural))
-> PParamsUpdate ConwayEra -> Identity (PParamsUpdate ConwayEra)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
Lens' (PParamsUpdate ConwayEra) (StrictMaybe Natural)
ppuCollateralPercentageL ((StrictMaybe Natural -> Identity (StrictMaybe Natural))
 -> PParamsUpdate ConwayEra -> Identity (PParamsUpdate ConwayEra))
-> StrictMaybe Natural
-> PParamsUpdate ConwayEra
-> PParamsUpdate ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Natural -> StrictMaybe Natural
forall a. a -> StrictMaybe a
SJust Natural
150)

collateralOutput :: BabbageTxOut ConwayEra
collateralOutput :: BabbageTxOut ConwayEra
collateralOutput =
  Addr
-> Value ConwayEra
-> Datum ConwayEra
-> StrictMaybe (Script ConwayEra)
-> BabbageTxOut ConwayEra
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut
    (KeyPair 'Payment -> KeyPair 'Staking -> Addr
forall p s.
(MakeCredential p 'Payment, MakeStakeReference s) =>
p -> s -> Addr
mkAddr KeyPair 'Payment
SLE.examplePayKey KeyPair 'Staking
SLE.exampleStakeKey)
    (Coin -> MultiAsset -> MaryValue
MaryValue (Integer -> Coin
Coin Integer
8675309) MultiAsset
forall a. Monoid a => a
mempty)
    Datum ConwayEra
forall era. Datum era
NoDatum
    StrictMaybe (Script ConwayEra)
StrictMaybe (AlonzoScript ConwayEra)
forall a. StrictMaybe a
SNothing

exampleConwayCerts :: OSet.OSet (ConwayTxCert era)
exampleConwayCerts :: forall era. OSet (ConwayTxCert era)
exampleConwayCerts =
  [ConwayTxCert era] -> OSet (ConwayTxCert era)
forall a. Ord a => [a] -> OSet a
OSet.fromList -- TODO should I add the new certs here?
    [ PoolCert -> ConwayTxCert era
forall era. PoolCert -> ConwayTxCert era
ConwayTxCertPool (PoolParams -> PoolCert
RegPool PoolParams
examplePoolParams)
    ]

exampleTxBodyConway :: TxBody ConwayEra
exampleTxBodyConway :: TxBody ConwayEra
exampleTxBodyConway =
  Set TxIn
-> Set TxIn
-> Set TxIn
-> StrictSeq (Sized (TxOut ConwayEra))
-> StrictMaybe (Sized (TxOut ConwayEra))
-> StrictMaybe Coin
-> OSet (TxCert ConwayEra)
-> Withdrawals
-> Coin
-> ValidityInterval
-> Set (KeyHash 'Witness)
-> MultiAsset
-> StrictMaybe ScriptIntegrityHash
-> StrictMaybe TxAuxDataHash
-> StrictMaybe Network
-> VotingProcedures ConwayEra
-> OSet (ProposalProcedure ConwayEra)
-> StrictMaybe Coin
-> Coin
-> TxBody ConwayEra
ConwayTxBody
    ([TxIn] -> Set TxIn
forall a. Ord a => [a] -> Set a
Set.fromList [HasCallStack => TxId -> Integer -> TxIn
TxId -> Integer -> TxIn
mkTxInPartial (SafeHash EraIndependentTxBody -> TxId
TxId (Int -> SafeHash EraIndependentTxBody
forall a. Int -> SafeHash a
mkDummySafeHash Int
1)) Integer
0]) -- spending inputs
    ([TxIn] -> Set TxIn
forall a. Ord a => [a] -> Set a
Set.fromList [HasCallStack => TxId -> Integer -> TxIn
TxId -> Integer -> TxIn
mkTxInPartial (SafeHash EraIndependentTxBody -> TxId
TxId (Int -> SafeHash EraIndependentTxBody
forall a. Int -> SafeHash a
mkDummySafeHash Int
2)) Integer
1]) -- collateral inputs
    ([TxIn] -> Set TxIn
forall a. Ord a => [a] -> Set a
Set.fromList [HasCallStack => TxId -> Integer -> TxIn
TxId -> Integer -> TxIn
mkTxInPartial (SafeHash EraIndependentTxBody -> TxId
TxId (Int -> SafeHash EraIndependentTxBody
forall a. Int -> SafeHash a
mkDummySafeHash Int
1)) Integer
3]) -- reference inputs
    ( [Sized (BabbageTxOut ConwayEra)]
-> StrictSeq (Sized (BabbageTxOut ConwayEra))
forall a. [a] -> StrictSeq a
StrictSeq.fromList
        [ Version -> BabbageTxOut ConwayEra -> Sized (BabbageTxOut ConwayEra)
forall a. EncCBOR a => Version -> a -> Sized a
mkSized (forall era. Era era => Version
eraProtVerHigh @ConwayEra) (BabbageTxOut ConwayEra -> Sized (BabbageTxOut ConwayEra))
-> BabbageTxOut ConwayEra -> Sized (BabbageTxOut ConwayEra)
forall a b. (a -> b) -> a -> b
$
            Addr
-> Value ConwayEra
-> Datum ConwayEra
-> StrictMaybe (Script ConwayEra)
-> BabbageTxOut ConwayEra
forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut
              (KeyPair 'Payment -> KeyPair 'Staking -> Addr
forall p s.
(MakeCredential p 'Payment, MakeStakeReference s) =>
p -> s -> Addr
mkAddr KeyPair 'Payment
SLE.examplePayKey KeyPair 'Staking
SLE.exampleStakeKey)
              (Int -> MaryValue
MarySLE.exampleMultiAssetValue Int
2)
              (BinaryData ConwayEra -> Datum ConwayEra
forall era. BinaryData era -> Datum era
Datum (BinaryData ConwayEra -> Datum ConwayEra)
-> BinaryData ConwayEra -> Datum ConwayEra
forall a b. (a -> b) -> a -> b
$ Data ConwayEra -> BinaryData ConwayEra
forall era. Data era -> BinaryData era
dataToBinaryData Data ConwayEra
datumExample) -- inline datum
              (Script ConwayEra -> StrictMaybe (Script ConwayEra)
forall a. a -> StrictMaybe a
SJust (Script ConwayEra -> StrictMaybe (Script ConwayEra))
-> Script ConwayEra -> StrictMaybe (Script ConwayEra)
forall a b. (a -> b) -> a -> b
$ forall (l :: Language) era.
(HasCallStack, EraPlutusTxInfo l era) =>
Natural -> Script era
alwaysSucceeds @'PlutusV2 Natural
3) -- reference script
        ]
    )
    (Sized (TxOut ConwayEra) -> StrictMaybe (Sized (TxOut ConwayEra))
forall a. a -> StrictMaybe a
SJust (Sized (TxOut ConwayEra) -> StrictMaybe (Sized (TxOut ConwayEra)))
-> Sized (TxOut ConwayEra) -> StrictMaybe (Sized (TxOut ConwayEra))
forall a b. (a -> b) -> a -> b
$ Version -> BabbageTxOut ConwayEra -> Sized (BabbageTxOut ConwayEra)
forall a. EncCBOR a => Version -> a -> Sized a
mkSized (forall era. Era era => Version
eraProtVerHigh @ConwayEra) BabbageTxOut ConwayEra
collateralOutput) -- collateral return
    (Coin -> StrictMaybe Coin
forall a. a -> StrictMaybe a
SJust (Coin -> StrictMaybe Coin) -> Coin -> StrictMaybe Coin
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
8675309) -- collateral tot
    OSet (TxCert ConwayEra)
OSet (ConwayTxCert ConwayEra)
forall era. OSet (ConwayTxCert era)
exampleConwayCerts -- txcerts
    ( Map RewardAccount Coin -> Withdrawals
Withdrawals (Map RewardAccount Coin -> Withdrawals)
-> Map RewardAccount Coin -> Withdrawals
forall a b. (a -> b) -> a -> b
$
        RewardAccount -> Coin -> Map RewardAccount Coin
forall k a. k -> a -> Map k a
Map.singleton
          (Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet (KeyPair 'Staking -> Credential 'Staking
forall (r :: KeyRole). KeyPair r -> Credential r
SLE.keyToCredential KeyPair 'Staking
SLE.exampleStakeKey))
          (Integer -> Coin
Coin Integer
100) -- txwdrls
    )
    (Integer -> Coin
Coin Integer
999) -- txfee
    (StrictMaybe SlotNo -> StrictMaybe SlotNo -> ValidityInterval
ValidityInterval (SlotNo -> StrictMaybe SlotNo
forall a. a -> StrictMaybe a
SJust (Word64 -> SlotNo
SlotNo Word64
2)) (SlotNo -> StrictMaybe SlotNo
forall a. a -> StrictMaybe a
SJust (Word64 -> SlotNo
SlotNo Word64
4))) -- txvldt
    (KeyHash 'Witness -> Set (KeyHash 'Witness)
forall a. a -> Set a
Set.singleton (KeyHash 'Witness -> Set (KeyHash 'Witness))
-> KeyHash 'Witness -> Set (KeyHash 'Witness)
forall a b. (a -> b) -> a -> b
$ Int -> KeyHash 'Witness
forall (discriminator :: KeyRole). Int -> KeyHash discriminator
SLE.mkKeyHash Int
212) -- reqSignerHashes
    MultiAsset
exampleMultiAsset -- mint
    (ScriptIntegrityHash -> StrictMaybe ScriptIntegrityHash
forall a. a -> StrictMaybe a
SJust (ScriptIntegrityHash -> StrictMaybe ScriptIntegrityHash)
-> ScriptIntegrityHash -> StrictMaybe ScriptIntegrityHash
forall a b. (a -> b) -> a -> b
$ Int -> ScriptIntegrityHash
forall a. Int -> SafeHash a
mkDummySafeHash Int
42) -- scriptIntegrityHash
    (TxAuxDataHash -> StrictMaybe TxAuxDataHash
forall a. a -> StrictMaybe a
SJust (TxAuxDataHash -> StrictMaybe TxAuxDataHash)
-> (SafeHash EraIndependentTxAuxData -> TxAuxDataHash)
-> SafeHash EraIndependentTxAuxData
-> StrictMaybe TxAuxDataHash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SafeHash EraIndependentTxAuxData -> TxAuxDataHash
TxAuxDataHash (SafeHash EraIndependentTxAuxData -> StrictMaybe TxAuxDataHash)
-> SafeHash EraIndependentTxAuxData -> StrictMaybe TxAuxDataHash
forall a b. (a -> b) -> a -> b
$ Int -> SafeHash EraIndependentTxAuxData
forall a. Int -> SafeHash a
mkDummySafeHash Int
42) -- adHash
    (Network -> StrictMaybe Network
forall a. a -> StrictMaybe a
SJust Network
Mainnet) -- txnetworkid
    (Map Voter (Map GovActionId (VotingProcedure ConwayEra))
-> VotingProcedures ConwayEra
forall era.
Map Voter (Map GovActionId (VotingProcedure era))
-> VotingProcedures era
VotingProcedures Map Voter (Map GovActionId (VotingProcedure ConwayEra))
forall a. Monoid a => a
mempty)
    OSet (ProposalProcedure ConwayEra)
forall a. Monoid a => a
mempty
    (Coin -> StrictMaybe Coin
forall a. a -> StrictMaybe a
SJust (Coin -> StrictMaybe Coin) -> Coin -> StrictMaybe Coin
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
867530900000) -- current treasury value
    Coin
forall a. Monoid a => a
mempty
  where
    MaryValue Coin
_ MultiAsset
exampleMultiAsset = Int -> MaryValue
MarySLE.exampleMultiAssetValue Int
3

datumExample :: Data ConwayEra
datumExample :: Data ConwayEra
datumExample = Data -> Data ConwayEra
forall era. Era era => Data -> Data era
Data (Integer -> Data
P.I Integer
191)

redeemerExample :: Data ConwayEra
redeemerExample :: Data ConwayEra
redeemerExample = Data -> Data ConwayEra
forall era. Era era => Data -> Data era
Data (Integer -> Data
P.I Integer
919)

exampleTx :: ShelleyTx ConwayEra
exampleTx :: ShelleyTx ConwayEra
exampleTx =
  TxBody ConwayEra
-> TxWits ConwayEra
-> StrictMaybe (TxAuxData ConwayEra)
-> ShelleyTx ConwayEra
forall era.
EraTx era =>
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx
    TxBody ConwayEra
exampleTxBodyConway
    ( Set (WitVKey 'Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script ConwayEra)
-> TxDats ConwayEra
-> Redeemers ConwayEra
-> AlonzoTxWits ConwayEra
forall era.
AlonzoEraScript era =>
Set (WitVKey 'Witness)
-> Set BootstrapWitness
-> Map ScriptHash (Script era)
-> TxDats era
-> Redeemers era
-> AlonzoTxWits era
AlonzoTxWits
        (SafeHash EraIndependentTxBody
-> [KeyPair 'Witness] -> Set (WitVKey 'Witness)
forall (kr :: KeyRole).
SafeHash EraIndependentTxBody
-> [KeyPair kr] -> Set (WitVKey 'Witness)
mkWitnessesVKey (TxBody ConwayEra -> SafeHash EraIndependentTxBody
forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated TxBody ConwayEra
exampleTxBodyConway) [KeyPair 'Payment -> KeyPair 'Witness
forall (a :: KeyRole -> *) (r :: KeyRole).
HasKeyRole a =>
a r -> a 'Witness
asWitness KeyPair 'Payment
SLE.examplePayKey]) -- vkey
        Set BootstrapWitness
forall a. Monoid a => a
mempty -- bootstrap
        ( ScriptHash
-> AlonzoScript ConwayEra
-> Map ScriptHash (AlonzoScript ConwayEra)
forall k a. k -> a -> Map k a
Map.singleton
            (forall era. EraScript era => Script era -> ScriptHash
hashScript @ConwayEra (Script ConwayEra -> ScriptHash) -> Script ConwayEra -> ScriptHash
forall a b. (a -> b) -> a -> b
$ forall (l :: Language) era.
(HasCallStack, EraPlutusTxInfo l era) =>
Natural -> Script era
alwaysSucceeds @'PlutusV1 Natural
3)
            (forall (l :: Language) era.
(HasCallStack, EraPlutusTxInfo l era) =>
Natural -> Script era
alwaysSucceeds @'PlutusV1 Natural
3) -- txscripts
        )
        (Map DataHash (Data ConwayEra) -> TxDats ConwayEra
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats (Map DataHash (Data ConwayEra) -> TxDats ConwayEra)
-> Map DataHash (Data ConwayEra) -> TxDats ConwayEra
forall a b. (a -> b) -> a -> b
$ DataHash -> Data ConwayEra -> Map DataHash (Data ConwayEra)
forall k a. k -> a -> Map k a
Map.singleton (Data ConwayEra -> DataHash
forall era. Data era -> DataHash
hashData Data ConwayEra
datumExample) Data ConwayEra
datumExample)
        ( Map (PlutusPurpose AsIx ConwayEra) (Data ConwayEra, ExUnits)
-> Redeemers ConwayEra
forall era.
AlonzoEraScript era =>
Map (PlutusPurpose AsIx era) (Data era, ExUnits) -> Redeemers era
Redeemers (Map (PlutusPurpose AsIx ConwayEra) (Data ConwayEra, ExUnits)
 -> Redeemers ConwayEra)
-> Map (PlutusPurpose AsIx ConwayEra) (Data ConwayEra, ExUnits)
-> Redeemers ConwayEra
forall a b. (a -> b) -> a -> b
$
            ConwayPlutusPurpose AsIx ConwayEra
-> (Data ConwayEra, ExUnits)
-> Map
     (ConwayPlutusPurpose AsIx ConwayEra) (Data ConwayEra, ExUnits)
forall k a. k -> a -> Map k a
Map.singleton (AsIx Word32 TxIn -> ConwayPlutusPurpose AsIx ConwayEra
forall (f :: * -> * -> *) era.
f Word32 TxIn -> ConwayPlutusPurpose f era
ConwaySpending (AsIx Word32 TxIn -> ConwayPlutusPurpose AsIx ConwayEra)
-> AsIx Word32 TxIn -> ConwayPlutusPurpose AsIx ConwayEra
forall a b. (a -> b) -> a -> b
$ Word32 -> AsIx Word32 TxIn
forall ix it. ix -> AsIx ix it
AsIx Word32
0) (Data ConwayEra
redeemerExample, Natural -> Natural -> ExUnits
ExUnits Natural
5000 Natural
5000)
        ) -- redeemers
    )
    ( TxAuxData ConwayEra -> StrictMaybe (TxAuxData ConwayEra)
forall a. a -> StrictMaybe a
SJust (TxAuxData ConwayEra -> StrictMaybe (TxAuxData ConwayEra))
-> TxAuxData ConwayEra -> StrictMaybe (TxAuxData ConwayEra)
forall a b. (a -> b) -> a -> b
$
        Map Word64 Metadatum
-> [AlonzoScript ConwayEra] -> AlonzoTxAuxData ConwayEra
forall (f :: * -> *) era.
(Foldable f, AlonzoEraScript era) =>
Map Word64 Metadatum -> f (AlonzoScript era) -> AlonzoTxAuxData era
mkAlonzoTxAuxData
          Map Word64 Metadatum
SLE.exampleAuxDataMap -- metadata
          [forall (l :: Language) era.
(HasCallStack, EraPlutusTxInfo l era) =>
Natural -> Script era
alwaysFails @'PlutusV1 Natural
2, Timelock ConwayEra -> AlonzoScript ConwayEra
forall era. Timelock era -> AlonzoScript era
TimelockScript (Timelock ConwayEra -> AlonzoScript ConwayEra)
-> Timelock ConwayEra -> AlonzoScript ConwayEra
forall a b. (a -> b) -> a -> b
$ StrictSeq (NativeScript ConwayEra) -> NativeScript ConwayEra
forall era.
ShelleyEraScript era =>
StrictSeq (NativeScript era) -> NativeScript era
RequireAllOf StrictSeq (Timelock ConwayEra)
StrictSeq (NativeScript ConwayEra)
forall a. Monoid a => a
mempty] -- Scripts
    )

exampleTransactionInBlock :: AlonzoTx ConwayEra
exampleTransactionInBlock :: AlonzoTx ConwayEra
exampleTransactionInBlock = TxBody ConwayEra
-> TxWits ConwayEra
-> IsValid
-> StrictMaybe (TxAuxData ConwayEra)
-> AlonzoTx ConwayEra
forall era.
TxBody era
-> TxWits era
-> IsValid
-> StrictMaybe (TxAuxData era)
-> AlonzoTx era
AlonzoTx TxBody ConwayEra
b TxWits ConwayEra
AlonzoTxWits ConwayEra
w (Bool -> IsValid
IsValid Bool
True) StrictMaybe (TxAuxData ConwayEra)
StrictMaybe (AlonzoTxAuxData ConwayEra)
a
  where
    ShelleyTx TxBody ConwayEra
b TxWits ConwayEra
w StrictMaybe (TxAuxData ConwayEra)
a = ShelleyTx ConwayEra
exampleTx

exampleConwayNewEpochState :: NewEpochState ConwayEra
exampleConwayNewEpochState :: NewEpochState ConwayEra
exampleConwayNewEpochState =
  Value ConwayEra
-> PParams ConwayEra
-> PParams ConwayEra
-> NewEpochState ConwayEra
forall era.
(EraTxOut era, EraGov era, EraStake era, EraCertState era,
 Default (StashedAVVMAddresses era)) =>
Value era -> PParams era -> PParams era -> NewEpochState era
SLE.exampleNewEpochState
    (Int -> MaryValue
MarySLE.exampleMultiAssetValue Int
1)
    PParams ConwayEra
forall era. EraPParams era => PParams era
emptyPParams
    (PParams ConwayEra
forall era. EraPParams era => PParams era
emptyPParams PParams ConwayEra
-> (PParams ConwayEra -> PParams ConwayEra) -> PParams ConwayEra
forall a b. a -> (a -> b) -> b
& (CoinPerByte -> Identity CoinPerByte)
-> PParams ConwayEra -> Identity (PParams ConwayEra)
forall era.
BabbageEraPParams era =>
Lens' (PParams era) CoinPerByte
Lens' (PParams ConwayEra) CoinPerByte
ppCoinsPerUTxOByteL ((CoinPerByte -> Identity CoinPerByte)
 -> PParams ConwayEra -> Identity (PParams ConwayEra))
-> CoinPerByte -> PParams ConwayEra -> PParams ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Coin -> CoinPerByte
CoinPerByte (Integer -> Coin
Coin Integer
1))

exampleConwayGenesis :: ConwayGenesis
exampleConwayGenesis :: ConwayGenesis
exampleConwayGenesis = ConwayGenesis
expectedConwayGenesis