SCP-3845: Create new plutus-script-utils package with script data and…

… script hashing functions along with typed plutus script wrappers. (#447)

cabal.project

@@ -14,6 +14,7 @@ packages: doc
           plutus-pab
           plutus-pab-executables
           plutus-playground-server
+          plutus-script-utils
           plutus-use-cases
           quickcheck-dynamic
           web-ghc
@@ -38,6 +39,19 @@ constraints:
      -- TODO: Try to remove on next `cardano-node` version upgrade.
      hedgehog >= 1.0.2 && < 1.1
 
+-- The plugin will typically fail when producing Haddock documentation. However,
+-- in this instance you can simply tell it to defer any errors to runtime (which
+-- will never happen since you're building documentation).
+--
+-- So, any package using 'PlutusTx.compile' in the code for which you need to
+-- generate haddock documentation should use the following 'haddock-options'.
+package plutus-ledger
+  haddock-options: "--optghc=-fplugin-opt PlutusTx.Plugin:defer-errors"
+package plutus-script-utils
+  haddock-options: "--optghc=-fplugin-opt PlutusTx.Plugin:defer-errors"
+package plutus-contract
+  haddock-options: "--optghc=-fplugin-opt PlutusTx.Plugin:defer-errors"
+
 -- These packages appear in our dependency tree and are very slow to build.
 -- Empirically, turning off optimization shaves off ~50% build time.
 -- It also mildly improves recompilation avoidance.

config.yaml

@@ -0,0 +1 @@
+{"cicPort":9083,"cicSocketPath":"/home/kolam/.local/share/Daedalus/testnet/cardano-node.socket","cicAppendTransactionQueueSize":10000,"cicSecurityParam":2160,"cicDbPath":"/tmp/cardano-node/testnet/chain-index.db","cicNetworkId":{"contents":{"unNetworkMagic":1097911063},"tag":"Testnet"},"cicStoreFrom":{"unBlockNo":3200000},"cicSlotConfig":{"scSlotLength":1000,"scSlotZeroTime":1596059091000}}

doc/plutus-doc.cabal

@@ -75,6 +75,7 @@ executable doc-doctests
       plutus-ledger -any,
       plutus-ledger-api -any,
       plutus-ledger-constraints -any,
+      plutus-script-utils -any,
       plutus-contract -any,
       playground-common -any,
       plutus-use-cases -any,

doc/plutus/tutorials/BasicApps.hs

@@ -66,7 +66,7 @@ splitValidator :: Scripts.TypedValidator Split
 splitValidator = Scripts.mkTypedValidator @Split
     $$(PlutusTx.compile [|| validateSplit ||])
     $$(PlutusTx.compile [|| wrap ||]) where
-        wrap = Scripts.wrapValidator @SplitData @()
+        wrap = Scripts.mkUntypedValidator @SplitData @()
 
 -- BLOCK4
 

doc/plutus/tutorials/BasicPolicies.hs

@@ -32,10 +32,10 @@ oneAtATimePolicy _ ctx =
     in Value.valueOf minted ownSymbol tname PlutusTx.== 1
 
 -- We can use 'compile' to turn a minting policy into a compiled Plutus Core program,
--- just as for validator scripts. We also provide a 'wrapMintingPolicy' function
+-- just as for validator scripts. We also provide a 'mkUntypedMintingPolicy' function
 -- to handle the boilerplate.
 oneAtATimeCompiled :: PlutusTx.CompiledCode (PlutusTx.BuiltinData -> PlutusTx.BuiltinData -> ())
-oneAtATimeCompiled = $$(PlutusTx.compile [|| Typed.wrapMintingPolicy oneAtATimePolicy ||])
+oneAtATimeCompiled = $$(PlutusTx.compile [|| Typed.mkUntypedMintingPolicy oneAtATimePolicy ||])
 -- BLOCK2
 singleSignerPolicy :: Ledger.ScriptContext -> PlutusTx.Bool
 singleSignerPolicy ctx = Ledger.txSignedBy (Ledger.scriptContextTxInfo ctx) key

doc/plutus/tutorials/BasicValidators.hs

@@ -15,6 +15,7 @@ import Ledger qualified
 import Ledger.Ada qualified as Ada
 import Ledger.Typed.Scripts qualified as Typed
 import Ledger.Value qualified as Value
+import Plutus.V1.Ledger.Api qualified as Ledger
 
 import Data.ByteString qualified as BS
 import Data.ByteString.Lazy qualified as BSL
@@ -92,17 +93,17 @@ validateDateTyped :: EndDate -> Date -> Ledger.ScriptContext -> Bool
 validateDateTyped endDate date _ = beforeEnd date endDate
 
 validateDateWrapped :: BuiltinData -> BuiltinData -> BuiltinData -> ()
-validateDateWrapped = Typed.wrapValidator validateDateTyped
+validateDateWrapped = Typed.mkUntypedValidator validateDateTyped
 -- BLOCK7
 dateInstance :: Typed.TypedValidator DateValidator
 dateInstance = Typed.mkTypedValidator @DateValidator
     -- The first argument is the compiled validator.
     $$(PlutusTx.compile [|| validateDateTyped ||])
     -- The second argument is a compiled wrapper.
-    -- Unfortunately we can't just inline wrapValidator here for technical reasons.
+    -- Unfortunately we can't just inline mkUntypedValidator here for technical reasons.
     $$(PlutusTx.compile [|| wrap ||])
     where
-        wrap = Typed.wrapValidator
+        wrap = Typed.mkUntypedValidator
 
 dateValidatorHash :: Ledger.ValidatorHash
 dateValidatorHash = Typed.validatorHash dateInstance

doc/plutus/tutorials/Escrow2.hs

@@ -24,12 +24,13 @@ import Data.Foldable (fold)
 import Data.Map (Map)
 import Data.Map qualified as Map
 
-import Ledger (Datum, minAdaTxOut)
+import Ledger (minAdaTxOut)
 import Ledger.Ada qualified as Ada
 import Ledger.Value qualified as Value
 import Plutus.Contract (Contract, selectList)
 import Plutus.Contract.Test (Wallet, mockWalletPaymentPubKeyHash, w1, w2, w3, w4, w5)
 import Plutus.Contract.Test.ContractModel qualified as CM
+import Plutus.V1.Ledger.Api (Datum)
 
 import Plutus.Contracts.Tutorial.Escrow (EscrowError, EscrowParams (EscrowParams, escrowTargets), EscrowSchema, payEp,
                                          payToPaymentPubKeyTarget, redeemEp)

doc/plutus/tutorials/Escrow3.hs

@@ -23,12 +23,13 @@ import Data.Foldable (fold)
 import Data.Map (Map)
 import Data.Map qualified as Map
 
-import Ledger (Datum, minAdaTxOut)
+import Ledger (minAdaTxOut)
 import Ledger.Ada qualified as Ada
 import Ledger.Value qualified as Value
 import Plutus.Contract (Contract, selectList)
 import Plutus.Contract.Test (Wallet, mockWalletPaymentPubKeyHash, w1, w2, w3, w4, w5)
 import Plutus.Contract.Test.ContractModel qualified as CM
+import Plutus.V1.Ledger.Api (Datum)
 
 import Plutus.Contracts.Tutorial.Escrow (EscrowError, EscrowParams (EscrowParams, escrowTargets), EscrowSchema, payEp,
                                          payToPaymentPubKeyTarget, redeemEp, refundEp)

doc/plutus/tutorials/Escrow4.hs

@@ -24,12 +24,13 @@ import Data.Foldable (fold)
 import Data.Map (Map)
 import Data.Map qualified as Map
 
-import Ledger (Datum, POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
+import Ledger (POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
 import Ledger.Ada qualified as Ada
 import Ledger.Value qualified as Value
 import Plutus.Contract (Contract, selectList)
 import Plutus.Contract.Test (Wallet, mockWalletPaymentPubKeyHash, w1, w2, w3, w4, w5)
 import Plutus.Contract.Test.ContractModel qualified as CM
+import Plutus.V1.Ledger.Api (Datum)
 
 import Plutus.Trace.Emulator qualified as Trace
 import PlutusTx.Monoid (inv)

doc/plutus/tutorials/Escrow5.hs

@@ -24,12 +24,13 @@ import Data.Foldable (fold)
 import Data.Map (Map)
 import Data.Map qualified as Map
 
-import Ledger (Datum, POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
+import Ledger (POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
 import Ledger.Ada qualified as Ada
 import Ledger.Value qualified as Value
 import Plutus.Contract (Contract, selectList)
 import Plutus.Contract.Test (Wallet, mockWalletPaymentPubKeyHash, w1, w2, w3, w4, w5)
 import Plutus.Contract.Test.ContractModel qualified as CM
+import Plutus.V1.Ledger.Api (Datum)
 
 import Plutus.Trace.Emulator qualified as Trace
 import PlutusTx.Monoid (inv)

doc/plutus/tutorials/Escrow6.hs

@@ -32,20 +32,22 @@ import Data.Foldable (fold)
 import Data.Map (Map)
 import Data.Map qualified as Map
 
-import Ledger (Datum, POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
+import Ledger (POSIXTime (POSIXTime), Slot (Slot, getSlot), minAdaTxOut)
 import Ledger.Ada qualified as Ada
 import Ledger.Value qualified as Value
 import Plutus.Contract (Contract, selectList)
 import Plutus.Contract.Test (Wallet, mockWalletPaymentPubKeyHash, w1, w2, w3, w4, w5)
 import Plutus.Contract.Test.ContractModel qualified as CM
+import Plutus.V1.Ledger.Api (Datum)
 
 import Plutus.Trace.Emulator qualified as Trace
 import PlutusTx.Monoid (inv)
 
 import Data.Default (Default (def))
 import Ledger.TimeSlot (SlotConfig (scSlotLength), scSlotZeroTime)
 import Plutus.Contract.Test.ContractModel (SomeContractInstanceKey (Key), coverageIndex, currentSlot,
-                                           defaultCoverageOptions)
+                                           defaultCheckOptionsContractModel, defaultCoverageOptions,
+                                           propRunActionsWithOptions, quickCheckWithCoverage)
 import Plutus.Contract.Test.ContractModel.CrashTolerance (CrashTolerance (available, restartArguments),
                                                           WithCrashTolerance)
 import Plutus.Contract.Test.Coverage (writeCoverageReport)

doc/plutus/tutorials/EscrowImpl.hs

@@ -53,19 +53,20 @@ import Control.Monad.Error.Lens (throwing)
 import Data.Aeson (FromJSON, ToJSON)
 import GHC.Generics (Generic)
 
-import Ledger (Datum (Datum), DatumHash, POSIXTime, PaymentPubKeyHash (unPaymentPubKeyHash),
-               ScriptContext (ScriptContext, scriptContextTxInfo), TxId, ValidatorHash, getCardanoTxId, interval,
-               scriptOutputsAt, txSignedBy, valuePaidTo)
+import Ledger (POSIXTime, PaymentPubKeyHash (unPaymentPubKeyHash), ScriptContext (ScriptContext, scriptContextTxInfo),
+               TxId, getCardanoTxId, interval, scriptOutputsAt, txSignedBy, valuePaidTo)
 import Ledger qualified
 import Ledger.Constraints (TxConstraints)
 import Ledger.Constraints qualified as Constraints
-import Ledger.Contexts (ScriptContext (ScriptContext, scriptContextTxInfo), TxInfo (txInfoValidRange))
 import Ledger.Interval (after, before, from)
 import Ledger.Interval qualified as Interval
 import Ledger.Tx qualified as Tx
 import Ledger.Typed.Scripts (TypedValidator)
 import Ledger.Typed.Scripts qualified as Scripts
 import Ledger.Value (Value, geq, lt)
+import Plutus.Script.Utils.V1.Scripts qualified as Scripts
+import Plutus.V1.Ledger.Api (Datum (Datum), DatumHash, ValidatorHash)
+import Plutus.V1.Ledger.Contexts (ScriptContext (ScriptContext, scriptContextTxInfo), TxInfo (txInfoValidRange))
 
 import Plutus.Contract (AsContractError (_ContractError), Contract, ContractError, Endpoint, HasEndpoint, Promise,
                         awaitTime, currentTime, endpoint, mapError, mkTxConstraints, ownPaymentPubKeyHash, promiseMap,
@@ -219,11 +220,11 @@ validate EscrowParams{escrowDeadline, escrowTargets} contributor action ScriptCo
 
 {- START typedValidator -}
 typedValidator :: EscrowParams Datum -> Scripts.TypedValidator Escrow
-typedValidator escrow = go (Haskell.fmap Ledger.datumHash escrow) where
+typedValidator escrow = go (Haskell.fmap Scripts.datumHash escrow) where
     go = Scripts.mkTypedValidatorParam @Escrow
         $$(PlutusTx.compile [|| validate ||])
         $$(PlutusTx.compile [|| wrap ||])
-    wrap = Scripts.wrapValidator
+    wrap = Scripts.mkUntypedValidator
 {- END typedValidator -}
 escrowContract
     :: EscrowParams Datum
@@ -336,7 +337,7 @@ refund ::
 refund inst escrow = do
     pk <- ownPaymentPubKeyHash
     unspentOutputs <- utxosAt (Scripts.validatorAddress inst)
-    let flt _ ciTxOut = either id Ledger.datumHash (Tx._ciTxOutDatum ciTxOut) == Ledger.datumHash (Datum (PlutusTx.toBuiltinData pk))
+    let flt _ ciTxOut = either id Scripts.datumHash (Tx._ciTxOutDatum ciTxOut) == Scripts.datumHash (Datum (PlutusTx.toBuiltinData pk))
         tx' = Typed.collectFromScriptFilter flt unspentOutputs Refund
                 <> Constraints.mustValidateIn (from (Haskell.succ $ escrowDeadline escrow))
     if Constraints.modifiesUtxoSet tx'

doc/plutus/tutorials/basic-validators.rst

@@ -118,7 +118,7 @@ This tells the compiler what the Haskell types for the redeemer and datum are, s
 
 We can then write a nice version of our validator that *only* uses the Haskell types!
 This is what we would write if we completely forgot about all the concerns about ``Data``, returning errors, and so on.
-To turn this into a validator like we saw before, we can use :hsobj:`Ledger.Typed.Scripts.Validators.wrapValidator`.
+To turn this into a validator like we saw before, we can use :hsobj:`Plutus.Script.Utils.V1.Typed.Scripts.Validators.mkUntypedValidator`.
 This takes advantage of the information we provided in our ``ScriptType`` instance to automatically work out how to decode the arguments.
 
 .. literalinclude:: BasicValidators.hs