Automatic reference script

CHANGELOG.md

@@ -22,6 +22,10 @@
   constrained yet.
 - PrettyCooked option `pcOptPrintLog`, which is a boolean, to turn on or off the log
   display in the pretty printer. The default value is `True`.
+- Reference inputs with proper reference scripts are now automatically attached
+  to redeemers. This can be turned off using `txOptAutoReferenceScripts`, in
+  which case the helper `withReferenceInput` can be used on a redeemer to
+  automatically attach a reference input.
 - Capability to test the result of a mockchain run based on the log entries.
 
 ### Removed
@@ -34,10 +38,8 @@
 - GHC bumped to 9.6.6
 - Internal representation of redeemers have changed, and are similar for any
   supported script purpose (minting, spending or proposing).
-- Redeemers should now be built using one of the four following smart
-  constructors: `txSkelSomeRedeemer`, `txSkelEmptyRedeemer`,
-  `txSkelSomeRedeemerAndReferenceScript`,
-  `txSkelEmptyRedeemerAndReferenceScript`.
+- Redeemers should now be built using one of the two following smart
+  constructors: `someTxSkelRedeemer`, `emptyTxSkelRedeemer`
 - `mkProposingScript` changed to `mkScript`
 - `withDatumHashed` changed to `withUnresolvedDatumHash`
 - `paysScriptDatumHashed` changed to `paysScriptUnresolvedDatumHash`

cooked-validators.cabal

@@ -24,13 +24,14 @@ library
       Cooked.Conversion.ToHash
       Cooked.Conversion.ToOutputDatum
       Cooked.Conversion.ToPubKeyHash
-      Cooked.Conversion.ToScript
       Cooked.Conversion.ToScriptHash
       Cooked.Conversion.ToValue
+      Cooked.Conversion.ToVersionedScript
       Cooked.Currencies
       Cooked.InitialDistribution
       Cooked.Ltl
       Cooked.MockChain
+      Cooked.MockChain.AutoReferenceScripts
       Cooked.MockChain.Balancing
       Cooked.MockChain.BlockChain
       Cooked.MockChain.Direct

src/Cooked/Conversion.hs

@@ -6,6 +6,6 @@ import Cooked.Conversion.ToCredential as X
 import Cooked.Conversion.ToHash as X
 import Cooked.Conversion.ToOutputDatum as X
 import Cooked.Conversion.ToPubKeyHash as X
-import Cooked.Conversion.ToScript as X
 import Cooked.Conversion.ToScriptHash as X
 import Cooked.Conversion.ToValue as X
+import Cooked.Conversion.ToVersionedScript as X

src/Cooked/Conversion/ToScriptHash.hs

@@ -1,7 +1,7 @@
 -- | Objects from which a script hash can be extracted
 module Cooked.Conversion.ToScriptHash where
 
-import Cooked.Conversion.ToScript
+import Cooked.Conversion.ToVersionedScript
 import Plutus.Script.Utils.Scripts qualified as Script
 import Plutus.Script.Utils.Typed qualified as Script
 import PlutusLedgerApi.V3 qualified as Api
@@ -22,10 +22,10 @@ instance ToScriptHash (Script.Versioned Script.Script) where
   toScriptHash = Script.scriptHash
 
 instance ToScriptHash (Script.Versioned Script.Validator) where
-  toScriptHash = toScriptHash . toScript
+  toScriptHash = toScriptHash . toVersionedScript
 
 instance ToScriptHash (Script.TypedValidator a) where
-  toScriptHash = toScriptHash . toScript
+  toScriptHash = toScriptHash . toVersionedScript
 
 instance ToScriptHash (Script.Versioned Script.MintingPolicy) where
-  toScriptHash = toScriptHash . Script.mintingPolicyHash
+  toScriptHash = toScriptHash . toVersionedScript

src/Cooked/Conversion/ToVersionedScript.hs

@@ -0,0 +1,20 @@
+-- | Objects from which a versioned script can be extracted
+module Cooked.Conversion.ToVersionedScript where
+
+import Plutus.Script.Utils.Scripts qualified as Script
+import Plutus.Script.Utils.Typed qualified as Script
+
+class ToVersionedScript a where
+  toVersionedScript :: a -> Script.Versioned Script.Script
+
+instance ToVersionedScript (Script.Versioned Script.Script) where
+  toVersionedScript = id
+
+instance ToVersionedScript (Script.Versioned Script.Validator) where
+  toVersionedScript (Script.Versioned (Script.Validator script) version) = Script.Versioned script version
+
+instance ToVersionedScript (Script.TypedValidator a) where
+  toVersionedScript = toVersionedScript . Script.vValidatorScript
+
+instance ToVersionedScript (Script.Versioned Script.MintingPolicy) where
+  toVersionedScript (Script.Versioned (Script.MintingPolicy script) version) = Script.Versioned script version

src/Cooked/MockChain/AutoReferenceScripts.hs

@@ -0,0 +1,64 @@
+-- | This module provides a function to ensure that each redeemer used in a
+-- skeleton is attached a reference scripts when a known utxos contains it.
+module Cooked.MockChain.AutoReferenceScripts (toTxSkelWithReferenceScripts) where
+
+import Control.Monad
+import Cooked.Conversion
+import Cooked.MockChain.BlockChain
+import Cooked.MockChain.UtxoSearch
+import Cooked.Output
+import Cooked.Skeleton
+import Data.Map qualified as Map
+import Data.Maybe
+import Optics.Core
+import PlutusLedgerApi.V3 qualified as Api
+
+-- | Searches through the known utxos for a utxo containing a reference script
+-- with a given script hash, and returns the first such utxo found, if any.
+retrieveReferenceScript :: (MonadBlockChain m, ToScriptHash s) => s -> m (Maybe Api.TxOutRef)
+retrieveReferenceScript script = listToMaybe . (fst <$>) <$> runUtxoSearch (referenceScriptOutputsSearch script)
+
+-- | Attempts to attach a reference script to a redeemer when it can be found in
+-- the context. Will not override any existing reference script. If this results
+-- in the addition of a reference script, will log the event.
+updateRedeemer :: (MonadBlockChain m, ToScriptHash s) => s -> TxSkelRedeemer -> m TxSkelRedeemer
+updateRedeemer script txSkelRed@(TxSkelRedeemer red Nothing) = do
+  oRefM <- retrieveReferenceScript script
+  case oRefM of
+    Nothing -> return txSkelRed
+    Just oRef -> do
+      logEvent $ MCLogAddedReferenceScript red oRef (toScriptHash script)
+      return $ TxSkelRedeemer red $ Just oRef
+updateRedeemer _ redeemer = return redeemer
+
+-- | Goes through the various parts of the skeleton where a redeemer can appear,
+-- and attempt to attach a reference script to each of them, following the rules
+-- from `updateRedeemer`
+toTxSkelWithReferenceScripts :: (MonadBlockChain m) => TxSkel -> m TxSkel
+toTxSkelWithReferenceScripts txSkel = do
+  newMints <- forM (txSkelMintsToList $ txSkel ^. txSkelMintsL) $ \(mPol, red, tk, nb) ->
+    (mPol,,tk,nb) <$> updateRedeemer mPol red
+  newInputs <- forM (Map.toList $ txSkel ^. txSkelInsL) $ \(oRef, red) -> do
+    outputM <- txOutByRef oRef
+    -- We retrieve the possible script hash of the current oRef
+    case (^. outputOwnerL) <$> (outputM >>= isScriptOutput) of
+      -- Either the txOutRef is unknown, or it belongs to a private key
+      Nothing -> return (oRef, red)
+      Just scriptHash -> (oRef,) <$> updateRedeemer scriptHash red
+  newProposals <- forM (txSkel ^. txSkelProposalsL) $ \prop ->
+    case prop ^. txSkelProposalWitnessL of
+      Nothing -> return prop
+      Just (script, red) -> flip (set txSkelProposalWitnessL) prop . Just . (script,) <$> updateRedeemer script red
+  newWithdrawals <- forM (Map.toList $ txSkel ^. txSkelWithdrawalsL) $ \(wit, (red, quantity)) -> case wit of
+    Right _ -> return (wit, (red, quantity))
+    Left script -> (Left script,) . (,quantity) <$> updateRedeemer script red
+  return $
+    txSkel
+      & txSkelMintsL
+      .~ txSkelMintsFromList newMints
+      & txSkelInsL
+      .~ Map.fromList newInputs
+      & txSkelProposalsL
+      .~ newProposals
+      & txSkelWithdrawalsL
+      .~ Map.fromList newWithdrawals

src/Cooked/MockChain/Balancing.hs

@@ -398,5 +398,5 @@ computeBalancedTxSkel balancingWallet balancingUtxos txSkel@TxSkel {..} (Script.
       -- a new output at the end of the list, to keep the order intact.
       (txOutRefs, val) <- getOptimalCandidate candidatesRaw balancingWallet balancingError
       return (txOutRefs, txSkelOuts ++ [paysPK balancingWallet val])
-  let newTxSkelIns = txSkelIns <> Map.fromList ((,txSkelEmptyRedeemer) <$> additionalInsTxOutRefs)
+  let newTxSkelIns = txSkelIns <> Map.fromList ((,emptyTxSkelRedeemer) <$> additionalInsTxOutRefs)
   return $ (txSkel & txSkelOutsL .~ newTxSkelOuts) & txSkelInsL .~ newTxSkelIns

src/Cooked/MockChain/BlockChain.hs

@@ -129,6 +129,8 @@ data MockChainLogEntry
     -- depending on whether the user has provided an explicit wallet or a set of
     -- utxos to be used as collaterals.
     MCLogUnusedCollaterals (Either Wallet (Set Api.TxOutRef))
+  | -- | Logging the automatic addition of a reference script
+    MCLogAddedReferenceScript Redeemer Api.TxOutRef Script.ScriptHash
 
 -- | Contains methods needed for balancing.
 class (MonadFail m, MonadError MockChainError m) => MonadBlockChainBalancing m where

src/Cooked/MockChain/Direct.hs

@@ -14,6 +14,7 @@ import Control.Monad.Reader
 import Control.Monad.State.Strict
 import Control.Monad.Writer
 import Cooked.InitialDistribution
+import Cooked.MockChain.AutoReferenceScripts
 import Cooked.MockChain.Balancing
 import Cooked.MockChain.BlockChain
 import Cooked.MockChain.GenerateTx
@@ -137,21 +138,24 @@ instance (Monad m) => MonadBlockChainWithoutValidation (MockChainT m) where
   awaitSlot s = modify' (\st -> st {mcstCurrentSlot = max s (mcstCurrentSlot st)}) >> currentSlot
 
 instance (Monad m) => MonadBlockChain (MockChainT m) where
-  validateTxSkel skelUnbal = do
+  validateTxSkel skelUnbal@TxSkel {..} | TxOpts {..} <- txSkelOpts = do
     -- We log the submitted skeleton
     gets mcstToSkelContext >>= logEvent . (`MCLogSubmittedTxSkel` skelUnbal)
     -- We retrieve the current parameters
     oldParams <- getParams
     -- We compute the optionally modified parameters
-    let newParams = applyEmulatorParamsModification (txOptEmulatorParamsModification . txSkelOpts $ skelUnbal) oldParams
+    let newParams = applyEmulatorParamsModification txOptEmulatorParamsModification oldParams
     -- We change the parameters for the duration of the validation process
     setParams newParams
     -- We ensure that the outputs have the required minimal amount of ada, when
     -- requested in the skeleton options
-    minAdaSkelUnbal <- if txOptEnsureMinAda . txSkelOpts $ skelUnbal then toTxSkelWithMinAda skelUnbal else return skelUnbal
+    minAdaSkelUnbal <- (if txOptEnsureMinAda then toTxSkelWithMinAda else return) skelUnbal
+    -- We add reference scripts in the various redeemers of the skeleton, when
+    -- they can be found in the index and are requested in the skeleton options
+    minAdaRefScriptsSkelUnbal <- (if txOptAutoReferenceScripts then toTxSkelWithReferenceScripts else return) minAdaSkelUnbal
     -- We balance the skeleton when requested in the skeleton option, and get
     -- the associated fee, collateral inputs and return collateral wallet
-    (skel, fee, mCollaterals) <- balanceTxSkel minAdaSkelUnbal
+    (skel, fee, mCollaterals) <- balanceTxSkel minAdaRefScriptsSkelUnbal
     -- We log the adjusted skeleton
     gets mcstToSkelContext >>= \ctx -> logEvent $ MCLogAdjustedTxSkel ctx skel fee mCollaterals
     -- We retrieve data that will be used in the transaction generation process:
@@ -169,7 +173,7 @@ instance (Monad m) => MonadBlockChain (MockChainT m) where
     cardanoTx <- case generateTx fee newParams hashedData (insMap <> refInsMap <> collateralInsMap) insValidators mCollaterals skel of
       Left err -> throwError . MCEGenerationError $ err
       -- We apply post-generation modification when applicable
-      Right tx -> return $ Ledger.CardanoEmulatorEraTx $ applyRawModOnBalancedTx (txOptUnsafeModTx . txSkelOpts $ skelUnbal) tx
+      Right tx -> return $ Ledger.CardanoEmulatorEraTx $ applyRawModOnBalancedTx txOptUnsafeModTx tx
     -- To run transaction validation we need a minimal ledger state
     eLedgerState <- gets mcstToEmulatedLedgerState
     -- We finally run the emulated validation, and we only care about the
@@ -203,8 +207,7 @@ instance (Monad m) => MonadBlockChain (MockChainT m) where
               . addValidators (txSkelValidatorsInOutputs skel <> txSkelReferenceScripts skel)
           )
     -- We apply a change of slot when requested in the options
-    when (txOptAutoSlotIncrease $ txSkelOpts skel) $
-      modify' (\st -> st {mcstCurrentSlot = mcstCurrentSlot st + 1})
+    when txOptAutoSlotIncrease $ modify' (\st -> st {mcstCurrentSlot = mcstCurrentSlot st + 1})
     -- We return the parameters to their original state
     setParams oldParams
     -- We log the validated transaction

src/Cooked/MockChain/GenerateTx/Output.hs

@@ -45,4 +45,4 @@ toCardanoTxOut (Pays output) = do
           <$> Ledger.toCardanoScriptDataHash (Script.datumHash $ Api.Datum $ Api.toBuiltinData datum)
     TxSkelOutDatum datum -> return $ Cardano.TxOutDatumInTx Cardano.AlonzoEraOnwardsConway $ toHashableScriptData datum
     TxSkelOutInlineDatum datum -> return $ Cardano.TxOutDatumInline Cardano.BabbageEraOnwardsConway $ toHashableScriptData datum
-  return $ Cardano.TxOut address value datum $ Ledger.toCardanoReferenceScript (toScript <$> oRefScript)
+  return $ Cardano.TxOut address value datum $ Ledger.toCardanoReferenceScript (toVersionedScript <$> oRefScript)

src/Cooked/MockChain/GenerateTx/Proposal.hs

@@ -133,7 +133,7 @@ toProposalProcedureAndWitness txSkelProposal@TxSkelProposal {..} anchorResolutio
   let conwayProposalProcedure = Conway.ProposalProcedure (Emulator.Coin minDeposit) cred govAction anchor
   (conwayProposalProcedure,) <$> case txSkelProposalWitness of
     Nothing -> return Nothing
-    Just (script, redeemer) -> Just <$> liftTxGen (toScriptWitness (toScript script) redeemer Cardano.NoScriptDatumForStake)
+    Just (script, redeemer) -> Just <$> liftTxGen (toScriptWitness (toVersionedScript script) redeemer Cardano.NoScriptDatumForStake)
 
 -- | Translates a list of skeleton proposals into a proposal procedures
 toProposalProcedures :: [TxSkelProposal] -> AnchorResolution -> ProposalGen (Cardano.TxProposalProcedures Cardano.BuildTx Cardano.ConwayEra)

src/Cooked/MockChain/GenerateTx/Witness.hs

@@ -41,8 +41,8 @@ toRewardAccount cred =
           (Ledger.toCardanoStakeKeyHash pubkeyHash)
       return $ Cardano.KeyHashObj pkHash
 
--- | Translate a script and a reference script utxo into into either a plutus
--- script or a reference input containing the right script
+-- | Translates a script and a reference script utxo into either a plutus script
+-- or a reference input containing the right script
 toPlutusScriptOrReferenceInput :: Script.Versioned Script.Script -> Maybe Api.TxOutRef -> WitnessGen (Cardano.PlutusScriptOrReferenceInput lang)
 toPlutusScriptOrReferenceInput (Script.Versioned (Script.Script script) _) Nothing = return $ Cardano.PScript $ Cardano.PlutusScriptSerialised script
 toPlutusScriptOrReferenceInput script (Just scriptOutRef) = do
@@ -66,18 +66,18 @@ toPlutusScriptOrReferenceInput script (Just scriptOutRef) = do
 
 -- | Translates a script with its associated redeemer and datum to a script
 -- witness.
-toScriptWitness :: (ToScript a) => a -> TxSkelRedeemer -> Cardano.ScriptDatum b -> WitnessGen (Cardano.ScriptWitness b Cardano.ConwayEra)
-toScriptWitness (toScript -> script@(Script.Versioned _ version)) (TxSkelRedeemer {..}) datum =
+toScriptWitness :: (ToVersionedScript a) => a -> TxSkelRedeemer -> Cardano.ScriptDatum b -> WitnessGen (Cardano.ScriptWitness b Cardano.ConwayEra)
+toScriptWitness (toVersionedScript -> script@(Script.Versioned _ version)) (TxSkelRedeemer {..}) datum =
   let scriptData = case txSkelRedeemer of
         EmptyRedeemer -> Ledger.toCardanoScriptData $ Api.toBuiltinData ()
         SomeRedeemer s -> Ledger.toCardanoScriptData $ Api.toBuiltinData s
    in case version of
         Script.PlutusV1 ->
           (\x -> Cardano.PlutusScriptWitness Cardano.PlutusScriptV1InConway Cardano.PlutusScriptV1 x datum scriptData Ledger.zeroExecutionUnits)
-            <$> toPlutusScriptOrReferenceInput script txSkelReferenceScript
+            <$> toPlutusScriptOrReferenceInput script txSkelReferenceInput
         Script.PlutusV2 ->
           (\x -> Cardano.PlutusScriptWitness Cardano.PlutusScriptV2InConway Cardano.PlutusScriptV2 x datum scriptData Ledger.zeroExecutionUnits)
-            <$> toPlutusScriptOrReferenceInput script txSkelReferenceScript
+            <$> toPlutusScriptOrReferenceInput script txSkelReferenceInput
         Script.PlutusV3 ->
           (\x -> Cardano.PlutusScriptWitness Cardano.PlutusScriptV3InConway Cardano.PlutusScriptV3 x datum scriptData Ledger.zeroExecutionUnits)
-            <$> toPlutusScriptOrReferenceInput script txSkelReferenceScript
+            <$> toPlutusScriptOrReferenceInput script txSkelReferenceInput

src/Cooked/MockChain/MockChainSt.hs

@@ -6,8 +6,8 @@ import Cardano.Ledger.Shelley.API qualified as Shelley
 import Cardano.Ledger.Shelley.LedgerState qualified as Shelley
 import Cardano.Node.Emulator.Internal.Node qualified as Emulator
 import Control.Arrow
-import Cooked.Conversion.ToScript
 import Cooked.Conversion.ToScriptHash
+import Cooked.Conversion.ToVersionedScript
 import Cooked.InitialDistribution
 import Cooked.MockChain.GenerateTx (GenerateTxError (..), generateTxOut)
 import Cooked.MockChain.UtxoState
@@ -178,7 +178,7 @@ referenceScriptMap0From (InitialDistribution initDist) =
     unitMaybeFrom :: TxSkelOut -> Maybe (Script.ValidatorHash, Script.Versioned Script.Validator)
     unitMaybeFrom (Pays output) = do
       refScript <- view outputReferenceScriptL output
-      let vScript@(Script.Versioned script version) = toScript refScript
+      let vScript@(Script.Versioned script version) = toVersionedScript refScript
           Api.ScriptHash scriptHash = toScriptHash vScript
       return (Script.ValidatorHash scriptHash, Script.Versioned (Script.Validator script) version)
 

src/Cooked/Pretty/Cooked.hs

@@ -155,13 +155,23 @@ instance PrettyCooked MockChainLogEntry where
   prettyCookedOpt opts (MCLogNewTx txId) = "New transaction:" <+> prettyCookedOpt opts txId
   prettyCookedOpt opts (MCLogDiscardedUtxos n s) = prettyCookedOpt opts n <+> "balancing utxos were discarded:" <+> PP.pretty s
   prettyCookedOpt opts (MCLogUnusedCollaterals (Left cWallet)) =
-    "Specific request to fetch collateral utxos from"
-      <+> prettyCookedOpt opts (walletPKHash cWallet)
-      <+> "has been disregarded because the transaction does not require collaterals"
+    "Specific request to fetch collateral utxos from "
+      <> prettyCookedOpt opts (walletPKHash cWallet)
+      <> " has been disregarded because the transaction does not require collaterals"
   prettyCookedOpt opts (MCLogUnusedCollaterals (Right (length -> n))) =
-    "Specific request to fetch collateral utxos from the given set of"
-      <+> prettyCookedOpt opts n
-      <+> "elements has been disregarded because the transaction does not require collaterals"
+    "Specific request to fetch collateral utxos from the given set of "
+      <> prettyCookedOpt opts n
+      <> " elements has been disregarded because the transaction does not require collaterals"
+  prettyCookedOpt opts (MCLogAddedReferenceScript red oRef sHash) =
+    "A reference script sitting at "
+      <> prettyCookedOpt opts oRef
+      <> " has been automatically associated to redeemer "
+      <> ( case red of
+             EmptyRedeemer -> "Empty"
+             SomeRedeemer s -> prettyCookedOpt opts s
+         )
+      <> " for script "
+      <> prettyCookedOpt opts sHash
 
 prettyTxSkel :: PrettyCookedOpts -> SkelContext -> TxSkel -> DocCooked
 prettyTxSkel opts skelContext (TxSkel lbl txopts mints signers validityRange ins insReference outs proposals withdrawals) =