Add --tx-in-collateral and derive the era in compatible commands

.changes/20260813_173839_cardano-cli_mateusz.galazyn_cardano_api_compatible_tx.yml

@@ -0,0 +1,6 @@
+project: cardano-cli
+pr: 1408
+kind:
+  - feature
+description: |
+  Add a repeatable `--tx-in-collateral` option to `compatible transaction signed-transaction`, available from the Alonzo era onwards, so transactions with Plutus witnesses can include collateral inputs.

.changes/20261015_120000_cardano-cli_mateusz.galazyn_compatible-era-options.yml

@@ -0,0 +1,6 @@
+project: cardano-cli
+pr: 1408
+kind:
+  - refactoring
+description: |
+  Remove `pVoteFile`, `pProposalFile` and `pCertificateFile` from `Cardano.CLI.EraBased.Common.Option`; use `pVoteFileForEra`, `pProposalFileForEra` and `pCertificateFileForEra` with the era you need instead. Remove `readTxUpdateProposal` from `Cardano.CLI.Read`; read the file with `readFileTextEnvelope` instead. `CreateCompatibleSignedTransaction` now takes the update proposal file and the proposal files directly, without `Featured`.

cardano-cli/src/Cardano/CLI/Compatible/Governance/Run.hs

@@ -57,10 +57,8 @@ runCompatibleGovernanceActionCreateProtocolParametersUpdateCmd eraBasedPParams'
       shelleyToBabbageProtocolParametersUpdate sbe eraBasedPParams'
     ShelleyBasedEraBabbage ->
       shelleyToBabbageProtocolParametersUpdate sbe eraBasedPParams'
-    ShelleyBasedEraConway -> conwayProtocolParametersUpdate sbe eraBasedPParams'
-    ShelleyBasedEraDijkstra ->
-      -- TODO: Dijkstra
-      error "runCompatibleGovernanceActionCreateProtocolParametersUpdateCmd: Dijkstra not supported yet"
+    ShelleyBasedEraConway -> conwayOnwardsProtocolParametersUpdate sbe eraBasedPParams'
+    ShelleyBasedEraDijkstra -> conwayOnwardsProtocolParametersUpdate sbe eraBasedPParams'
 
 maybeAddUpdatedCostModel
   :: GovernanceActionProtocolParametersUpdateCmdArgs era
@@ -74,11 +72,12 @@ maybeAddUpdatedCostModel args = case uppCostModelsFile args of
     pure . addCostModelsToEraBasedProtocolParametersUpdate alonzoOnwards costModels $
       uppNewPParams args
 
-conwayProtocolParametersUpdate
-  :: ShelleyBasedEra ConwayEra
-  -> GovernanceActionProtocolParametersUpdateCmdArgs ConwayEra
+conwayOnwardsProtocolParametersUpdate
+  :: Typeable era
+  => ShelleyBasedEra era
+  -> GovernanceActionProtocolParametersUpdateCmdArgs era
   -> CIO e ()
-conwayProtocolParametersUpdate sbe args = do
+conwayOnwardsProtocolParametersUpdate sbe args = do
   let oFp = uppFilePath args
       anyEra = AnyShelleyBasedEra sbe
 

cardano-cli/src/Cardano/CLI/Compatible/Transaction/Command.hs

@@ -24,11 +24,11 @@ data CompatibleTransactionCmds era
   = CreateCompatibleSignedTransaction
       (ShelleyBasedEra era)
       [TxIn]
+      [TxIn]
+      -- ^ Collateral inputs
       [TxOutAnyEra]
-      !(Maybe (Featured ShelleyToBabbageEra era (Maybe UpdateProposalFile)))
-      !( Maybe
-           (Featured ConwayEraOnwards era [(ProposalFile In, Maybe AnyNonAssetScript)])
-       )
+      !(Maybe UpdateProposalFile)
+      ![(ProposalFile In, Maybe AnyNonAssetScript)]
       ![(VoteFile In, Maybe AnyNonAssetScript)]
       [WitnessSigningData]
       -- ^ Signing keys

cardano-cli/src/Cardano/CLI/Compatible/Transaction/Option.hs

@@ -12,6 +12,7 @@ module Cardano.CLI.Compatible.Transaction.Option
 where
 
 import Cardano.Api
+import Cardano.Api.Experimental qualified as Exp
 
 import Cardano.CLI.Compatible.Transaction.Command
 import Cardano.CLI.Environment
@@ -51,14 +52,15 @@ pCompatibleSignedTransaction
 pCompatibleSignedTransaction env sbe =
   CreateCompatibleSignedTransaction sbe
     <$> many pTxInOnly
+    <*> pTxInsCollateral sbe
     <*> many (pTxOutEraAware sbe)
-    <*> pFeatured (toCardanoEra sbe) (optional pUpdateProposalFile)
-    <*> pFeatured (toCardanoEra sbe) (many (pProposalFile ManualBalance))
+    <*> pOptionalUpdateProposalFile sbe
+    <*> pProposalFiles sbe ManualBalance
     <*> pVoteFiles sbe ManualBalance
     <*> many pWitnessSigningData
     <*> optional (pNetworkId env)
     <*> pTxFee
-    <*> many (pCertificateFile ManualBalance)
+    <*> pCertificateFiles sbe ManualBalance
     <*> optional pProtocolParamsFile
     <*> pOutputFile
 
@@ -71,6 +73,16 @@ pTxInOnly =
         <> Opt.help "TxId#TxIx"
     )
 
+pTxInsCollateral :: ShelleyBasedEra era -> Parser [TxIn]
+pTxInsCollateral = \case
+  ShelleyBasedEraShelley -> pure []
+  ShelleyBasedEraAllegra -> pure []
+  ShelleyBasedEraMary -> pure []
+  ShelleyBasedEraAlonzo -> many pTxInCollateral
+  ShelleyBasedEraBabbage -> many pTxInCollateral
+  ShelleyBasedEraConway -> many pTxInCollateral
+  ShelleyBasedEraDijkstra -> many pTxInCollateral
+
 -- This parser renders the appropriate parsers depending on what
 -- functionality is available per era.
 pTxOutEraAware :: ShelleyBasedEra era -> Parser TxOutAnyEra
@@ -89,18 +101,14 @@ pTxOutEraAware sbe =
     <*> pRefScriptFp sbe
 
 pTxOutDatum :: ShelleyBasedEra era -> Parser TxOutDatumAnyEra
-pTxOutDatum sbe =
-  forEraInEon
-    (convert sbe)
-    (pure TxOutDatumByNone)
-    ( \case
-        AlonzoEraOnwardsAlonzo ->
-          pAlonzoDatumFunctionality <|> pure TxOutDatumByNone
-        AlonzoEraOnwardsBabbage ->
-          pBabbageDatumFunctionality <|> pure TxOutDatumByNone
-        AlonzoEraOnwardsConway -> pConwayDatumFunctionality <|> pure TxOutDatumByNone
-        AlonzoEraOnwardsDijkstra -> pConwayDatumFunctionality <|> pure TxOutDatumByNone
-    )
+pTxOutDatum = \case
+  ShelleyBasedEraShelley -> pure TxOutDatumByNone
+  ShelleyBasedEraAllegra -> pure TxOutDatumByNone
+  ShelleyBasedEraMary -> pure TxOutDatumByNone
+  ShelleyBasedEraAlonzo -> pAlonzoDatumFunctionality <|> pure TxOutDatumByNone
+  ShelleyBasedEraBabbage -> pBabbageDatumFunctionality <|> pure TxOutDatumByNone
+  ShelleyBasedEraConway -> pConwayDatumFunctionality <|> pure TxOutDatumByNone
+  ShelleyBasedEraDijkstra -> pConwayDatumFunctionality <|> pure TxOutDatumByNone
  where
   pAlonzoDatumFunctionality =
     asum
@@ -151,21 +159,78 @@ pTxOutDatum sbe =
         "The script datum to embed in the tx output as an inline datum, in the given file."
 
 pRefScriptFp :: ShelleyBasedEra era -> Parser ReferenceScriptAnyEra
-pRefScriptFp =
-  inEonForShelleyBasedEra @ConwayEraOnwards
-    (pure ReferenceScriptAnyEraNone)
-    ( const $
-        ReferenceScriptAnyEra
-          <$> parseFilePath "tx-out-reference-script-file" "Reference script input file."
-            <|> pure ReferenceScriptAnyEraNone
-    )
+pRefScriptFp = \case
+  ShelleyBasedEraShelley -> pure ReferenceScriptAnyEraNone
+  ShelleyBasedEraAllegra -> pure ReferenceScriptAnyEraNone
+  ShelleyBasedEraMary -> pure ReferenceScriptAnyEraNone
+  ShelleyBasedEraAlonzo -> pure ReferenceScriptAnyEraNone
+  ShelleyBasedEraBabbage -> pure ReferenceScriptAnyEraNone
+  ShelleyBasedEraConway -> pReferenceScript
+  ShelleyBasedEraDijkstra -> pReferenceScript
+ where
+  pReferenceScript =
+    ReferenceScriptAnyEra
+      <$> parseFilePath "tx-out-reference-script-file" "Reference script input file."
+        <|> pure ReferenceScriptAnyEraNone
+
+pOptionalUpdateProposalFile :: ShelleyBasedEra era -> Parser (Maybe UpdateProposalFile)
+pOptionalUpdateProposalFile = \case
+  ShelleyBasedEraShelley -> optional pUpdateProposalFile
+  ShelleyBasedEraAllegra -> optional pUpdateProposalFile
+  ShelleyBasedEraMary -> optional pUpdateProposalFile
+  ShelleyBasedEraAlonzo -> optional pUpdateProposalFile
+  ShelleyBasedEraBabbage -> optional pUpdateProposalFile
+  ShelleyBasedEraConway -> pure Nothing
+  ShelleyBasedEraDijkstra -> pure Nothing
 
 pVoteFiles
-  :: ShelleyBasedEra era
+  :: forall era
+   . ShelleyBasedEra era
   -> BalanceTxExecUnits
   -> Parser [(VoteFile In, Maybe AnyNonAssetScript)]
 pVoteFiles sbe bExUnits =
-  inEonForShelleyBasedEra @ConwayEraOnwards
-    (pure [])
-    (const . many $ pVoteFile bExUnits)
-    sbe
+  case sbe of
+    ShelleyBasedEraShelley -> pure []
+    ShelleyBasedEraAllegra -> pure []
+    ShelleyBasedEraMary -> pure []
+    ShelleyBasedEraAlonzo -> pure []
+    ShelleyBasedEraBabbage -> pure []
+    ShelleyBasedEraConway -> pVoteFilesForEra (Exp.useEra @era) bExUnits
+    ShelleyBasedEraDijkstra -> pVoteFilesForEra (Exp.useEra @era) bExUnits
+
+pProposalFiles
+  :: forall era
+   . ShelleyBasedEra era
+  -> BalanceTxExecUnits
+  -> Parser [(ProposalFile In, Maybe AnyNonAssetScript)]
+pProposalFiles sbe bExUnits =
+  case sbe of
+    ShelleyBasedEraShelley -> pure []
+    ShelleyBasedEraAllegra -> pure []
+    ShelleyBasedEraMary -> pure []
+    ShelleyBasedEraAlonzo -> pure []
+    ShelleyBasedEraBabbage -> pure []
+    ShelleyBasedEraConway -> pProposalFilesForEra (Exp.useEra @era) bExUnits
+    ShelleyBasedEraDijkstra -> pProposalFilesForEra (Exp.useEra @era) bExUnits
+
+pCertificateFiles
+  :: forall era
+   . ShelleyBasedEra era
+  -> BalanceTxExecUnits
+  -> Parser [(CertificateFile, Maybe AnyNonAssetScript)]
+pCertificateFiles sbe bExUnits =
+  many $ case sbe of
+    ShelleyBasedEraShelley -> pCertificateFile
+    ShelleyBasedEraAllegra -> pCertificateFile
+    ShelleyBasedEraMary -> pCertificateFile
+    ShelleyBasedEraAlonzo -> pCertificateFile
+    ShelleyBasedEraBabbage -> pCertificateFile
+    ShelleyBasedEraConway -> pCertificateFileForEra (Exp.useEra @era) bExUnits
+    ShelleyBasedEraDijkstra -> pCertificateFileForEra (Exp.useEra @era) bExUnits
+ where
+  pCertificateFile :: Parser (CertificateFile, Maybe AnyNonAssetScript)
+  pCertificateFile =
+    pCertificateFileWithPlutusReferenceLanguage
+      (pAnyPlutusSLanguage "certificate-")
+      "the use of the certificate."
+      bExUnits

cardano-cli/src/Cardano/CLI/Compatible/Transaction/Run.hs

@@ -5,6 +5,7 @@
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}
+{-# LANGUAGE TypeApplications #-}
 
 module Cardano.CLI.Compatible.Transaction.Run
   ( runCompatibleTransactionCmd
@@ -42,6 +43,7 @@ import Data.Aeson qualified as Aeson
 import Data.Bifunctor (first)
 import Data.Map.Ordered.Strict qualified as OMap
 import Data.Map.Strict qualified as Map
+import Data.Maybe (fromMaybe)
 import Data.Text qualified as Text
 import Lens.Micro
 
@@ -53,9 +55,10 @@ runCompatibleTransactionCmd
   ( CreateCompatibleSignedTransaction
       sbe
       ins
+      insCollateral
       outs
       mUpdateProposal
-      mProposalProcedure
+      proposals
       mVotes
       witnesses
       mNetworkId
@@ -84,28 +87,24 @@ runCompatibleTransactionCmd
 
     (protocolUpdates, votes) :: (AnyProtocolUpdate era, AnyVote era) <-
       inEonForShelleyBasedEra
-        ( case mUpdateProposal of
-            Nothing -> return (NoPParamsUpdate sbe, NoVotes)
-            Just p -> do
-              pparamUpdate <- readUpdateProposalFile p
-              return (pparamUpdate, NoVotes)
+        ( do
+            pparamUpdate <-
+              fromMaybe (NoPParamsUpdate sbe) <$> forM mUpdateProposal (readUpdateProposalFile sbe)
+            return (pparamUpdate, NoVotes)
         )
-        ( \w ->
-            case mProposalProcedure of
-              Nothing -> return (NoPParamsUpdate sbe, NoVotes)
-              Just prop -> do
-                pparamUpdate <- readProposalProcedureFile prop
-                votesAndWits :: [(OldApi.VotingProcedures era, Exp.AnyWitness (Exp.LedgerEra era))] <-
-                  obtainCommonConstraints (convert w) $ readVotingProceduresFiles mVotes
-                votingProcedures :: (Exp.TxVotingProcedures (Exp.LedgerEra era)) <-
-                  obtainCommonConstraints (convert w) $
-                    fromEitherCli
-                      ( Exp.mkTxVotingProcedures
-                          [ (obtainCommonConstraints (convert w) $ OldApi.unVotingProcedures vp, anyW)
-                          | (vp, anyW) <- votesAndWits
-                          ]
-                      )
-                return (pparamUpdate, VotingProcedures w $ obtainCommonConstraints (convert w) votingProcedures)
+        ( \w -> do
+            pparamUpdate <- readProposalProcedureFile sbe proposals
+            votesAndWits :: [(OldApi.VotingProcedures era, Exp.AnyWitness (Exp.LedgerEra era))] <-
+              obtainCommonConstraints (convert w) $ readVotingProceduresFiles mVotes
+            votingProcedures :: (Exp.TxVotingProcedures (Exp.LedgerEra era)) <-
+              obtainCommonConstraints (convert w) $
+                fromEitherCli
+                  ( Exp.mkTxVotingProcedures
+                      [ (obtainCommonConstraints (convert w) $ OldApi.unVotingProcedures vp, anyW)
+                      | (vp, anyW) <- votesAndWits
+                      ]
+                  )
+            return (pparamUpdate, VotingProcedures w $ obtainCommonConstraints (convert w) votingProcedures)
         )
         sbe
 
@@ -126,6 +125,7 @@ runCompatibleTransactionCmd
             , compatibleTxProtocolUpdate = protocolUpdates
             , compatibleTxVotingProcedures = votes
             , compatibleTxCertificates = txCerts
+            , compatibleTxInsCollateral = insCollateral
             , compatibleTxProtocolParams = pparams
             }
 
@@ -235,31 +235,49 @@ mkTxCertificatesSbe era certs = Exp.TxCertificates . OMap.fromList $ map attachW
     (c, wit <$ Compatible.getTxCertWitness (convert era) cert)
 
 readUpdateProposalFile
-  :: Featured ShelleyToBabbageEra era (Maybe UpdateProposalFile)
+  :: forall e era
+   . ShelleyBasedEra era
+  -> UpdateProposalFile
   -> CIO e (AnyProtocolUpdate era)
-readUpdateProposalFile (Featured sToB Nothing) =
-  return $ NoPParamsUpdate $ convert sToB
-readUpdateProposalFile (Featured sToB (Just updateProposalFile)) = do
-  prop <-
-    fromExceptTCli $ readTxUpdateProposal sToB updateProposalFile
-  case prop of
-    TxUpdateProposalNone -> return $ NoPParamsUpdate $ convert sToB
-    TxUpdateProposal _ proposal -> return $ ProtocolUpdate sToB proposal
+readUpdateProposalFile sbe (UpdateProposalFile file) =
+  case sbe of
+    ShelleyBasedEraShelley -> ProtocolUpdate ShelleyToBabbageEraShelley <$> readUpdateProposal
+    ShelleyBasedEraAllegra -> ProtocolUpdate ShelleyToBabbageEraAllegra <$> readUpdateProposal
+    ShelleyBasedEraMary -> ProtocolUpdate ShelleyToBabbageEraMary <$> readUpdateProposal
+    ShelleyBasedEraAlonzo -> ProtocolUpdate ShelleyToBabbageEraAlonzo <$> readUpdateProposal
+    ShelleyBasedEraBabbage -> ProtocolUpdate ShelleyToBabbageEraBabbage <$> readUpdateProposal
+    ShelleyBasedEraConway -> pure $ NoPParamsUpdate sbe
+    ShelleyBasedEraDijkstra -> pure $ NoPParamsUpdate sbe
+ where
+  readUpdateProposal :: CIO e (UpdateProposal era)
+  readUpdateProposal =
+    fromEitherIOCli @(FileError TextEnvelopeError) $
+      shelleyBasedEraConstraints sbe $
+        readFileTextEnvelope (File file)
 
 readProposalProcedureFile
   :: forall e era
-   . Featured ConwayEraOnwards era [(ProposalFile In, Maybe AnyNonAssetScript)]
+   . ShelleyBasedEra era
+  -> [(ProposalFile In, Maybe AnyNonAssetScript)]
   -> CIO e (AnyProtocolUpdate era)
-readProposalProcedureFile (Featured cEraOnwards []) =
-  let sbe = convert cEraOnwards
-   in return $ NoPParamsUpdate sbe
-readProposalProcedureFile (Featured cEraOnwards proposals) = do
-  let era = convert cEraOnwards
-  props :: [(Proposal era, Exp.AnyWitness (Exp.LedgerEra era))] <-
-    Exp.obtainCommonConstraints era $ mapM readProposal proposals
-
-  return $
-    Exp.obtainCommonConstraints era $
-      ProposalProcedures cEraOnwards $
-        Exp.mkTxProposalProcedures
-          [(govProp, swit) | (Proposal govProp, swit) <- props]
+readProposalProcedureFile sbe [] = return $ NoPParamsUpdate sbe
+readProposalProcedureFile sbe proposals =
+  case sbe of
+    ShelleyBasedEraShelley -> return $ NoPParamsUpdate sbe
+    ShelleyBasedEraAllegra -> return $ NoPParamsUpdate sbe
+    ShelleyBasedEraMary -> return $ NoPParamsUpdate sbe
+    ShelleyBasedEraAlonzo -> return $ NoPParamsUpdate sbe
+    ShelleyBasedEraBabbage -> return $ NoPParamsUpdate sbe
+    ShelleyBasedEraConway -> ProposalProcedures ConwayEraOnwardsConway <$> readProcedures
+    ShelleyBasedEraDijkstra -> ProposalProcedures ConwayEraOnwardsDijkstra <$> readProcedures
+ where
+  readProcedures
+    :: forall era'
+     . Exp.IsEra era'
+    => CIO e (Exp.TxProposalProcedures (ShelleyLedgerEra era'))
+  readProcedures = Exp.obtainCommonConstraints (Exp.useEra @era') $ do
+    props :: [(Proposal era', Exp.AnyWitness (Exp.LedgerEra era'))] <-
+      mapM readProposal proposals
+    pure $
+      Exp.mkTxProposalProcedures
+        [(govProp, swit) | (Proposal govProp, swit) <- props]