Audit changes

CHANGELOG.md

@@ -15,6 +15,8 @@
 - `validatorToTypedValidatorV2`
 - `walletPKHashToWallet` that retrives a wallet from a pkh. It used to be
   present but somehow disapeared.
+- It is now possible to reference an output which has a hashed datum.
+- `txSkelHashedData` the gives all the datum hashes in inputs and reference inputs.
 
 ### Removed
 
@@ -29,6 +31,11 @@
   `txSkelSomeRedeemerAndReferenceScript`,
   `txSkelEmptyRedeemerAndReferenceScript`.
 - `mkProposingScript` changed to `mkScript`
+- `withDatumHashed` changed to `withUnresolvedDatumHash`
+- `paysScriptDatumHashed` changed to `paysScriptUnresolvedDatumHash`
+- `txSkelInputData` changed to `txSkelConsumedData`
+- Pretty printing of hashed datum now includes the hash (and not only the
+  resolved datum).
 
 ### Fixed
 

cooked-validators.cabal

@@ -110,6 +110,7 @@ library
     , cardano-api
     , cardano-crypto
     , cardano-data
+    , cardano-ledger-alonzo
     , cardano-ledger-conway
     , cardano-ledger-core
     , cardano-ledger-shelley
@@ -203,6 +204,7 @@ test-suite spec
     , cardano-api
     , cardano-crypto
     , cardano-data
+    , cardano-ledger-alonzo
     , cardano-ledger-conway
     , cardano-ledger-core
     , cardano-ledger-shelley

package.yaml

@@ -11,6 +11,7 @@ dependencies:
   - cardano-api
   - cardano-crypto
   - cardano-data
+  - cardano-ledger-alonzo
   - cardano-ledger-core
   - cardano-ledger-shelley
   - cardano-ledger-conway

src/Cooked/MockChain/Balancing.hs

@@ -260,7 +260,7 @@ estimateTxSkelFee :: (MonadBlockChainBalancing m) => TxSkel -> Fee -> Collateral
 estimateTxSkelFee skel fee collateralIns returnCollateralWallet = do
   -- We retrieve the necessary data to generate the transaction body
   params <- getParams
-  managedData <- txSkelInputData skel
+  managedData <- txSkelHashedData skel
   managedTxOuts <- lookupUtxosPl $ txSkelKnownTxOutRefs skel <> Set.toList collateralIns
   managedValidators <- txSkelInputValidators skel
   -- We generate the transaction body content, handling errors in the meantime

src/Cooked/MockChain/BlockChain.hs

@@ -45,7 +45,8 @@ module Cooked.MockChain.BlockChain
     txSkelReferenceInputUtxos,
     txSkelInputValidators,
     txSkelInputValue,
-    txSkelInputData,
+    txSkelHashedData,
+    txSkelConsumedData,
     lookupUtxos,
     lookupUtxosPl,
     validateTxSkel',
@@ -340,28 +341,40 @@ lookupUtxos =
 txSkelInputValue :: (MonadBlockChainBalancing m) => TxSkel -> m Api.Value
 txSkelInputValue = (foldMap (Api.txOutValue . txOutV2FromLedger) <$>) . txSkelInputUtxos
 
--- | Look up the data on UTxOs the transaction consumes.
-txSkelInputData :: (MonadBlockChainBalancing m) => TxSkel -> m (Map Api.DatumHash Api.Datum)
-txSkelInputData skel = do
-  mDatumHashes <-
-    mapMaybe
-      ( \output ->
-          case output ^. outputDatumL of
-            Api.NoOutputDatum -> Nothing
-            Api.OutputDatum datum -> Just $ Script.datumHash datum
-            Api.OutputDatumHash dHash -> Just dHash
-      )
-      . Map.elems
-      <$> txSkelInputUtxosPl skel
-  Map.fromList
-    <$> mapM
-      ( \dHash ->
+-- | Looks up and resolves the hashed datums on UTxOs the transaction consumes
+-- or references, which will be needed by the transaction body.
+txSkelHashedData :: (MonadBlockChainBalancing m) => TxSkel -> m (Map Api.DatumHash Api.Datum)
+txSkelHashedData skel = do
+  let outputToDatumHashM output = case output ^. outputDatumL of
+        Api.OutputDatumHash dHash -> Just dHash
+        _ -> Nothing
+  (Map.elems -> inputTxOuts) <- txSkelInputUtxosPl skel
+  (Map.elems -> refInputTxOuts) <- txSkelReferenceInputUtxosPl skel
+  foldM
+    ( \dat dHash ->
+        maybeErrM
+          (MCEUnknownDatum "txSkelHashedData: Transaction input with unknown datum hash" dHash)
+          (\rDat -> Map.insert dHash rDat dat)
+          (datumFromHash dHash)
+    )
+    Map.empty
+    (mapMaybe outputToDatumHashM $ inputTxOuts <> refInputTxOuts)
+
+-- | Looks us the data on UTxOs the transaction consumes. This corresponds to
+-- the keys of what should be removed from the stored datums in our mockchain.
+-- There can be duplicates, which is expected.
+txSkelConsumedData :: (MonadBlockChainBalancing m) => TxSkel -> m [Api.DatumHash]
+txSkelConsumedData skel = do
+  let outputToDatumHashM output = case output ^. outputDatumL of
+        Api.OutputDatumHash dHash ->
           maybeErrM
-            (MCEUnknownDatum "txSkelInputData: Transaction input with un-resolvable datum hash" dHash)
-            (dHash,)
+            (MCEUnknownDatum "txSkelConsumedData: Transaction input with unknown datum hash" dHash)
+            (Just . const dHash)
             (datumFromHash dHash)
-      )
-      mDatumHashes
+        Api.OutputDatum datum -> return $ Just $ Script.datumHash datum
+        Api.NoOutputDatum -> return Nothing
+  (Map.elems -> inputTxOuts) <- txSkelInputUtxosPl skel
+  catMaybes <$> mapM outputToDatumHashM inputTxOuts
 
 -- ** Slot and Time Management
 

src/Cooked/MockChain/Direct.hs

@@ -170,15 +170,16 @@ instance (Monad m) => MonadBlockChain (MockChainT m) where
     -- We retrieve data that will be used in the transaction generation process:
     -- datums, validators and various kinds of inputs. This idea is to provide a
     -- rich-enough context for the transaction generation to succeed.
-    insData <- txSkelInputData skel
+    hashedData <- txSkelHashedData skel
+    insData <- txSkelConsumedData skel
     insValidators <- txSkelInputValidators skel
     insMap <- txSkelInputUtxosPl skel
     refInsMap <- txSkelReferenceInputUtxosPl skel
     collateralInsMap <- lookupUtxosPl $ Set.toList collateralIns
     -- We attempt to generate the transaction associated with the balanced
     -- skeleton and the retrieved data. This is an internal generation, there is
     -- no validation involved yet.
-    cardanoTx <- case generateTx fee returnCollateralWallet collateralIns newParams insData (insMap <> refInsMap <> collateralInsMap) insValidators skel of
+    cardanoTx <- case generateTx fee returnCollateralWallet collateralIns newParams hashedData (insMap <> refInsMap <> collateralInsMap) insValidators skel of
       Left err -> throwError . MCEGenerationError $ err
       -- We apply post-generation modification when applicable
       Right tx -> return $ Ledger.CardanoEmulatorEraTx $ applyRawModOnBalancedTx (txOptUnsafeModTx . txSkelOpts $ skelUnbal) tx
@@ -210,8 +211,8 @@ instance (Monad m) => MonadBlockChain (MockChainT m) where
       -- Otherwise, we update known validators and datums.
       Nothing ->
         modify'
-          ( removeDatums (Map.keys insData)
-              . addDatums (Map.toList $ txSkelDataInOutputs skel)
+          ( removeDatums insData
+              . addDatums (txSkelDataInOutputs skel)
               . addValidators (txSkelValidatorsInOutputs skel <> txSkelReferenceScripts skel)
           )
     -- We apply a change of slot when requested in the options

src/Cooked/MockChain/GenerateTx/Body.hs

@@ -1,7 +1,14 @@
 module Cooked.MockChain.GenerateTx.Body where
 
 import Cardano.Api qualified as Cardano
+import Cardano.Api.Shelley qualified as Cardano
+import Cardano.Ledger.Alonzo.Tx qualified as Alonzo
+import Cardano.Ledger.Alonzo.TxBody qualified as Alonzo
+import Cardano.Ledger.Alonzo.TxWits qualified as Alonzo
+import Cardano.Ledger.Conway.PParams qualified as Conway
+import Cardano.Ledger.Plutus qualified as Cardano
 import Cardano.Node.Emulator.Internal.Node qualified as Emulator
+import Control.Lens qualified as Lens
 import Control.Monad
 import Control.Monad.Reader
 import Cooked.MockChain.GenerateTx.Collateral qualified as Collateral
@@ -12,10 +19,11 @@ import Cooked.MockChain.GenerateTx.Output qualified as Output
 import Cooked.MockChain.GenerateTx.Proposal qualified as Proposal
 import Cooked.Skeleton
 import Cooked.Wallet
-import Data.Bifunctor
+import Data.Either.Combinators
 import Data.Map (Map)
 import Data.Map qualified as Map
 import Data.Set (Set)
+import Data.Set qualified as Set
 import Ledger.Address qualified as Ledger
 import Ledger.Tx qualified as Ledger
 import Ledger.Tx.CardanoAPI qualified as Ledger
@@ -86,8 +94,8 @@ txSkelToBodyContent skel@TxSkel {..} | txSkelReferenceInputs <- txSkelReferenceT
   let txMetadata = Cardano.TxMetadataNone -- That's what plutus-apps does as well
       txAuxScripts = Cardano.TxAuxScriptsNone -- That's what plutus-apps does as well
       txWithdrawals = Cardano.TxWithdrawalsNone -- That's what plutus-apps does as well
-      txCertificates = Cardano.TxCertificatesNone -- That's what plutus-apps does as well
       txUpdateProposal = Cardano.TxUpdateProposalNone -- That's what plutus-apps does as well
+      txCertificates = Cardano.TxCertificatesNone -- That's what plutus-apps does as well
       txScriptValidity = Cardano.TxScriptValidityNone -- That's what plutus-apps does as well
       txVotingProcedures = Nothing -- TODO, same as above
   return Cardano.TxBodyContent {..}
@@ -97,17 +105,50 @@ txSkelToBodyContent skel@TxSkel {..} | txSkelReferenceInputs <- txSkelReferenceT
 txSkelToCardanoTx :: TxSkel -> BodyGen (Cardano.Tx Cardano.ConwayEra)
 txSkelToCardanoTx txSkel = do
   txBodyContent <- txSkelToBodyContent txSkel
-  cardanoTxUnsigned <-
-    lift $
-      bimap
-        (TxBodyError "generateTx: ")
-        (`Cardano.Tx` [])
-        (Cardano.createAndValidateTransactionBody Cardano.ShelleyBasedEraConway txBodyContent)
-  foldM
-    ( \tx wal ->
-        case Ledger.addCardanoTxWitness (Ledger.toWitness $ Ledger.PaymentPrivateKey $ walletSK wal) (Ledger.CardanoTx tx Cardano.ShelleyBasedEraConway) of
-          Ledger.CardanoTx tx' Cardano.ShelleyBasedEraConway -> return tx'
-          _ -> throwOnString "txSkelToCardanoTx: Wrong output era"
-    )
-    cardanoTxUnsigned
-    (txSkelSigners txSkel)
+
+  -- We create the associated Shelley TxBody
+  txBody@(Cardano.ShelleyTxBody a body c dats e f) <-
+    lift $ mapLeft (TxBodyError "generateTx :") $ Cardano.createAndValidateTransactionBody Cardano.ShelleyBasedEraConway txBodyContent
+
+  -- There is a chance that the body is in need of additional data. This happens
+  -- when the set of reference inputs contains hashed datums that will need to
+  -- be resolved during phase 2 validation. All that follows until the
+  -- definition of "txBody'" aims at doing just that. In the process, we have to
+  -- reconstruct the body with the new data and the associated hash. Hopefully,
+  -- in the future, cardano-api provides a way to add those data in the body
+  -- directly without requiring this methods, which somewhat feels like a hack.
+  mData <- asks managedData
+  mTxOut <- asks managedTxOuts
+  refIns <- forM (txSkelReferenceTxOutRefs txSkel) $ \oRef ->
+    throwOnLookup ("txSkelToCardanoTx: Unable to resolve TxOutRef " <> show oRef) oRef mTxOut
+  let datumHashes = [hash | (Api.TxOut _ _ (Api.OutputDatumHash hash) _) <- refIns]
+  additionalData <- forM datumHashes $ \dHash ->
+    throwOnLookup ("txSkelToCardanoTx: Unable to resolve datum hash " <> show dHash) dHash mData
+  let additionalDataMap = Map.fromList [(Cardano.hashData dat, dat) | Api.Datum (Cardano.Data . Api.toData -> dat) <- additionalData]
+  toLangDepViewParam <- asks (Conway.getLanguageView . Cardano.unLedgerProtocolParameters . Emulator.ledgerProtocolParameters . params)
+  let txDats' = Alonzo.TxDats additionalDataMap
+      (era, datums, redeemers) = case dats of
+        Cardano.TxBodyNoScriptData -> (Cardano.AlonzoEraOnwardsConway, txDats', Alonzo.Redeemers Map.empty)
+        Cardano.TxBodyScriptData era' txDats reds -> (era', txDats <> txDats', reds)
+      witnesses = Cardano.collectTxBodyScriptWitnesses Cardano.ShelleyBasedEraConway txBodyContent
+      languages = [toCardanoLanguage v | (_, Cardano.AnyScriptWitness (Cardano.PlutusScriptWitness _ v _ _ _ _)) <- witnesses]
+      scriptIntegrityHash =
+        Cardano.alonzoEraOnwardsConstraints era $
+          Alonzo.hashScriptIntegrity (Set.fromList $ toLangDepViewParam <$> languages) redeemers datums
+      body' = body Lens.& Alonzo.scriptIntegrityHashTxBodyL Lens..~ scriptIntegrityHash
+      txBody' = Cardano.ShelleyTxBody a body' c (Cardano.TxBodyScriptData era datums redeemers) e f
+
+  -- We return the transaction signed by all the required signers. The body is
+  -- chosen based on whether or not it required additional data.
+  return $
+    Ledger.getEmulatorEraTx $
+      foldl
+        (flip Ledger.addCardanoTxWitness)
+        (Ledger.CardanoEmulatorEraTx $ Cardano.Tx (if null additionalDataMap then txBody else txBody') [])
+        (Ledger.toWitness . Ledger.PaymentPrivateKey . walletSK <$> txSkelSigners txSkel)
+  where
+    toCardanoLanguage :: Cardano.PlutusScriptVersion lang -> Cardano.Language
+    toCardanoLanguage = \case
+      Cardano.PlutusScriptV1 -> Cardano.PlutusV1
+      Cardano.PlutusScriptV2 -> Cardano.PlutusV2
+      Cardano.PlutusScriptV3 -> Cardano.PlutusV3

src/Cooked/Pretty/Cooked.hs

@@ -355,9 +355,12 @@ prettyTxSkelOut opts (Pays output) =
                   "Datum (inlined):"
                     <+> (PP.align . prettyCookedOpt opts)
                       (output ^. outputDatumL)
-              Api.OutputDatumHash _datum ->
+              Api.OutputDatumHash dHash ->
                 Just $
-                  "Datum (hashed):"
+                  "Datum (hashed)"
+                    <+> "("
+                    <> prettyHash (pcOptHashes opts) (toHash dHash)
+                    <> "):"
                     <+> (PP.align . prettyCookedOpt opts)
                       (output ^. outputDatumL)
               Api.NoOutputDatum -> Nothing,
@@ -371,9 +374,19 @@ prettyTxSkelOutDatumMaybe opts txSkelOutDatum@(TxSkelOutInlineDatum _) =
   Just $
     "Datum (inlined):"
       <+> PP.align (prettyCookedOpt opts txSkelOutDatum)
-prettyTxSkelOutDatumMaybe opts txSkelOutDatum =
+prettyTxSkelOutDatumMaybe opts txSkelOutDatum@(TxSkelOutDatumHash dat) =
   Just $
-    "Datum (hashed):"
+    "Datum (hashed)"
+      <+> "("
+      <> prettyHash (pcOptHashes opts) (toHash $ Script.datumHash $ Api.Datum $ Api.toBuiltinData dat)
+      <> "):"
+      <+> PP.align (prettyCookedOpt opts txSkelOutDatum)
+prettyTxSkelOutDatumMaybe opts txSkelOutDatum@(TxSkelOutDatum dat) =
+  Just $
+    "Datum (hashed)"
+      <+> "("
+      <> prettyHash (pcOptHashes opts) (toHash $ Script.datumHash $ Api.Datum $ Api.toBuiltinData dat)
+      <> "):"
       <+> PP.align (prettyCookedOpt opts txSkelOutDatum)
 
 prettyTxSkelIn :: PrettyCookedOpts -> SkelContext -> (Api.TxOutRef, TxSkelRedeemer) -> DocCooked

src/Cooked/Skeleton.hs

@@ -49,11 +49,11 @@ module Cooked.Skeleton
     paysPK,
     paysScript,
     paysScriptInlineDatum,
-    paysScriptDatumHash,
+    paysScriptUnresolvedDatumHash,
     paysScriptNoDatum,
     withDatum,
     withInlineDatum,
-    withDatumHash,
+    withUnresolvedDatumHash,
     withReferenceScript,
     withStakingCredential,
     TxSkelRedeemer (..),
@@ -870,8 +870,9 @@ paysPK pkh value =
         (Nothing @(Script.Versioned Script.Script))
     )
 
--- | Pays a script a certain value with a certain datum, using the
+-- | Pays a script a certain value with a certain datum hash, using the
 -- 'TxSkelOutDatum' constructor. (See the documentation of 'TxSkelOutDatum'.)
+-- The datum is resolved in the transaction.
 paysScript ::
   ( Api.ToData (Script.DatumType a),
     Show (Script.DatumType a),
@@ -917,9 +918,9 @@ paysScriptInlineDatum validator datum value =
         (Nothing @(Script.Versioned Script.Script))
     )
 
--- | Pays a script a certain value with a certain hashed (not resolved in
--- transaction) datum.
-paysScriptDatumHash ::
+-- | Pays a script a certain value with a certain hashed datum which is not
+-- resolved in the transaction (as opposed to "paysScript").
+paysScriptUnresolvedDatumHash ::
   ( Api.ToData (Script.DatumType a),
     Show (Script.DatumType a),
     Typeable (Script.DatumType a),
@@ -931,7 +932,7 @@ paysScriptDatumHash ::
   Script.DatumType a ->
   Api.Value ->
   TxSkelOut
-paysScriptDatumHash validator datum value =
+paysScriptUnresolvedDatumHash validator datum value =
   Pays
     ( ConcreteOutput
         validator
@@ -942,7 +943,7 @@ paysScriptDatumHash validator datum value =
     )
 
 -- | Pays a script a certain value without any datum. Intended to be used with
--- 'withDatum', 'withDatumHash', or 'withInlineDatum' to try a datum whose type
+-- 'withDatum', 'withUnresolvedDatumHash', or 'withInlineDatum' to try a datum whose type
 -- does not match the validator's.
 paysScriptNoDatum :: (Typeable a) => Script.TypedValidator a -> Api.Value -> TxSkelOut
 paysScriptNoDatum validator value =
@@ -968,8 +969,8 @@ withInlineDatum (Pays output) datum = Pays $ (fromAbstractOutput output) {concre
 -- | Set the datum in a payment to the given hashed (not resolved in the
 -- transaction) datum (whose type may not fit the typed validator in case of a
 -- script).
-withDatumHash :: (Api.ToData a, Show a, Typeable a, PlutusTx.Eq a, PrettyCooked a) => TxSkelOut -> a -> TxSkelOut
-withDatumHash (Pays output) datum = Pays $ (fromAbstractOutput output) {concreteOutputDatum = TxSkelOutDatumHash datum}
+withUnresolvedDatumHash :: (Api.ToData a, Show a, Typeable a, PlutusTx.Eq a, PrettyCooked a) => TxSkelOut -> a -> TxSkelOut
+withUnresolvedDatumHash (Pays output) datum = Pays $ (fromAbstractOutput output) {concreteOutputDatum = TxSkelOutDatumHash datum}
 
 -- | Add a reference script to a transaction output (or replace it if there is
 -- already one)
@@ -1058,18 +1059,19 @@ data SkelContext = SkelContext
 txSkelValueInOutputs :: TxSkel -> Api.Value
 txSkelValueInOutputs = foldOf (txSkelOutsL % folded % txSkelOutValueL)
 
--- | Return all data on transaction outputs.
-txSkelDataInOutputs :: TxSkel -> Map Api.DatumHash TxSkelOutDatum
+-- | Return all data on transaction outputs. This can contain duplicates, which
+-- is intended.
+txSkelDataInOutputs :: TxSkel -> [(Api.DatumHash, TxSkelOutDatum)]
 txSkelDataInOutputs =
   foldMapOf
     ( txSkelOutsL
         % folded
         % txSkelOutDatumL
     )
-    ( \txSkelOutDatum -> do
+    ( \txSkelOutDatum ->
         maybe
-          Map.empty
-          (\datum -> Map.singleton (Script.datumHash datum) txSkelOutDatum)
+          []
+          (\datum -> [(Script.datumHash datum, txSkelOutDatum)])
           (txSkelOutUntypedDatum txSkelOutDatum)
     )
 

tests/Cooked/BalancingSpec.hs

@@ -40,7 +40,7 @@ initialDistributionBalancing =
       paysPK alice (Script.ada 30),
       paysPK alice (Script.lovelace 1280229 <> banana 3) `withDatum` (10 :: Integer),
       paysPK alice (Script.ada 1 <> banana 7) `withReferenceScript` (alwaysTrueValidator @MockContract),
-      paysPK alice (Script.ada 105 <> banana 2) `withDatumHash` ()
+      paysPK alice (Script.ada 105 <> banana 2) `withUnresolvedDatumHash` ()
     ]
 
 type TestBalancingOutcome = (TxSkel, TxSkel, Integer, Set Api.TxOutRef, [Api.TxOutRef])