PLT-18 Add script typed wrapper for Plutus V2 scripts

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
@@ -39,6 +40,19 @@ constraints:
     aeson >= 2
   , hedgehog >= 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.

doc/plutus-doc.cabal

@@ -75,6 +75,7 @@ executable doc-doctests
       plutus-ledger -any,
       plutus-ledger-api >= 1.0.0,
       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

nix/pkgs/haskell/haskell.nix

@@ -60,6 +60,7 @@ let
             plutus-pab.package.buildable = false;
             plutus-pab-executables.package.buildable = false;
             plutus-playground-server.package.buildable = false; # Would also require libpq
+            plutus-script-utils.package.buildable = false;
             plutus-tx-plugin.package.buildable = false;
             plutus-use-cases.package.buildable = false;
             plutus-example.package.buildable = false;
@@ -111,6 +112,9 @@ let
             plutus-ledger.doHaddock = deferPluginErrors;
             plutus-ledger.flags.defer-plugin-errors = deferPluginErrors;
 
+            plutus-script-utils.doHaddock = deferPluginErrors;
+            plutus-script-utils.flags.defer-plugin-errors = deferPluginErrors;
+
             plutus-example.doHaddock = deferPluginErrors;
             plutus-example.flags.defer-plugin-errors = deferPluginErrors;
             plutus-example.preCheck = "
@@ -142,14 +146,15 @@ let
             plutus-chain-index.ghcOptions = [ "-Werror" ];
             plutus-chain-index-core.ghcOptions = [ "-Werror" ];
             plutus-contract.ghcOptions = [ "-Werror" ];
+            plutus-doc.ghcOptions = [ "-Werror" ];
+            plutus-example.ghcOptions = [ "-Werror" ];
             plutus-ledger.ghcOptions = [ "-Werror" ];
             plutus-ledger-constraints.ghcOptions = [ "-Werror" ];
             plutus-playground-server.ghcOptions = [ "-Werror" ];
             plutus-pab.ghcOptions = [ "-Werror" ];
             plutus-pab-executables.ghcOptions = [ "-Werror" ];
-            plutus-doc.ghcOptions = [ "-Werror" ];
+            plutus-script-utils.ghcOptions = [ "-Werror" ];
             plutus-use-cases.ghcOptions = [ "-Werror" ];
-            plutus-example.ghcOptions = [ "-Werror" ];
 
             # Honestly not sure why we need this, it has a mysterious unused dependency on "m"
             # This will go away when we upgrade nixpkgs and things use ieee754 anyway.

playground-common/playground-common.cabal

@@ -65,6 +65,7 @@ library
         plutus-chain-index-core -any,
         plutus-contract -any,
         plutus-ledger -any,
+        plutus-ledger-api -any,
         plutus-ledger-constraints -any,
         row-types -any,
         prettyprinter -any,

playground-common/src/PSGenerator/Common.hs

@@ -18,10 +18,9 @@ import Language.PureScript.Bridge (BridgePart, Language (Haskell), PSType, SumTy
 import Language.PureScript.Bridge.Builder (BridgeData)
 import Language.PureScript.Bridge.PSTypes (psInt, psNumber, psString)
 import Language.PureScript.Bridge.TypeParameters (A)
-import Ledger (Address, BlockId, CardanoTx, ChainIndexTxOut, DatumHash, MintingPolicy, OnChainTx, PaymentPubKey,
-               PaymentPubKeyHash, PubKey, PubKeyHash, RedeemerPtr, ScriptTag, Signature, StakePubKey, StakePubKeyHash,
-               StakeValidator, Tx, TxId, TxIn, TxInType, TxOut, TxOutRef, TxOutTx, UtxoIndex, ValidationPhase,
-               Validator)
+import Ledger (Address, BlockId, CardanoTx, ChainIndexTxOut, OnChainTx, PaymentPubKey, PaymentPubKeyHash, PubKey,
+               PubKeyHash, RedeemerPtr, ScriptTag, Signature, StakePubKey, StakePubKeyHash, Tx, TxId, TxIn, TxInType,
+               TxOut, TxOutRef, TxOutTx, UtxoIndex, ValidationPhase)
 import Ledger.Ada (Ada)
 import Ledger.Constraints.OffChain (MkTxError, UnbalancedTx)
 import Ledger.Credential (Credential, StakingCredential)
@@ -50,6 +49,7 @@ import Plutus.Trace.Emulator.Types (ContractInstanceLog, ContractInstanceMsg, Co
                                     UserThreadMsg)
 import Plutus.Trace.Scheduler (Priority, SchedulerLog, StopReason, ThreadEvent, ThreadId)
 import Plutus.Trace.Tag (Tag)
+import Plutus.V1.Ledger.Api (DatumHash, MintingPolicy, StakeValidator, Validator)
 import Schema (FormArgumentF, FormSchema)
 import Wallet.API (WalletAPIError)
 import Wallet.Emulator.Types qualified as EM

playground-common/src/Schema.hs

@@ -58,13 +58,13 @@ import Data.Text qualified as Text
 import Data.UUID (UUID)
 import GHC.Generics (C1, Constructor, D1, Generic, K1 (K1), M1 (M1), Rec0, Rep, S1, Selector, U1, conIsRecord, conName,
                      from, selName, (:*:) ((:*:)), (:+:) (L1, R1))
-import Ledger (Ada, AssetClass, CurrencySymbol, DatumHash, Interval, POSIXTime, POSIXTimeRange, PaymentPubKey,
-               PaymentPubKeyHash, PubKey, PubKeyHash, RedeemerHash, Signature, Slot, StakePubKey, StakePubKeyHash,
-               TokenName, TxId, TxOutRef, ValidatorHash, Value)
+import Ledger (Ada, AssetClass, CurrencySymbol, Interval, POSIXTime, POSIXTimeRange, PaymentPubKey, PaymentPubKeyHash,
+               PubKey, PubKeyHash, Signature, Slot, StakePubKey, StakePubKeyHash, TokenName, TxId, TxOutRef, Value)
 import Ledger.Bytes (LedgerBytes)
 import Ledger.CardanoWallet (WalletNumber)
 import Plutus.Contract.Secrets (SecretArgument (EndpointSide, UserSide))
 import Plutus.Contract.StateMachine.ThreadToken (ThreadToken)
+import Plutus.V1.Ledger.Api (DatumHash, RedeemerHash, ValidatorHash)
 import PlutusTx.AssocMap qualified
 import PlutusTx.Prelude qualified as P
 import PlutusTx.Ratio qualified as P

plutus-chain-index-core/plutus-chain-index-core.cabal

@@ -58,6 +58,7 @@ library
     build-depends:
         plutus-ledger -any,
         plutus-ledger-api >= 1.0.0,
+        plutus-script-utils -any,
         plutus-tx >= 1.0.0,
         freer-extras -any,
     build-depends:

plutus-chain-index-core/src/Plutus/ChainIndex/Api.hs

@@ -24,12 +24,13 @@ import Data.Aeson (FromJSON, ToJSON, Value)
 import Data.OpenApi qualified as OpenApi
 import Data.Proxy (Proxy (..))
 import GHC.Generics (Generic)
-import Ledger (AssetClass, Datum, DatumHash, MintingPolicy, MintingPolicyHash, Redeemer, RedeemerHash, StakeValidator,
-               StakeValidatorHash, TxId, Validator, ValidatorHash)
+import Ledger (AssetClass, TxId)
 import Ledger.Credential (Credential)
 import Ledger.Tx (ChainIndexTxOut, TxOutRef)
 import Plutus.ChainIndex.Tx (ChainIndexTx)
 import Plutus.ChainIndex.Types (Diagnostics, Tip)
+import Plutus.V1.Ledger.Api (Datum, DatumHash, MintingPolicy, MintingPolicyHash, Redeemer, RedeemerHash, StakeValidator,
+                             StakeValidatorHash, Validator, ValidatorHash)
 import Servant qualified
 import Servant.API (Description, Get, JSON, NoContent, Post, Put, ReqBody, (:<|>), (:>))
 import Servant.OpenApi (toOpenApi)

plutus-chain-index-core/src/Plutus/ChainIndex/Client.hs

@@ -25,8 +25,7 @@ import Control.Monad.Freer.Error (Error, throwError)
 import Control.Monad.Freer.Reader (Reader, ask)
 import Control.Monad.IO.Class (MonadIO (..))
 import Data.Proxy (Proxy (..))
-import Ledger (Datum, DatumHash, MintingPolicy, MintingPolicyHash, Redeemer, RedeemerHash, StakeValidator,
-               StakeValidatorHash, TxId, Validator, ValidatorHash)
+import Ledger (TxId)
 import Ledger.Tx (ChainIndexTxOut, TxOutRef)
 import Network.HTTP.Types.Status (Status (..))
 import Plutus.ChainIndex.Api (API, IsUtxoResponse, TxoAtAddressRequest (TxoAtAddressRequest), TxosResponse,
@@ -35,6 +34,8 @@ import Plutus.ChainIndex.Api (API, IsUtxoResponse, TxoAtAddressRequest (TxoAtAdd
 import Plutus.ChainIndex.Effects (ChainIndexQueryEffect (..))
 import Plutus.ChainIndex.Tx (ChainIndexTx)
 import Plutus.ChainIndex.Types (Tip)
+import Plutus.V1.Ledger.Api (Datum, DatumHash, MintingPolicy, MintingPolicyHash, Redeemer, RedeemerHash, StakeValidator,
+                             StakeValidatorHash, Validator, ValidatorHash)
 import Servant (NoContent, (:<|>) (..))
 import Servant.Client (ClientEnv, ClientError (..), ClientM, client, runClientM)
 import Servant.Client.Core.Response (ResponseF (..))

plutus-chain-index-core/src/Plutus/ChainIndex/DbSchema.hs

@@ -36,12 +36,14 @@ import Database.Beam (Beamable, Columnar, Database, DatabaseSettings, FromBacken
 import Database.Beam.Migrate (CheckedDatabaseSettings, defaultMigratableDbSettings, renameCheckedEntity,
                               unCheckDatabase)
 import Database.Beam.Sqlite (Sqlite)
-import Ledger (AssetClass, BlockId (..), ChainIndexTxOut (..), Datum, DatumHash (..), MintingPolicy,
-               MintingPolicyHash (..), Redeemer, RedeemerHash (..), Script, ScriptHash (..), Slot, StakeValidator,
-               StakeValidatorHash (..), TxId (..), TxOut, TxOutRef (..), Validator, ValidatorHash (..))
+import Ledger (BlockId (..), ChainIndexTxOut (..), Slot)
 import Plutus.ChainIndex.Tx (ChainIndexTx)
 import Plutus.ChainIndex.Types (BlockNumber (..), Tip (..))
-import Plutus.V1.Ledger.Api (Credential)
+import Plutus.V1.Ledger.Api (Credential, Datum, DatumHash (..), MintingPolicy, MintingPolicyHash (..), Redeemer,
+                             RedeemerHash (..), Script, StakeValidator, StakeValidatorHash (..), TxId (..), TxOut,
+                             TxOutRef (..), Validator, ValidatorHash (..))
+import Plutus.V1.Ledger.Scripts (ScriptHash (..))
+import Plutus.V1.Ledger.Value (AssetClass)
 import PlutusTx.Builtins qualified as PlutusTx
 
 data DatumRowT f = DatumRow