Remove unnecessary e2e specs

Because the http server sepcs added before. We only keep a: * simple success case scenario * and another one using a blueprint
input-output-hk · Apr 17, 2024 · 6cb560a · 6cb560a
1 parent 7c68e76
commit 6cb560a
Show file tree

Hide file tree

Showing 3 changed files with 48 additions and 165 deletions.
diff --git a/hydra-cluster/src/Hydra/Cluster/Scenarios.hs b/hydra-cluster/src/Hydra/Cluster/Scenarios.hs
@@ -25,12 +25,10 @@ import Data.Aeson.Types (parseMaybe)
 import Data.ByteString (isInfixOf)
 import Data.ByteString qualified as B
 import Data.Set qualified as Set
-import Hydra.API.HTTPServer (
-  TransactionSubmitted (..),
- )
-import Hydra.Cardano.Api (Coin (..), File (File), Key (SigningKey), PaymentKey, PlutusScriptV2, Tx, TxId, UTxO, fromPlutusScript, getVerificationKey, isVkTxOut, lovelaceToValue, makeSignedTransaction, mkScriptAddress, mkTxOutDatumHash, mkTxOutDatumInline, mkVkAddress, selectLovelace, signTx, toScriptData, txOutAddress, txOutValue, writeFileTextEnvelope, pattern ReferenceScriptNone, pattern TxOut, pattern TxOutDatumNone)
+import Hydra.API.HTTPServer (DraftCommitTxRequest (..), DraftCommitTxResponse (..), TransactionSubmitted (..))
+import Hydra.Cardano.Api (Coin (..), File (File), Key (SigningKey), PaymentKey, Tx, TxId, UTxO, getVerificationKey, isVkTxOut, lovelaceToValue, makeSignedTransaction, mkVkAddress, selectLovelace, signTx, txOutAddress, txOutValue, writeFileTextEnvelope, pattern ReferenceScriptNone, pattern TxOut, pattern TxOutDatumNone)
 import Hydra.Chain.Direct.Tx (verificationKeyToOnChainId)
-import Hydra.Cluster.Faucet (FaucetLog, createOutputAtAddress, seedFromFaucet, seedFromFaucet_)
+import Hydra.Cluster.Faucet (FaucetLog, seedFromFaucet, seedFromFaucet_)
 import Hydra.Cluster.Faucet qualified as Faucet
 import Hydra.Cluster.Fixture (Actor (..), actorName, alice, aliceSk, aliceVk, bob, bobSk, bobVk, carol, carolSk)
 import Hydra.Cluster.Mithril (MithrilLog)
@@ -39,7 +37,7 @@ import Hydra.Cluster.Util (chainConfigFor, keysFor, modifyConfig, setNetworkId)
 import Hydra.ContestationPeriod (ContestationPeriod (UnsafeContestationPeriod), fromNominalDiffTime)
 import Hydra.HeadId (HeadId)
 import Hydra.Ledger (IsTx (balance), txId)
-import Hydra.Ledger.Cardano (ScriptInfo (..), TxOutWithWitness (..), genKeyPair, mkSimpleTx)
+import Hydra.Ledger.Cardano (genKeyPair, mkSimpleTx)
 import Hydra.Logging (Tracer, traceWith)
 import Hydra.Options (networkId, startChainFrom)
 import Hydra.Party (Party)
@@ -71,7 +69,6 @@ import Network.HTTP.Req (
   runReq,
   (/:),
  )
-import PlutusLedgerApi.Test.Examples qualified as Plutus
 import System.Directory (removeDirectoryRecursive)
 import System.FilePath ((</>))
 import Test.QuickCheck (choose, generate)
@@ -297,125 +294,53 @@ singlePartyOpenAHead tracer workDir node hydraScriptsTxId callback =
  where
   RunningNode{networkId, nodeSocket, blockTime} = node
 
--- | Exercise committing a script utxo that uses inline datums.
-singlePartyCommitsExternalScriptWithInlineDatum ::
-  Tracer IO EndToEndLog ->
-  FilePath ->
-  RunningNode ->
-  TxId ->
-  IO ()
-singlePartyCommitsExternalScriptWithInlineDatum tracer workDir node hydraScriptsTxId =
-  (`finally` returnFundsToFaucet tracer node Alice) $ do
-    refuelIfNeeded tracer node Alice 25_000_000
-    aliceChainConfig <- chainConfigFor Alice workDir nodeSocket hydraScriptsTxId [] $ UnsafeContestationPeriod 100
-    let hydraNodeId = 1
-    let hydraTracer = contramap FromHydraNode tracer
-    withHydraNode hydraTracer aliceChainConfig workDir hydraNodeId aliceSk [] [1] $ \n1 -> do
-      send n1 $ input "Init" []
-      headId <- waitMatch (10 * blockTime) n1 $ headIsInitializingWith (Set.fromList [alice])
-
-      -- Prepare a script output on the network
-      -- FIXME: spending validators have 3 arguments? does this succeed still? is it not run?
-      let script = fromPlutusScript @PlutusScriptV2 $ Plutus.alwaysSucceedingNAryFunction 2
-          scriptAddress = mkScriptAddress @PlutusScriptV2 networkId script
-          reedemer = 1 :: Integer
-          datum = 2 :: Integer
-          scriptInfo = ScriptInfo (toScriptData reedemer) Nothing script
-      (scriptTxIn, scriptTxOut) <- createOutputAtAddress node scriptAddress (mkTxOutDatumInline datum)
-
-      -- Commit the script output using known witness
-      -- FIXME: must complete request, but without DraftCommitTxRequest
-      let clientPayload =
-            object
-              [ scriptTxIn
-                  .= object
-                    [ "txOut" .= scriptTxOut
-                    , "witness"
-                        .= object
-                          [ "plutusV2Script" .= script
-                          , "redeemer" .= reedemer
-                          , "datum" .= datum
-                          ]
-                    ]
-              ]
-      res <-
-        runReq defaultHttpConfig $
-          req
-            POST
-            (http "127.0.0.1" /: "commit")
-            (ReqBodyJson clientPayload)
-            (Proxy :: Proxy (JsonResponse Tx))
-            (port $ 4000 + hydraNodeId)
-      -- NOTE: We accept a 'Tx' here as we want to submit it just after
-      let commitTx = responseBody res
-      submitTx node commitTx
-
-      lockedUTxO <- waitMatch (10 * blockTime) n1 $ \v -> do
-        guard $ v ^? key "headId" == Just (toJSON headId)
-        guard $ v ^? key "tag" == Just "HeadIsOpen"
-        pure $ v ^? key "utxo"
-      lockedUTxO `shouldBe` Just (toJSON $ UTxO.singleton (scriptTxIn, scriptTxOut))
- where
-  RunningNode{networkId, nodeSocket, blockTime} = node
-
 -- | Single hydra-node where the commit is done from an external UTxO owned by a
 -- script which requires providing script, datum and redeemer instead of
 -- signing the transaction.
-singlePartyCommitsFromExternalScript ::
+singlePartyCommitsFromExternal ::
   Tracer IO EndToEndLog ->
   FilePath ->
   RunningNode ->
   TxId ->
   IO ()
-singlePartyCommitsFromExternalScript tracer workDir node hydraScriptsTxId =
-  (`finally` returnFundsToFaucet tracer node Alice) $ do
-    refuelIfNeeded tracer node Alice 25_000_000
-    aliceChainConfig <- chainConfigFor Alice workDir nodeSocket hydraScriptsTxId [] $ UnsafeContestationPeriod 100
-    let hydraNodeId = 1
-    let hydraTracer = contramap FromHydraNode tracer
-    withHydraNode hydraTracer aliceChainConfig workDir hydraNodeId aliceSk [] [1] $ \n1 -> do
-      send n1 $ input "Init" []
-      headId <- waitMatch (10 * blockTime) n1 $ headIsInitializingWith (Set.fromList [alice])
+singlePartyCommitsFromExternal tracer workDir node hydraScriptsTxId =
+  ( `finally`
+      do
+        returnFundsToFaucet tracer node Alice
+        returnFundsToFaucet tracer node AliceFunds
+  )
+    $ do
+      refuelIfNeeded tracer node Alice 25_000_000
+      aliceChainConfig <- chainConfigFor Alice workDir nodeSocket hydraScriptsTxId [] $ UnsafeContestationPeriod 100
+      let hydraNodeId = 1
+      let hydraTracer = contramap FromHydraNode tracer
+      withHydraNode hydraTracer aliceChainConfig workDir hydraNodeId aliceSk [] [1] $ \n1 -> do
+        send n1 $ input "Init" []
+        headId <- waitMatch (10 * blockTime) n1 $ headIsInitializingWith (Set.fromList [alice])
 
-      -- Prepare a script output on the network
-      let script = fromPlutusScript @PlutusScriptV2 $ Plutus.alwaysSucceedingNAryFunction 2
-          scriptAddress = mkScriptAddress @PlutusScriptV2 networkId script
-          reedemer = 1 :: Integer
-          datum = 2 :: Integer
-          scriptInfo = ScriptInfo (toScriptData reedemer) (Just $ toScriptData datum) script
-      (scriptTxIn, scriptTxOut) <- createOutputAtAddress node scriptAddress (mkTxOutDatumHash datum)
-
-      -- Commit the script output using known witness
-      let clientPayload =
-            SimpleCommitRequest
-              { utxoToCommit =
-                  UTxO.singleton
-                    ( scriptTxIn
-                    , TxOutWithWitness
-                        { txOut = scriptTxOut
-                        , witness = Just scriptInfo
-                        }
-                    )
-              }
-      res <-
-        runReq defaultHttpConfig $
-          req
-            POST
-            (http "127.0.0.1" /: "commit")
-            (ReqBodyJson clientPayload)
-            (Proxy :: Proxy (JsonResponse DraftCommitTxResponse))
-            (port $ 4000 + hydraNodeId)
-
-      let DraftCommitTxResponse{commitTx} = responseBody res
-      submitTx node commitTx
-
-      lockedUTxO <- waitMatch (10 * blockTime) n1 $ \v -> do
-        guard $ v ^? key "headId" == Just (toJSON headId)
-        guard $ v ^? key "tag" == Just "HeadIsOpen"
-        pure $ v ^? key "utxo"
-      lockedUTxO `shouldBe` Just (toJSON $ UTxO.singleton (scriptTxIn, scriptTxOut))
+        (walletVk, _) <- keysFor AliceFunds
+        utxoToCommit <- seedFromFaucet node walletVk 5_000_000 (contramap FromFaucet tracer)
+        -- Commit the script output using known witness
+        let clientPayload = SimpleCommitRequest{utxoToCommit}
+        res <-
+          runReq defaultHttpConfig $
+            req
+              POST
+              (http "127.0.0.1" /: "commit")
+              (ReqBodyJson clientPayload)
+              (Proxy :: Proxy (JsonResponse DraftCommitTxResponse))
+              (port $ 4000 + hydraNodeId)
+
+        let DraftCommitTxResponse{commitTx} = responseBody res
+        submitTx node commitTx
+
+        lockedUTxO <- waitMatch (10 * blockTime) n1 $ \v -> do
+          guard $ v ^? key "headId" == Just (toJSON headId)
+          guard $ v ^? key "tag" == Just "HeadIsOpen"
+          pure $ v ^? key "utxo"
+        lockedUTxO `shouldBe` Just (toJSON utxoToCommit)
  where
-  RunningNode{networkId, nodeSocket, blockTime} = node
+  RunningNode{nodeSocket, blockTime} = node
 
 -- | Single hydra-node where the commit is done from a raw transaction
 -- blueprint.
@@ -475,34 +400,6 @@ singlePartyCommitsFromExternalTxBlueprint tracer workDir node hydraScriptsTxId =
  where
   RunningNode{networkId, nodeSocket, blockTime} = node
 
-singlePartyCannotCommitExternallyWalletUtxo ::
-  Tracer IO EndToEndLog ->
-  FilePath ->
-  RunningNode ->
-  TxId ->
-  IO ()
-singlePartyCannotCommitExternallyWalletUtxo tracer workDir node hydraScriptsTxId =
-  (`finally` returnFundsToFaucet tracer node Alice) $ do
-    refuelIfNeeded tracer node Alice 25_000_000
-    aliceChainConfig <- chainConfigFor Alice workDir nodeSocket hydraScriptsTxId [] $ UnsafeContestationPeriod 100
-    let hydraNodeId = 1
-    let hydraTracer = contramap FromHydraNode tracer
-    withHydraNode hydraTracer aliceChainConfig workDir hydraNodeId aliceSk [] [1] $ \n1 -> do
-      send n1 $ input "Init" []
-      _headId <- waitMatch (10 * blockTime) n1 $ headIsInitializingWith (Set.fromList [alice])
-
-      -- these keys should mimic external wallet keys needed to sign the commit tx
-
-      -- internal wallet uses the actor keys internally so we need to use utxo
-      -- present at this public key
-      (userVk, _userSk) <- keysFor Alice
-      -- submit the tx using our external user key to get a utxo to commit
-      utxoToCommit <- seedFromFaucet node userVk 2_000_000 (contramap FromFaucet tracer)
-      -- Request to build a draft commit tx from hydra-node
-      requestCommitTx n1 utxoToCommit `shouldThrow` expectErrorStatus 400 (Just "SpendingNodeUtxoForbidden")
- where
-  RunningNode{nodeSocket, blockTime} = node
-
 -- | Initialize open and close a head on a real network and ensure contestation
 -- period longer than the time horizon is possible. For this it is enough that
 -- we can close a head and not wait for the deadline.

diff --git a/hydra-cluster/test/Test/DirectChainSpec.hs b/hydra-cluster/test/Test/DirectChainSpec.hs
@@ -66,7 +66,7 @@ import Hydra.Cluster.Util (chainConfigFor, keysFor, modifyConfig, readConfigFile
 import Hydra.Crypto (aggregate, sign)
 import Hydra.HeadId (HeadId, HeadSeed (..))
 import Hydra.Ledger (IsTx (..))
-import Hydra.Ledger.Cardano (Tx, genKeyPair, mkBlueprintTx, utxoFromTxOutWithWitness, utxoToTxOutWithWitness)
+import Hydra.Ledger.Cardano (Tx, genKeyPair, mkBlueprintTx)
 import Hydra.Logging (Tracer, nullTracer, showLogsOnFailure)
 import Hydra.OnChainId (OnChainId)
 import Hydra.Options (
@@ -525,10 +525,8 @@ externalCommit ::
   UTxO' (TxOut CtxUTxO) ->
   IO ()
 externalCommit node hydraClient externalSk headId utxoToCommit = do
-  let utxoToCommit' = utxoToTxOutWithWitness utxoToCommit
-      blueprintTx = mkBlueprintTx utxoToCommit'
-      utxo = utxoFromTxOutWithWitness utxoToCommit'
-  commitTx <- draftCommitTx headId utxo blueprintTx
+  let blueprintTx = mkBlueprintTx utxoToCommit
+  commitTx <- draftCommitTx headId utxoToCommit blueprintTx
   let signedTx = signTx externalSk commitTx
   submitTx node signedTx
  where

diff --git a/hydra-cluster/test/Test/EndToEndSpec.hs b/hydra-cluster/test/Test/EndToEndSpec.hs
@@ -67,9 +67,7 @@ import Hydra.Cluster.Scenarios (
   refuelIfNeeded,
   restartedNodeCanAbort,
   restartedNodeCanObserveCommitTx,
-  singlePartyCannotCommitExternallyWalletUtxo,
-  singlePartyCommitsExternalScriptWithInlineDatum,
-  singlePartyCommitsFromExternalScript,
+  singlePartyCommitsFromExternal,
   singlePartyCommitsFromExternalTxBlueprint,
   singlePartyHeadFullLifeCycle,
   testPreventResumeReconfiguredPeer,
@@ -178,27 +176,17 @@ spec = around (showLogsOnFailure "EndToEndSpec") $ do
           withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
             publishHydraScriptsAs node Faucet
               >>= timedTx tmpDir tracer node
-      xit "commits from external with script utxo" $ \tracer -> do
+      it "commits from external with utxo" $ \tracer -> do
         withClusterTempDir $ \tmpDir -> do
           withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
             publishHydraScriptsAs node Faucet
-              >>= singlePartyCommitsFromExternalScript tracer tmpDir node
-      xit "commit external wallet utxo with inline datum in the script" $ \tracer -> do
-        withClusterTempDir $ \tmpDir -> do
-          withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
-            publishHydraScriptsAs node Faucet
-              >>= singlePartyCommitsExternalScriptWithInlineDatum tracer tmpDir node
-      xit "can't commit externally with internal wallet utxo" $ \tracer -> do
-        withClusterTempDir $ \tmpDir -> do
-          withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
-            publishHydraScriptsAs node Faucet
-              >>= singlePartyCannotCommitExternallyWalletUtxo tracer tmpDir node
+              >>= singlePartyCommitsFromExternal tracer tmpDir node
       it "can submit a signed user transaction" $ \tracer -> do
         withClusterTempDir $ \tmpDir -> do
           withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
             publishHydraScriptsAs node Faucet
               >>= canSubmitTransactionThroughAPI tracer tmpDir node
-      xit "commits from external with tx blueprint" $ \tracer -> do
+      it "commits from external with tx blueprint" $ \tracer -> do
         withClusterTempDir $ \tmpDir -> do
           withCardanoNodeDevnet (contramap FromCardanoNode tracer) tmpDir $ \node ->
             publishHydraScriptsAs node Faucet