IntersectMBO
diff --git a/‎.github/workflows/test.yml‎
Lines changed: 3 additions & 3 deletions b/‎.github/workflows/test.yml‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎doc/adr/0005-pab-indexing-solution-integration.rst‎
Lines changed: 1 addition & 1 deletion b/‎doc/adr/0005-pab-indexing-solution-integration.rst‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎plutus-chain-index-core/src/Plutus/ChainIndex/Tx.hs‎
Lines changed: 3 additions & 3 deletions b/‎plutus-chain-index-core/src/Plutus/ChainIndex/Tx.hs‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎plutus-chain-index-core/src/Plutus/ChainIndex/TxIdState.hs‎
Lines changed: 2 additions & 2 deletions b/‎plutus-chain-index-core/src/Plutus/ChainIndex/TxIdState.hs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎plutus-contract-certification/src/Plutus/Contract/Test/Certification/Run.hs‎
Lines changed: 24 additions & 7 deletions b/‎plutus-contract-certification/src/Plutus/Contract/Test/Certification/Run.hs‎
Lines changed: 24 additions & 7 deletions
diff --git a/‎plutus-contract/src/Wallet/Emulator/Chain.hs‎
Lines changed: 7 additions & 5 deletions b/‎plutus-contract/src/Wallet/Emulator/Chain.hs‎
Lines changed: 7 additions & 5 deletions
diff --git a/‎plutus-contract/src/Wallet/Emulator/MultiAgent.hs‎
Lines changed: 1 addition & 1 deletion b/‎plutus-contract/src/Wallet/Emulator/MultiAgent.hs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎plutus-contract/src/Wallet/Emulator/Wallet.hs‎
Lines changed: 55 additions & 59 deletions b/‎plutus-contract/src/Wallet/Emulator/Wallet.hs‎
Lines changed: 55 additions & 59 deletions
diff --git a/‎plutus-contract/src/Wallet/Graph.hs‎
Lines changed: 1 addition & 1 deletion b/‎plutus-contract/src/Wallet/Graph.hs‎
Lines changed: 1 addition & 1 deletion
@@ -9,7 +9,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
-      - uses: nixbuild/nix-quick-install-action@v17
+      - uses: nixbuild/nix-quick-install-action@v18
       - run: nix-instantiate release.nix --arg supportedSystems '[ builtins.currentSystem ]' --restrict-eval -I . --allowed-uris 'https://github.com/NixOS/nixpkgs https://github.com/input-output-hk https://github.com/NixOS/nixpkgs-channels' --option trusted-public-keys "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option substituters "https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/" --show-trace
   nix-tests:
     strategy:
@@ -18,7 +18,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
-      - uses: nixbuild/nix-quick-install-action@v17
+      - uses: nixbuild/nix-quick-install-action@v18
       - run: nix-build -A tests.nixpkgsFmt -A tests.cabalFmt -A tests.purs-tidy -A tests.pngOptimization -A tests.shellcheck -A tests.stylishHaskell --arg supportedSystems '[ builtins.currentSystem ]' --restrict-eval -I . --allowed-uris 'https://github.com/NixOS/nixpkgs https://github.com/input-output-hk https://github.com/NixOS/nixpkgs-channels' --option trusted-public-keys "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option substituters "https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/"
   check-for-updates:
     strategy:
@@ -27,7 +27,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
-      - uses: nixbuild/nix-quick-install-action@v17
+      - uses: nixbuild/nix-quick-install-action@v18
       - run: |
           nix --extra-experimental-features 'nix-command flakes' --extra-experimental-features flakes flake lock --option trusted-public-keys "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option substituters "https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/"
           nix-shell --extra-experimental-features 'nix-command flakes' --command "cd plutus-playground-client && (update-client-deps || update-client-deps)" --option trusted-public-keys "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" --option substituters "https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/" # Double-call to work around bug in spago2nix on first fetch
 
@@ -44,7 +44,7 @@ contract in `plutus-use-cases`).
       -- Step 3
       let refs = Map.keys
                  $ Map.filter ((==) address . txOutAddress)
-                 $ getCardanoTxUnspentOutputsTx ledgerTx
+                 $ getCardanoTxProducedOutputs ledgerTx
       case refs of
           []                   -> throwing _ScriptOutputMissing pk
           [outRef] -> do
 
@@ -110,11 +110,11 @@ fromOnChainTx = \case
             ctx
     Invalid ctx ->
         onCardanoTx
-            (\case tx@Tx{txCollateral, txValidRange, txData, txScripts} ->
+            (\case tx@Tx{txCollateralInputs, txReturnCollateral, txValidRange, txData, txScripts} ->
                     ChainIndexTx
                         { _citxTxId = txId tx
-                        , _citxInputs = map (fillTxInputWitnesses tx) txCollateral
-                        , _citxOutputs = InvalidTx Nothing -- TODO: update when `Tx` supports collateral output
+                        , _citxInputs = map (fillTxInputWitnesses tx) txCollateralInputs
+                        , _citxOutputs = InvalidTx $ fmap (fromCardanoTxOut . getTxOut) txReturnCollateral
                         , _citxValidRange = txValidRange
                         , _citxData = txData
                         , _citxRedeemers = calculateRedeemerPointers tx
 
@@ -21,7 +21,7 @@ import Data.FingerTree ((|>))
 import Data.FingerTree qualified as FT
 import Data.Map qualified as Map
 import Data.Monoid (Last (..), Sum (..))
-import Ledger (OnChainTx, TxId, eitherTx)
+import Ledger (OnChainTx, TxId, onChainTxIsValid)
 import Plutus.ChainIndex.Tx (ChainIndexTx (..), citxTxId, validityFromChainIndex)
 import Plutus.ChainIndex.Types (BlockNumber (..), Depth (..), Point (..), RollbackState (..), Tip (..),
                                 TxConfirmedState (..), TxIdState (..), TxStatus, TxStatusFailure (..), TxValidity (..))
@@ -31,7 +31,7 @@ import Plutus.ChainIndex.UtxoState (RollbackFailed (..), RollbackResult (..), Ut
 -- | The 'TxStatus' of a transaction right after it was added to the chain
 initialStatus :: OnChainTx -> TxStatus
 initialStatus tx =
-  TentativelyConfirmed 0 (eitherTx (const TxInvalid) (const TxValid) tx) ()
+  TentativelyConfirmed 0 (if onChainTxIsValid tx then TxValid else TxInvalid) ()
 
 -- | Increase the depth of a tentatively confirmed transaction
 increaseDepth :: TxStatus -> TxStatus
 
@@ -58,8 +58,8 @@ import System.Random.SplitMix
 import Test.QuickCheck as QC
 import Test.QuickCheck.Property
 import Test.QuickCheck.Random as QC
-import Test.Tasty as Tasty
-import Test.Tasty.Runners as Tasty
+import Test.Tasty qualified as Tasty
+import Test.Tasty.Runners qualified as Tasty
 import Text.Read hiding (lift)
 
 newtype JSONShowRead a = JSONShowRead a
@@ -90,7 +90,24 @@ instance FromJSON SomeException where
     str <- parseJSON v
     return $ SomeException (ErrorCall str)
 
-deriving via (JSONShowRead Tasty.Result) instance ToJSON Tasty.Result
+data TastyResult = Result
+  { resultOutcome          :: Tasty.Outcome
+  , resultDescription      :: String
+  , resultShortDescription :: String
+  , resultTime             :: Tasty.Time
+  }
+  deriving (Generic, ToJSON)
+
+deriving instance Generic Tasty.FailureReason
+deriving instance ToJSON Tasty.FailureReason
+deriving instance ToJSON Tasty.Outcome
+
+instance ToJSON Tasty.Result where
+  toJSON r = toJSON $ Result { resultOutcome          = Tasty.resultOutcome r
+                             , resultDescription      = Tasty.resultDescription r
+                             , resultShortDescription = Tasty.resultShortDescription r
+                             , resultTime             = Tasty.resultTime r
+                             }
 
 data CertificationReport m = CertificationReport {
     _certRes_standardPropertyResult       :: QC.Result,
@@ -208,10 +225,10 @@ checkNoLockedFundsLight opts prf =
 mkQCArgs :: CertificationOptions -> Args
 mkQCArgs CertificationOptions{..} = stdArgs { chatty = certOptOutput , maxSuccess = certOptNumTests }
 
-runUnitTests :: (CoverageRef -> TestTree) -> CertMonad [Tasty.Result]
+runUnitTests :: (CoverageRef -> Tasty.TestTree) -> CertMonad [Tasty.Result]
 runUnitTests t = liftIORep $ do
     ref <- newCoverageRef
-    res <- launchTestTree mempty (t ref) $ \ status -> do
+    res <- Tasty.launchTestTree mempty (t ref) $ \ status -> do
       rs <- atomically $ mapM waitForDone (IntMap.elems status)
       return $ \ _ -> return rs
     cov <- readCoverageRef ref
@@ -220,8 +237,8 @@ runUnitTests t = liftIORep $ do
     waitForDone tv = do
       s <- readTVar tv
       case s of
-        Done r -> return r
-        _      -> retry
+        Tasty.Done r -> return r
+        _            -> retry
 
 checkDerived :: forall d m c. (c m => ContractModel (d m))
              => Maybe (Instance c m)
 
@@ -31,8 +31,8 @@ import Data.Monoid (Ap (Ap))
 import Data.Traversable (for)
 import GHC.Generics (Generic)
 import Ledger (Block, Blockchain, CardanoTx (..), OnChainTx (..), Params (..), Slot (..), TxId, TxIn (txInRef), Value,
-               eitherTx, getCardanoTxCollateralInputs, getCardanoTxFee, getCardanoTxId, getCardanoTxValidityRange,
-               txOutValue)
+               getCardanoTxCollateralInputs, getCardanoTxFee, getCardanoTxId, getCardanoTxTotalCollateral,
+               getCardanoTxValidityRange, txOutValue, unOnChain)
 import Ledger.Index qualified as Index
 import Ledger.Interval qualified as Interval
 import Ledger.Validation qualified as Validation
@@ -166,8 +166,10 @@ validateBlock params slot@(Slot s) idx txns =
     in ValidatedBlock block events idx'
 
 getCollateral :: Index.UtxoIndex -> CardanoTx -> Value
-getCollateral idx tx = fromRight (getCardanoTxFee tx) $
-    alaf Ap foldMap (fmap txOutValue . (`Index.lookup` idx) . txInRef) (getCardanoTxCollateralInputs tx)
+getCollateral idx tx = case getCardanoTxTotalCollateral tx of
+    Just v -> v
+    Nothing -> fromRight (getCardanoTxFee tx) $
+        alaf Ap foldMap (fmap txOutValue . (`Index.lookup` idx) . txInRef) (getCardanoTxCollateralInputs tx)
 
 -- | Check whether the given transaction can be validated in the given slot.
 canValidateNow :: Slot -> CardanoTx -> Bool
@@ -204,7 +206,7 @@ addBlock blk st =
   st & chainNewestFirst %~ (blk :)
      -- The block update may contain txs that are not in this client's
      -- `txPool` which will get ignored
-     & txPool %~ (\\ map (eitherTx id id) blk)
+     & txPool %~ (\\ map unOnChain blk)
 
 addTxToPool :: CardanoTx -> TxPool -> TxPool
 addTxToPool = (:)
 
@@ -308,7 +308,7 @@ emulatorStateInitialDist networkId mp = do
     where
         -- See [Creating wallets with multiple outputs]
         mkOutputs (key, vl) = mkOutput key <$> splitInto10 vl
-        splitInto10 vl = replicate (fromIntegral count) (Ada.toValue (ada `div` count)) ++ remainder
+        splitInto10 vl = if count <= 1 then [vl] else replicate (fromIntegral count) (Ada.toValue (ada `div` count)) ++ remainder
             where
                 ada = if Value.isAdaOnlyValue vl then Ada.fromValue vl else Ada.fromValue vl - minAdaTxOut
                 -- Make sure we don't make the outputs too small
 
@@ -25,7 +25,7 @@ module Wallet.Emulator.Wallet where
 
 import Cardano.Api.Shelley (makeSignedTransaction, protocolParamCollateralPercent)
 import Cardano.Wallet.Primitive.Types qualified as Cardano.Wallet
-import Control.Lens (makeLenses, makePrisms, over, view, (&), (.~), (^.))
+import Control.Lens (makeLenses, makePrisms, over, view, (&), (.~), (?~), (^.))
 import Control.Monad (foldM, (<=<))
 import Control.Monad.Freer (Eff, Member, Members, interpret, type (~>))
 import Control.Monad.Freer.Error (Error, runError, throwError)
@@ -37,7 +37,7 @@ import Data.Aeson qualified as Aeson
 import Data.Bifunctor (bimap, first, second)
 import Data.Data (Data)
 import Data.Default (Default (def))
-import Data.Foldable (Foldable (fold), find, foldl')
+import Data.Foldable (Foldable (fold), find, foldl', toList)
 import Data.List (sort, sortOn, (\\))
 import Data.Map qualified as Map
 import Data.Maybe (catMaybes, fromMaybe, isNothing, listToMaybe)
@@ -424,65 +424,75 @@ handleBalanceTx ::
     -> UnbalancedTx
     -> Eff effs Tx
 handleBalanceTx utxo utx = do
-    params@Params { pProtocolParams } <- WAPI.getClientParams
+    Params { pProtocolParams } <- WAPI.getClientParams
     let filteredUnbalancedTxTx = removeEmptyOutputs (view U.tx utx)
     let txInputs = Tx.txInputs filteredUnbalancedTxTx
     ownAddr <- gets ownAddress
     inputValues <- traverse lookupValue (Tx.txInputs filteredUnbalancedTxTx)
-    collateral  <- traverse lookupValue (Tx.txCollateral filteredUnbalancedTxTx)
     let fees = txFee filteredUnbalancedTxTx
         left = txMint filteredUnbalancedTxTx <> fold inputValues
         right = fees <> foldMap Tx.txOutValue (filteredUnbalancedTxTx ^. Tx.outputs)
-        collFees = Ada.toValue $ (Ada.fromValue fees * maybe 100 fromIntegral (protocolParamCollateralPercent pProtocolParams)) `Ada.divide` 100
-        remainingCollFees = collFees PlutusTx.- fold collateral
         balance = left PlutusTx.- right
         -- filter out inputs from utxo that are already in unBalancedTx
         inputsOutRefs = map Tx.txInputRef txInputs
         filteredUtxo = flip Map.filterWithKey utxo $ \txOutRef _ ->
             txOutRef `notElem` inputsOutRefs
         outRefsWithValue = second (view Ledger.ciTxOutValue) <$> Map.toList filteredUtxo
 
-    ((neg, newTxIns), (pos, newTxOuts)) <- calculateTxChanges params ownAddr outRefsWithValue $ Value.split balance
-
-    tx' <- if Value.isZero pos
-           then do
-               logDebug NoOutputsAdded
-               pure filteredUnbalancedTxTx
-           else do
-                logDebug $ AddingPublicKeyOutputFor pos
-                pure $ filteredUnbalancedTxTx & over Tx.outputs (++ newTxOuts)
-
-    tx'' <- if Value.isZero neg
-            then do
-                logDebug NoInputsAdded
-                pure tx'
-            else do
-                logDebug $ AddingInputsFor neg
-                pure $ tx' & over Tx.inputs (sort . (++) (fmap Tx.pubKeyTxInput newTxIns))
-
-    if remainingCollFees `Value.leq` PlutusTx.zero
-    then do
-        logDebug NoCollateralInputsAdded
-        pure tx''
-    else do
-        logDebug $ AddingCollateralInputsFor remainingCollFees
-        addCollateral utxo remainingCollFees tx''
+    ((neg, newTxIns), (pos, mNewTxOut)) <- calculateTxChanges ownAddr outRefsWithValue $ Value.split balance
+
+    txWithOutputsAdded <- if Value.isZero pos
+        then do
+            logDebug NoOutputsAdded
+            pure filteredUnbalancedTxTx
+        else do
+            logDebug $ AddingPublicKeyOutputFor pos
+            pure $ filteredUnbalancedTxTx & over Tx.outputs (++ toList mNewTxOut)
+
+    txWithinputsAdded <- if Value.isZero neg
+        then do
+            logDebug NoInputsAdded
+            pure txWithOutputsAdded
+        else do
+            logDebug $ AddingInputsFor neg
+            pure $ txWithOutputsAdded & over Tx.inputs (sort . (++) (fmap Tx.pubKeyTxInput newTxIns))
+
+    collateral <- traverse lookupValue (Tx.txCollateralInputs txWithinputsAdded)
+
+    let collAddr = maybe ownAddr Ledger.txOutAddress $ Tx.txReturnCollateral txWithinputsAdded
+        collateralPercent = maybe 100 fromIntegral (protocolParamCollateralPercent pProtocolParams)
+        collFees = Ada.toValue $ (Ada.fromValue fees * collateralPercent + 99 {- make sure to round up -}) `Ada.divide` 100
+        collBalance = fold collateral PlutusTx.- collFees
+
+    ((negColl, newTxInsColl), (_, mNewTxOutColl)) <- calculateTxChanges collAddr outRefsWithValue $ Value.split collBalance
+
+    txWithCollateralInputs <- if Value.isZero negColl
+        then do
+            logDebug NoCollateralInputsAdded
+            pure txWithinputsAdded
+        else do
+            logDebug $ AddingCollateralInputsFor negColl
+            pure $ txWithinputsAdded & over Tx.collateralInputs (sort . (++) (fmap Tx.pubKeyTxInput newTxInsColl))
+
+    pure $ txWithCollateralInputs & Tx.totalCollateral ?~ collFees & Tx.returnCollateral .~ mNewTxOutColl
 
 type PubKeyTxIn = TxOutRef
 
-calculateTxChanges
-    :: ( Member (Error WAPI.WalletAPIError) effs
-       )
-    => Params
-    -> Address -- ^ The address for the change output
+calculateTxChanges ::
+    ( Member (Error WAPI.WalletAPIError) effs
+    , Member NodeClientEffect effs
+    , Member (State WalletState) effs
+    )
+    => Address -- ^ The address for the change output
     -> [(TxOutRef, Value)] -- ^ The current wallet's unspent transaction outputs.
     -> (Value, Value) -- ^ The unbalanced tx's negative and positive balance.
-    -> Eff effs ((Value, [PubKeyTxIn]), (Value, [TxOut]))
-calculateTxChanges params addr utxos (neg, pos) = do
+    -> Eff effs ((Value, [PubKeyTxIn]), (Value, Maybe TxOut))
+calculateTxChanges addr utxos (neg, pos) = do
     -- Calculate the change output with minimal ada
-    (newNeg, newPos, extraTxOuts) <- if Value.isZero pos
-        then pure (neg, pos, [])
+    (newNeg, newPos, mExtraTxOut) <- if Value.isZero pos
+        then pure (neg, pos, Nothing)
         else do
+            params <- WAPI.getClientParams
             txOut <- either
               (throwError . WAPI.ToCardanoError)
               (pure . TxOut)
@@ -492,7 +502,7 @@ calculateTxChanges params addr utxos (neg, pos) = do
                 $ U.adjustTxOut params txOut
             let missingValue = Ada.toValue (fold missing)
             -- Add the missing ada to both sides to keep the balance.
-            pure (neg <> missingValue, pos <> missingValue, [extraTxOut])
+            pure (neg <> missingValue, pos <> missingValue, Just extraTxOut)
 
     -- Calculate the extra inputs needed
     (spend, change) <- if Value.isZero newNeg
@@ -502,30 +512,16 @@ calculateTxChanges params addr utxos (neg, pos) = do
     if Value.isZero change
         then do
             -- No change, so the new inputs and outputs have balanced the transaction
-            pure ((newNeg, fst <$> spend), (newPos, extraTxOuts))
-        else if null extraTxOuts
+            pure ((newNeg, fst <$> spend), (newPos, mExtraTxOut))
+        else if null mExtraTxOut
             -- We have change so we need an extra output, if we didn't have that yet,
             -- first make one with an estimated minimal amount of ada
             -- which then will calculate a more exact set of inputs
-            then calculateTxChanges params addr utxos (neg <> Ada.toValue Ledger.minAdaTxOut, Ada.toValue Ledger.minAdaTxOut)
+            then calculateTxChanges addr utxos (neg <> Ada.toValue Ledger.minAdaTxOut, Ada.toValue Ledger.minAdaTxOut)
             -- Else recalculate with the change added to both sides
             -- Ideally this creates the same inputs and outputs and then the change will be zero
             -- But possibly the minimal Ada increases and then we also want to compute a new set of inputs
-            else calculateTxChanges params addr utxos (newNeg <> change, newPos <> change)
-
-addCollateral
-    :: ( Member (Error WAPI.WalletAPIError) effs
-       )
-    => Map.Map TxOutRef ChainIndexTxOut -- ^ The current wallet's unspent transaction outputs.
-    -> Value
-    -> Tx
-    -> Eff effs Tx
-addCollateral mp vl tx = do
-    (spend, _) <- selectCoin (filter (Value.isAdaOnlyValue . snd) (second (view Ledger.ciTxOutValue) <$> Map.toList mp)) vl
-    let addTxCollateral =
-            let ins = Tx.pubKeyTxInput . fst <$> spend
-            in over Tx.collateralInputs (sort . (++) ins)
-    pure $ tx & addTxCollateral
+            else calculateTxChanges addr utxos (newNeg <> change, newPos <> change)
 
 -- | Given a set of @a@s with coin values, and a target value, select a number
 -- of @a@ such that their total value is greater than or equal to the target.
 
@@ -108,7 +108,7 @@ txnFlows keys bc = catMaybes (utxoLinks ++ foldMap extract bc')
 
     extract :: (UtxoLocation, OnChainTx) -> [Maybe FlowLink]
     extract (loc, tx) =
-      let targetRef = mkRef $ eitherTx getCardanoTxId getCardanoTxId tx in
+      let targetRef = mkRef $ getCardanoTxId $ unOnChain tx in
       fmap (flow (Just loc) targetRef . txInRef) (consumableInputs tx)
     -- make a flow for a TxOutRef