Merge pull request #68 from mlabs-haskell/bladyjoker/add-consumer-example

bladyjoker · web-flow · commit d1e834b2e1e3 · 2023-02-09T16:48:16.000+01:00
Add the Consumer example
diff --git a/README.md b/README.md
@@ -1100,3 +1100,16 @@ contains the [Fact Statement minting
 policy](coop-docs/02-plutus-protocol.md#fs-policy) script which is the `Currency
 Symbol` the consuming dApps use to assert the authenticity and provenance of the
 referenced [Fact Statement UTxOs](coop-docs/02-plutus-protocol.md#fs-validator).
+
+An example Consumer [validator script](coop-plutus/src/Coop/Plutus:L594-L608)
+was provided to demonstrate how to authenticate [Fact Statement
+UTxOs](coop-docs/02-plutus-protocol.md#fs-validator) on-chain. The script
+performs a simple assertion on the
+[Value](https://github.com/input-output-hk/plutus/blob/c3918d6027a9a34b6f72a6e4c7bf2e5350e6467e/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs#L185)
+of a referenced UTxO to make sure it contains a
+[CurrencySymbol](https://github.com/input-output-hk/plutus/blob/c3918d6027a9a34b6f72a6e4c7bf2e5350e6467e/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs#L79)
+of the [$FS](coop-docs/02-plutus-protocol.md#fs-token) tokens it trusts
+
+The second part of the script demonstrates how to parse a [Plutus
+JSON](coop-docs/05-json-plutus.md) [Fact
+Statement](coop-plutus/resources/sample.json).
diff --git a/coop-plutus/build.nix b/coop-plutus/build.nix
@@ -18,7 +18,7 @@ haskell-nix.cabalProject' (plutarch.applyPlutarchDep pkgs rec {
     packages = {
       # Enable strict builds
       coop-plutus.configureFlags = [ "-f-dev" ];
-
+      coop-plutus.package.extraSrcFiles = [ "resources/sample.json" "resources/sample.pd.cbor" ]; # TODO(bladyjoker): I would like to get rid of this as haskell-nix should pick it up from the Cabal file
       # Use the new-ledger-namespace
       coop-hs-types.configureFlags = [ "-fnew-ledger-namespace" ];
     };
diff --git a/coop-plutus/coop-plutus.cabal b/coop-plutus/coop-plutus.cabal
@@ -130,6 +130,7 @@ test-suite coop-plutus-tests
 
   build-depends:
     , base
+    , bytestring
     , containers
     , coop-hs-types
     , coop-plutus
@@ -139,4 +140,5 @@ test-suite coop-plutus-tests
     , plutus-ledger-api
     , plutus-tx
     , QuickCheck
+    , serialise
     , text
diff --git a/coop-plutus/resources/sample.json b/coop-plutus/resources/sample.json
@@ -0,0 +1,14 @@
+{
+    "array": [
+        1,
+        2,
+        3
+    ],
+    "boolean": true,
+    "null": null,
+    "integer": 123,
+    "big_integer": 12300000000000000000000000,
+    "real": 123.123,
+    "big_real": 12300000000000000000000000.123,
+    "string": "Hello World"
+}
diff --git a/coop-plutus/resources/sample.pd.cbor b/coop-plutus/resources/sample.pd.cbor
diff --git a/coop-plutus/src/Coop/Plutus.hs b/coop-plutus/src/Coop/Plutus.hs
@@ -8,35 +8,27 @@ module Coop.Plutus (
   certV,
   mkCertMp,
   pmustSpendAtLeastAa,
+  exampleConsumer,
 ) where
 
 import Coop.Plutus.Aux (pcurrencyTokenQuantity, pcurrencyValue, pdatumFromTxOut, pdjust, pdnothing, pfindMap, pfoldTxInputs, pfoldTxOutputs, pfoldTxRefs, phasCurrency, pmaybeData, pmustBeSignedBy, pmustBurnOwnSingletonValue, pmustMintCurrency, pmustPayCurrencyWithDatumTo, pmustSpendAtLeast, pmustValidateAfter, pownCurrencySymbol, ptryFromData, punit)
 import Coop.Plutus.Types (PAuthMpParams, PAuthMpRedeemer (PAuthMpBurn, PAuthMpMint), PAuthParams, PCertDatum, PCertMpParams, PCertMpRedeemer (PCertMpBurn, PCertMpMint), PFsDatum, PFsMpParams, PFsMpRedeemer (PFsMpBurn, PFsMpMint))
 import Plutarch (POpaque, pmatch, popaque)
+import Plutarch.Api.V1.AssocMap (plookup)
 import Plutarch.Api.V1.Value (passertPositive, pnormalize, pvalueOf)
 import Plutarch.Api.V1.Value qualified as PValue
-import Plutarch.Api.V2 (
-  AmountGuarantees (NonZero, Positive),
-  KeyGuarantees (Sorted),
-  PCurrencySymbol,
-  PMaybeData,
-  PMintingPolicy,
-  PTokenName (PTokenName),
-  PTuple,
-  PTxInInfo,
-  PTxOut,
-  PValidator,
-  PValue,
- )
+import Plutarch.Api.V2 (AmountGuarantees (NonZero, Positive), KeyGuarantees (Sorted, Unsorted), PCurrencySymbol, PMap, PMaybeData, PMintingPolicy, PTokenName (PTokenName), PTuple, PTxInInfo, PTxOut, PValidator, PValue)
 import Plutarch.Api.V2.Contexts (PScriptContext)
-import Plutarch.Bool (pif)
+import Plutarch.Bool (PBool, pif)
+import Plutarch.Builtin (PBuiltinPair, pasConstr, pfstBuiltin, psndBuiltin)
 import Plutarch.Crypto (pblake2b_256)
 import Plutarch.Extra.Interval (pcontains)
+import Plutarch.List (pmap)
 import Plutarch.Monadic qualified as P
 import Plutarch.Num (PNum (pnegate, (#+)))
-import Plutarch.Prelude (ClosedTerm, PAsData, PBuiltinList, PByteString, PEq ((#==)), PInteger, PListLike (pcons, pnil), PPair (PPair), PPartialOrd ((#<), (#<=)), Term, pcon, pconsBS, pfield, pfoldl, pfromData, phoistAcyclic, plam, plet, pletFields, ptrace, ptraceError, (#), (#$), type (:-->))
+import Plutarch.Prelude (ClosedTerm, PAsData, PBuiltinList, PByteString, PData, PEq ((#==)), PInteger, PListLike (pcons, phead, pnil), PMaybe (PJust), PPair (PPair), PPartialOrd ((#<), (#<=)), Term, pcon, pconsBS, pconstant, pfield, pfoldl, pfromData, phoistAcyclic, plam, plet, pletFields, ptrace, ptraceError, (#), (#$), type (:-->))
 import PlutusTx.Prelude (Group (inv))
-import Prelude (Monoid (mempty), Semigroup ((<>)), ($))
+import Prelude (Monoid (mempty), Semigroup ((<>)), ($), (.))
 
 {- | Validates spending from @FsV
 
@@ -598,3 +590,93 @@ pmustSpendAtLeastAa = phoistAcyclic $
       (atLeastAaQ #<= aaTokensSpent)
       (ptrace "pmustSpendAtLeastAa: Spent at least the specified amount of AA tokens" $ pblake2b_256 # tnBytes)
       (ptraceError "pmustSpendAtLeastAa: Must spend at least the specified amount of AA tokens")
+
+{- | Example Consumer validator that authenticates and processes a referenced
+ FactStatement UTxO
+
+- check that the reference input holds the appropriate $FS token (with the
+  trusted COOP Oracle's CurrencySymbol),
+- parse the Fact Statement embedded in the UTxO datum and perform assertions.
+
+To demonstrate the COOP provided Plutus JSON encoding a file was created with the COOP
+provided `plutus-json-cli` tool:
+
+\$ plutus-json-cli from-json -i resources/sample.json -o resources/sample.pd.cbor
+
+This served as an exemplary Fact Statement.
+-}
+exampleConsumer :: ClosedTerm (PCurrencySymbol :--> PValidator)
+exampleConsumer = phoistAcyclic $
+  plam $ \trustedCs _ _ ctx -> ptrace "exampleConsumer" P.do
+    ctx' <- pletFields @'["txInfo"] ctx
+    txInfo <- pletFields @'["referenceInputs"] ctx'.txInfo
+
+    ptrace "exampleConsumer: Looking for a Fact Statement reference input from a trusted COOP Oracle"
+    refInput <- pletFields @'["resolved"] $ phead # pfromData txInfo.referenceInputs
+    refInVal <- plet $ pfield @"value" # refInput.resolved
+
+    ptrace "exampleConsumer: Looking for a Fact Statement reference input from a trusted COOP Oracle"
+    pif
+      (phasCurrency # trustedCs # refInVal)
+      ( ptrace
+          "exampleConsumer: Found an authentic Fact Statement reference input from a trusted COOP Oracle"
+          P.do
+            -- Parse the FsDatum available in the referenced input
+            fsDatum <- pletFields @'["fd'fs", "fd'submitter", "fd'gcAfter", "fd'fsId"] $ pdatumFromTxOut @PFsDatum # ctx # refInput.resolved
+
+            -- Take the Fact Statement payload in `fd'fs` field and try to parse it as a PlutusData Map
+            factStatement :: Term s (PMap 'Unsorted PByteString PData) <- plet $ pfromData $ ptryFromData fsDatum.fd'fs
+
+            -- Take the "array" field in the Fact Statement and assert that it is [1,2,3]
+            PJust arrayNumbers''' <- pmatch $ plookup # pconstant "array" # factStatement
+            -- Parse it as Plutus List
+            arrayNumbers' :: Term s (PBuiltinList (PAsData PInteger)) <- plet $ pfromData $ ptryFromData arrayNumbers'''
+            -- Parse the elements within as Plutus Integer
+            arrayNumbers <- plet $ pmap # plam pfromData # arrayNumbers'
+            _ <- plet $ pif (arrayNumbers #== pconstant [1, 2, 3]) (popaque punit) (ptraceError "Expected Plutus List [1,2,3]")
+
+            -- Take the "boolean" field in the Fact Statement and assert that it is true
+            PJust boolean' <- pmatch $ plookup # pconstant "boolean" # factStatement
+            boolean :: Term s PBool <- plet $ pfromData $ ptryFromData boolean'
+            _ <- plet $ pif boolean (popaque punit) (ptraceError "Expected a Plutus Boolean true")
+
+            -- Take the "null" field in the Fact Statement and assert that it is null
+            PJust null' <- pmatch $ plookup # pconstant "null" # factStatement
+            null :: Term s (PBuiltinPair PInteger (PBuiltinList PData)) <- plet $ pasConstr # null'
+            _ <- plet $ pif ((pfstBuiltin # null) #== 2) (popaque punit) (ptraceError "Expected a Plutus Constr 2 []")
+            _ <- plet $ pif ((psndBuiltin # null) #== pconstant []) (popaque punit) (ptraceError "Expected a Plutus Constr 2 []")
+
+            -- Take the "integer" field in the Fact Statement and assert that it is 123
+            PJust integer' <- pmatch $ plookup # pconstant "integer" # factStatement
+            integer :: Term s PInteger <- plet $ pfromData $ ptryFromData integer'
+            _ <- plet $ pif (integer #== pconstant 123) (popaque punit) (ptraceError "Expected a Plutus Integer 123")
+
+            -- Take the "big_integer" field in the Fact Statement and assert that it is 12300000000000000000000000
+            PJust bigInteger' <- pmatch $ plookup # pconstant "big_integer" # factStatement
+            bigInteger'' :: Term s (PBuiltinPair PInteger (PBuiltinList PData)) <- plet $ pasConstr # bigInteger'
+            bigInteger''' :: Term s (PBuiltinList PInteger) <- plet $ pmap # plam (pfromData . ptryFromData) # (psndBuiltin # bigInteger'')
+            _ <- plet $ pif ((pfstBuiltin # bigInteger'') #== 3) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [12300000000000000000000000, 0]")
+            _ <- plet $ pif (bigInteger''' #== pconstant [12300000000000000000000000, 0]) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [12300000000000000000000000, 0]")
+
+            -- Take the "real" field in the Fact Statement and assert that it is 123.123
+            PJust real' <- pmatch $ plookup # pconstant "real" # factStatement
+            real'' :: Term s (PBuiltinPair PInteger (PBuiltinList PData)) <- plet $ pasConstr # real'
+            real''' :: Term s (PBuiltinList PInteger) <- plet $ pmap # plam (pfromData . ptryFromData) # (psndBuiltin # real'')
+            _ <- plet $ pif ((pfstBuiltin # real'') #== 3) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [123123, -3]")
+            _ <- plet $ pif (real''' #== pconstant [123123, -3]) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [123123, -3]")
+
+            -- Take the "big_real" field in the Fact Statement and assert that it is 12300000000000000000000000.123
+            PJust big_real' <- pmatch $ plookup # pconstant "big_real" # factStatement
+            big_real'' :: Term s (PBuiltinPair PInteger (PBuiltinList PData)) <- plet $ pasConstr # big_real'
+            big_real''' :: Term s (PBuiltinList PInteger) <- plet $ pmap # plam (pfromData . ptryFromData) # (psndBuiltin # big_real'')
+            _ <- plet $ pif ((pfstBuiltin # big_real'') #== 3) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [12300000000000000000000000123, -3]")
+            _ <- plet $ pif (big_real''' #== pconstant [12300000000000000000000000123, -3]) (popaque punit) (ptraceError "Expected a Plutus Constr 3 [12300000000000000000000000123, -3]")
+
+            -- Take the "string" field in the Fact Statement and assert that it is "Hello World"
+            PJust string' <- pmatch $ plookup # pconstant "string" # factStatement
+            string'' :: Term s PByteString <- plet $ pfromData $ ptryFromData string'
+            _ <- plet $ pif (string'' #== pconstant "Hello World") (popaque punit) (ptraceError "Expected a Plutus Bytestring \"Hello World\"")
+
+            ptrace "exampleConsumer: Everything worked!" $ popaque punit
+      )
+      (ptraceError "exampleConsumer: Must have a Fact Statement reference input from a trusted COOP Oracle")
diff --git a/coop-plutus/test/Coop/Plutus/Test.hs b/coop-plutus/test/Coop/Plutus/Test.hs
@@ -1,26 +1,30 @@
 module Coop.Plutus.Test (spec) where
 
 import Plutarch.Prelude (ClosedTerm, PBool (PTrue), PEq ((#==)), pconstant, pconstantData, (#))
-import Test.Hspec (Expectation, Spec, describe, shouldBe)
+import Test.Hspec (Expectation, Spec, describe, runIO, shouldBe)
 import Test.Hspec.QuickCheck (prop)
 import Test.QuickCheck (NonEmptyList (getNonEmpty), Positive (getPositive), choose, forAll, generate)
 
-import Coop.Plutus (certV, fsV, mkAuthMp, mkCertMp, mkFsMp, pmustSpendAtLeastAa)
+import Codec.Serialise (deserialiseOrFail)
+import Coop.Plutus (certV, exampleConsumer, fsV, mkAuthMp, mkCertMp, mkFsMp, pmustSpendAtLeastAa)
 import Coop.Plutus.Aux (hashTxInputs, pmustBurnOwnSingletonValue)
-import Coop.Plutus.Test.Generators (distribute, genAaInputs, genCertRdmrAc, genCorrectAuthMpBurningCtx, genCorrectAuthMpMintingCtx, genCorrectCertMpBurningCtx, genCorrectCertMpMintingCtx, genCorrectCertVSpendingCtx, genCorrectFsMpBurningCtx, genCorrectFsMpMintingCtx, genCorrectFsVSpendingCtx, genCorrectMustBurnOwnSingletonValueCtx, genCorruptAuthMpBurningCtx, genCorruptAuthMpMintingCtx, genCorruptCertMpBurningCtx, genCorruptCertMpMintingCtx, genCorruptCertVSpendingCtx, genCorruptFsMpBurningCtx, genCorruptFsMpMintingCtx, genCorruptFsVSpendingCtx, genCorruptMustBurnOwnSingletonValueCtx, mkScriptContext)
+import Coop.Plutus.Test.Generators (distribute, genAaInputs, genCertRdmrAc, genCorrectAuthMpBurningCtx, genCorrectAuthMpMintingCtx, genCorrectCertMpBurningCtx, genCorrectCertMpMintingCtx, genCorrectCertVSpendingCtx, genCorrectConsumerCtx, genCorrectFsMpBurningCtx, genCorrectFsMpMintingCtx, genCorrectFsVSpendingCtx, genCorrectMustBurnOwnSingletonValueCtx, genCorruptAuthMpBurningCtx, genCorruptAuthMpMintingCtx, genCorruptCertMpBurningCtx, genCorruptCertMpMintingCtx, genCorruptCertVSpendingCtx, genCorruptFsMpBurningCtx, genCorruptFsMpMintingCtx, genCorruptFsVSpendingCtx, genCorruptMustBurnOwnSingletonValueCtx, mkScriptContext)
 import Coop.Plutus.Types (PAuthMpParams, PCertMpParams, PFsMpParams)
 import Coop.Types (AuthMpParams (AuthMpParams), AuthMpRedeemer (AuthMpBurn, AuthMpMint), AuthParams (AuthParams), CertMpParams (CertMpParams), CertMpRedeemer (CertMpBurn, CertMpMint), FsMpParams (FsMpParams), FsMpRedeemer (FsMpBurn, FsMpMint))
+import Data.ByteString.Lazy qualified as LB
 import Data.Foldable (Foldable (fold))
 import Data.Map qualified as Map
 import Data.Set qualified as Set
 import Data.Text (Text, unpack)
 import Plutarch (Config (Config, tracingMode), TracingMode (DetTracing), compile, pcon, printScript)
+import Plutarch.Api.V1 (PCurrencySymbol)
 import Plutarch.Builtin (PIsData (pdataImpl))
 import Plutarch.Evaluate (evalScript)
 import Plutarch.Test (pfails, psucceeds)
 import PlutusLedgerApi.V1.Address (scriptHashAddress)
 import PlutusLedgerApi.V1.Value (AssetClass, TokenName (TokenName), assetClass, currencySymbol)
-import PlutusLedgerApi.V2 (Address, CurrencySymbol, Script, ScriptPurpose (Minting), ValidatorHash (ValidatorHash), toData)
+import PlutusLedgerApi.V2 (Address, CurrencySymbol, Script, ScriptPurpose (Minting), ValidatorHash (ValidatorHash), dataToBuiltinData, toData)
+import PlutusTx (Data)
 import PlutusTx.Builtins.Class (stringToBuiltinByteString)
 
 coopAc :: AssetClass
@@ -265,6 +269,19 @@ spec = do
                   # pconstant (toData ())
                   # pconstant ctx
               )
+  describe "@Consumer" $ do
+    samplePd <- runIO $ readPlutusDataCbor "resources/sample.pd.cbor"
+    describe "should-succeed" $ do
+      prop "reference a fact statement" $
+        forAll (genCorrectConsumerCtx fsCs (dataToBuiltinData samplePd)) $
+          \ctx ->
+            psucceeds
+              ( exampleConsumer
+                  # pconstant @PCurrencySymbol fsCs
+                  # pconstant (toData ())
+                  # pconstant (toData ())
+                  # pconstant ctx
+              )
 
 _plog :: ClosedTerm a -> Expectation
 _plog p = _ptraces' p id []
@@ -298,3 +315,9 @@ pshouldBe x y = do
 pscriptShouldBe :: Script -> Script -> Expectation
 pscriptShouldBe x y =
   printScript x `shouldBe` printScript y
+
+readPlutusDataCbor :: FilePath -> IO Data
+readPlutusDataCbor fname = do
+  cborBytes <- LB.readFile fname
+  let errOrDecoded = deserialiseOrFail @Data cborBytes
+  either (\err -> error $ "File " <> fname <> " can't be parsed into PlutusData CBOR: " <> show err) return errOrDecoded
diff --git a/coop-plutus/test/Coop/Plutus/Test/Generators.hs b/coop-plutus/test/Coop/Plutus/Test/Generators.hs
@@ -1,4 +1,4 @@
-module Coop.Plutus.Test.Generators (mkScriptContext, mkTxInfo, genCertRdmrAc, distribute, genCorruptCertMpMintingCtx, genAaInputs, genCorrectCertMpMintingCtx, genCorrectAuthMpMintingCtx, genCorruptAuthMpMintingCtx, genCorrectCertMpBurningCtx, genCorruptCertMpBurningCtx, normalizeValue, genCorrectAuthMpBurningCtx, genCorruptAuthMpBurningCtx, genCorrectCertVSpendingCtx, genCorruptCertVSpendingCtx, genCorrectMustBurnOwnSingletonValueCtx, genCorruptMustBurnOwnSingletonValueCtx, genCorrectFsMpMintingCtx, genCorruptFsMpMintingCtx, genCorrectFsMpBurningCtx, genCorruptFsMpBurningCtx, genCorrectFsVSpendingCtx, genCorruptFsVSpendingCtx) where
+module Coop.Plutus.Test.Generators (mkScriptContext, mkTxInfo, genCertRdmrAc, distribute, genCorruptCertMpMintingCtx, genAaInputs, genCorrectCertMpMintingCtx, genCorrectAuthMpMintingCtx, genCorruptAuthMpMintingCtx, genCorrectCertMpBurningCtx, genCorruptCertMpBurningCtx, normalizeValue, genCorrectAuthMpBurningCtx, genCorruptAuthMpBurningCtx, genCorrectCertVSpendingCtx, genCorruptCertVSpendingCtx, genCorrectMustBurnOwnSingletonValueCtx, genCorruptMustBurnOwnSingletonValueCtx, genCorrectFsMpMintingCtx, genCorruptFsMpMintingCtx, genCorrectFsMpBurningCtx, genCorruptFsMpBurningCtx, genCorrectFsVSpendingCtx, genCorruptFsVSpendingCtx, genCorrectConsumerCtx) where
 
 import Test.QuickCheck (Arbitrary (arbitrary), Gen, choose, chooseAny, chooseEnum, chooseInt, chooseInteger, sublistOf, suchThat, vectorOf)
 
@@ -17,7 +17,7 @@ import PlutusLedgerApi.V2 (Address, BuiltinByteString, Datum (Datum), Extended (
 import PlutusTx.AssocMap qualified as AssocMap
 import PlutusTx.Builtins.Class (stringToBuiltinByteString)
 
-import Coop.Types (AuthMpParams (amp'authAuthorityAc, amp'requiredAtLeastAaQ), AuthParams (ap'authTokenCs, ap'certTokenCs), CertDatum (CertDatum), CertMpParams (cmp'authAuthorityAc, cmp'certVAddress, cmp'requiredAtLeastAaQ), FsDatum (FsDatum, fs'gcAfter, fs'submitter), FsMpParams (fmp'authParams, fmp'fsVAddress))
+import Coop.Types (AuthMpParams (amp'authAuthorityAc, amp'requiredAtLeastAaQ), AuthParams (ap'authTokenCs, ap'certTokenCs), CertDatum (CertDatum), CertMpParams (cmp'authAuthorityAc, cmp'certVAddress, cmp'requiredAtLeastAaQ), FactStatement, FsDatum (FsDatum, fs'gcAfter, fs'submitter), FsMpParams (fmp'authParams, fmp'fsVAddress))
 import PlutusLedgerApi.V1.Interval (interval)
 import PlutusLedgerApi.V2 qualified as Value
 import PlutusTx.Prelude (Group (inv))
@@ -464,6 +464,29 @@ genCorruptFsVSpendingCtx = do
 
   return $ corrupt ctx
 
+genFsRefInput :: CurrencySymbol -> FactStatement -> Gen TxInInfo
+genFsRefInput fsCs fs = do
+  addr <- genAddress
+  fsTn <- genTokenName
+  fsId <- genBuiltinByteString "fsid" 5
+  submitter <- genPubKeyHash
+  return $
+    TxInInfo
+      (TxOutRef (TxId fsId) 0)
+      ( TxOut
+          addr
+          (Value.singleton fsCs fsTn 1)
+          (toOutputDatum $ FsDatum fs (LedgerBytes fsId) PosInf submitter)
+          Nothing
+      )
+
+genCorrectConsumerCtx :: CurrencySymbol -> FactStatement -> Gen ScriptContext
+genCorrectConsumerCtx fsCs fs = do
+  spendingIn <- genInput
+  fsRefIn <- genFsRefInput fsCs fs
+
+  return $ mkScriptContext (Spending (txInInfoOutRef spendingIn)) [spendingIn] [fsRefIn] mempty [] []
+
 genInput :: Gen TxInInfo
 genInput = (\outRef val addr -> TxInInfo outRef (TxOut addr val NoOutputDatum Nothing)) <$> genTxOutRef <*> genSingletonValue <*> genAddress
 
