Fix tests in convex-coin-selection

src/coin-selection/convex-coin-selection.cabal

@@ -90,5 +90,4 @@ test-suite convex-coin-selection-test
     plutus-ledger-api,
     plutus-tx,
     plutus-tx-plugin,
-    mtl,
-    transformers
+    mtl

src/coin-selection/test/Scripts.hs

@@ -25,6 +25,7 @@ import           PlutusLedgerApi.Common        (SerialisedScript)
 import           PlutusLedgerApi.Test.Examples (alwaysSucceedingNAryFunction)
 import           PlutusTx                      (BuiltinData, CompiledCode)
 import qualified PlutusTx
+import           PlutusTx.Prelude              (BuiltinUnit)
 import qualified Scripts.MatchingIndex         as MatchingIndex
 
 v2SpendingScript :: C.PlutusScript C.PlutusScriptV2
@@ -36,25 +37,25 @@ v2SpendingScriptSerialised = alwaysSucceedingNAryFunction 3
 v2StakingScript :: C.PlutusScript C.PlutusScriptV2
 v2StakingScript = C.PlutusScriptSerialised $ alwaysSucceedingNAryFunction 2
 
-matchingIndexValidatorCompiled :: CompiledCode (BuiltinData -> BuiltinData -> BuiltinData -> ())
-matchingIndexValidatorCompiled =  $$(PlutusTx.compile [|| \d r c -> MatchingIndex.validator d r c ||])
+matchingIndexValidatorCompiled :: CompiledCode (BuiltinData -> BuiltinUnit)
+matchingIndexValidatorCompiled =  $$(PlutusTx.compile [|| \c -> MatchingIndex.validator c ||])
 
-matchingIndexMPCompiled :: CompiledCode (BuiltinData -> BuiltinData -> ())
-matchingIndexMPCompiled = $$(PlutusTx.compile [|| \r c -> MatchingIndex.mintingPolicy r c ||])
+matchingIndexMPCompiled :: CompiledCode (BuiltinData -> BuiltinUnit)
+matchingIndexMPCompiled = $$(PlutusTx.compile [|| \c -> MatchingIndex.mintingPolicy c ||])
 
 {-| Script that passes if the input's index (in the list of transaction inputs)
   matches the number passed as the redeemer
 -}
-matchingIndexValidatorScript :: C.PlutusScript C.PlutusScriptV2
+matchingIndexValidatorScript :: C.PlutusScript C.PlutusScriptV3
 matchingIndexValidatorScript = compiledCodeToScript matchingIndexValidatorCompiled
 
-matchingIndexMPScript :: C.PlutusScript C.PlutusScriptV2
+matchingIndexMPScript :: C.PlutusScript C.PlutusScriptV3
 matchingIndexMPScript = compiledCodeToScript matchingIndexMPCompiled
 
 {-| Spend an output locked by 'matchingIndexValidatorScript', setting
 the redeemer to the index of the input in the final transaction
 -}
-spendMatchingIndex :: forall era m. (C.IsAlonzoBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV2 era) => MonadBuildTx era m => TxIn -> m ()
+spendMatchingIndex :: forall era m. (C.IsAlonzoBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV3 era) => MonadBuildTx era m => TxIn -> m ()
 spendMatchingIndex txi =
   let witness txBody = C.ScriptWitness C.ScriptWitnessForSpending $ BuildTx.buildScriptWitness
         matchingIndexValidatorScript
@@ -65,7 +66,7 @@ spendMatchingIndex txi =
 {-| Mint a token from the 'matchingIndexMPScript', setting
 the redeemer to the index of its currency symbol in the final transaction mint
 -}
-mintMatchingIndex :: forall era m. (C.IsMaryBasedEra era, C.IsAlonzoBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV2 era) => MonadBuildTx era m => C.PolicyId -> C.AssetName -> C.Quantity -> m ()
+mintMatchingIndex :: forall era m. (C.IsMaryBasedEra era, C.IsAlonzoBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV3 era) => MonadBuildTx era m => C.PolicyId -> C.AssetName -> C.Quantity -> m ()
 mintMatchingIndex policy assetName quantity =
   let witness txBody = BuildTx.buildScriptWitness
         matchingIndexMPScript

src/coin-selection/test/Scripts/MatchingIndex.hs

@@ -12,27 +12,29 @@ module Scripts.MatchingIndex(
   , mintingPolicy
 ) where
 
+import           PlutusLedgerApi.V1.Scripts  (Redeemer (..))
 import           PlutusLedgerApi.V1.Value    (flattenValue)
-import           PlutusLedgerApi.V2.Contexts (ScriptContext (..),
-                                              ScriptPurpose (..), TxInInfo (..),
+import           PlutusLedgerApi.V3.Contexts (ScriptContext (..),
+                                              ScriptInfo (..), TxInInfo (..),
                                               TxInfo (..))
+import qualified PlutusTx.Builtins.Internal  as BI
 import           PlutusTx.IsData.Class       (UnsafeFromData (unsafeFromBuiltinData))
-import           PlutusTx.Prelude            (BuiltinData)
+import           PlutusTx.Prelude            (BuiltinData, BuiltinUnit)
 import qualified PlutusTx.Prelude            as P
 
 {-# INLINABLE validator #-}
-validator :: BuiltinData -> BuiltinData -> BuiltinData -> ()
-validator _datum (unsafeFromBuiltinData -> idx :: P.Integer) (unsafeFromBuiltinData -> ScriptContext{scriptContextPurpose=Spending txOutRef, scriptContextTxInfo=TxInfo{txInfoInputs}}) =
+validator :: BuiltinData -> BuiltinUnit
+validator (unsafeFromBuiltinData -> ScriptContext{scriptContextScriptInfo=SpendingScript txOutRef _, scriptContextTxInfo=TxInfo{txInfoInputs}, scriptContextRedeemer=(unsafeFromBuiltinData P.. getRedeemer -> idx :: P.Integer)}) =
   let isOwnIndex TxInInfo{txInInfoOutRef} = txInInfoOutRef P.== txOutRef
       ownIndex   = P.findIndex isOwnIndex txInfoInputs
-  in if ownIndex P.== (P.Just idx) then () else P.traceError "Different indices"
-validator _ _ _ = P.error ()
+  in if ownIndex P.== (P.Just idx) then BI.unitval else P.traceError "Different indices"
+validator _ = P.error ()
 
 {-# INLINABLE mintingPolicy #-}
-mintingPolicy :: BuiltinData -> BuiltinData -> ()
-mintingPolicy (unsafeFromBuiltinData -> idx :: P.Integer) (unsafeFromBuiltinData -> ScriptContext{scriptContextPurpose=Minting ownCs, scriptContextTxInfo=TxInfo{txInfoMint}}) =
+mintingPolicy :: BuiltinData -> BuiltinUnit
+mintingPolicy (unsafeFromBuiltinData -> ScriptContext{scriptContextScriptInfo=MintingScript ownCs, scriptContextTxInfo=TxInfo{txInfoMint}, scriptContextRedeemer=(unsafeFromBuiltinData P.. getRedeemer -> idx :: P.Integer)}) =
   let mintList = flattenValue txInfoMint
       isOwnIndex (cs,_,_) = cs P.== ownCs
       ownIndex = P.findIndex isOwnIndex mintList
-  in if ownIndex P.== (P.Just idx) then () else P.traceError "Different indices"
-mintingPolicy _ _ = P.error ()
+  in if ownIndex P.== (P.Just idx) then BI.unitval else P.traceError "Different indices"
+mintingPolicy _ = P.error ()

src/coin-selection/test/Spec.hs

@@ -16,14 +16,12 @@ import           Control.Monad                  (replicateM, void, when)
 import           Control.Monad.Except           (MonadError, runExceptT)
 import           Control.Monad.IO.Class         (MonadIO (..))
 import           Control.Monad.State.Strict     (execStateT, modify)
-import           Control.Monad.Trans.Class      (MonadTrans (..))
 import           Convex.BuildTx                 (BuildTxT, addRequiredSignature,
                                                  assetValue, execBuildTx,
                                                  execBuildTxT, mintPlutus,
                                                  payToAddress,
                                                  payToAddressTxOut,
                                                  payToScriptDatumHash,
-                                                 payToScriptInlineDatum,
                                                  prependTxOut,
                                                  setMinAdaDepositAll,
                                                  spendPlutus, spendPlutusRef)
@@ -48,7 +46,6 @@ import qualified Convex.MockChain.Defaults      as Defaults
 import qualified Convex.MockChain.Gen           as Gen
 import           Convex.MockChain.Staking       (registerPool)
 import           Convex.MockChain.Utils         (mockchainSucceeds,
-                                                 runMockchainProp,
                                                  runMockchainPropErr)
 import           Convex.NodeParams              (ledgerProtocolParameters,
                                                  protocolParameters)
@@ -156,11 +153,11 @@ spendPlutusV2Script ref = inBabbage @era $ do
   let tx = execBuildTx (spendPlutus ref Scripts.v2SpendingScript () ())
   C.getTxId . C.getTxBody <$> tryBalanceAndSubmit mempty Wallet.w1 tx TrailingChange []
 
-putReferenceScript :: forall era m. (MonadFail m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m) => Wallet -> m C.TxIn
+putReferenceScript :: forall m. (MonadFail m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m) => Wallet -> m C.TxIn
 putReferenceScript wallet = do
-  let hsh = C.hashScript (C.PlutusScript C.PlutusScriptV2 Scripts.v2SpendingScript)
+  let addr = Wallet.addressInEra Defaults.networkId wallet
       tx = execBuildTx $
-            payToScriptInlineDatum Defaults.networkId hsh () C.NoStakeAddress (C.lovelaceToValue 10_000_000)
+            BuildTx.createRefScriptDatumHash addr (plutusScript Scripts.v2SpendingScript) () (C.lovelaceToValue 10_000_000)
             >> setMinAdaDepositAll Defaults.bundledProtocolParameters
   txId <- C.getTxId . C.getTxBody <$> tryBalanceAndSubmit mempty wallet tx TrailingChange []
   let outRef = C.TxIn txId (C.TxIx 0)
@@ -355,13 +352,15 @@ largeTransactionTest = do
     (_, view failedTransactions -> [(_, err)]) -> case err of
       ApplyTxFailure (ApplyTxError (Rules.ConwayUtxowFailure (Rules.UtxoFailure (Rules.MaxTxSizeUTxO 20313 16384)):|[])) -> pure ()
       _ -> fail $ "Unexpected failure. Expected 'MaxTxSizeUTxO', found " <> show err
+    (_, length . view failedTransactions -> numFailed) -> fail $ "Expected one failed transaction, found " <> show numFailed
 
   -- the tx should succeed after setting the max tx size to exactly 20304 (see the error message in the test above)
   let params' = Defaults.nodeParams & ledgerProtocolParameters . protocolParameters . Ledger.ppMaxTxSizeL .~ 20313
   runMockchain0IOWith Wallet.initialUTxOs params' (failOnError largeDatumTx) >>= \case
     (Right{}, view failedTransactions -> []) -> pure ()
+    (_, length . view failedTransactions -> numFailed) -> fail $ "Expected success with 0 failed transactions, found " <> show numFailed
 
-matchingIndex :: forall era m. (MonadMockchain era m, MonadError (BalanceTxError era) m, MonadFail m, C.IsBabbageBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV2 era) => m ()
+matchingIndex :: forall era m. (MonadMockchain era m, MonadError (BalanceTxError era) m, MonadFail m, C.IsBabbageBasedEra era, C.HasScriptLanguageInEra C.PlutusScriptV3 era) => m ()
 matchingIndex = inBabbage @era $ do
   let txBody = execBuildTx (BuildTx.payToScriptDatumHash Defaults.networkId (plutusScript Scripts.matchingIndexValidatorScript) () C.NoStakeAddress (C.lovelaceToValue 10_000_000))
       tx     = C.TxIn . C.getTxId . C.getTxBody <$> tryBalanceAndSubmit mempty Wallet.w1 txBody TrailingChange [] <*> pure (C.TxIx 0)
@@ -390,12 +389,12 @@ withdrawZero = inBabbage @era $ do
 
 matchingIndexMP :: forall m. (MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m, MonadFail m) => m ()
 matchingIndexMP = do
-  let sh = C.hashScript (C.PlutusScript C.PlutusScriptV2 Scripts.matchingIndexMPScript)
+  let sh = C.hashScript (C.PlutusScript C.PlutusScriptV3 Scripts.matchingIndexMPScript)
       policyId = C.PolicyId sh
       runTx assetName = Scripts.mintMatchingIndex policyId assetName 100
   void $ tryBalanceAndSubmit mempty Wallet.w1 (execBuildTx $ traverse_ runTx ["assetName1", "assetName2", "assetName3"]) TrailingChange []
 
-queryStakeAddressesTest :: forall era m. (MonadIO m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m, MonadFail m) => m ()
+queryStakeAddressesTest :: forall m. (MonadIO m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m, MonadFail m) => m ()
 queryStakeAddressesTest = do
   poolId <- registerPool Wallet.w1
   stakeKey <- C.generateSigningKey C.AsStakeKey
@@ -435,7 +434,7 @@ queryStakeAddressesTest = do
   when (length rewards /= 1) $ fail "Expected 1 reward"
   when (length delegations /= 1) $ fail "Expected 1 delegation"
 
-withdrawalTest :: forall era m. (MonadIO m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m, MonadFail m) => m ()
+withdrawalTest :: forall m. (MonadIO m, MonadMockchain C.ConwayEra m, MonadError (BalanceTxError C.ConwayEra) m, MonadFail m) => m ()
 withdrawalTest = do
   poolId <- registerPool Wallet.w1
   stakeKey <- C.generateSigningKey C.AsStakeKey