From fff6cf5c1ebdfc20ef689a010293a64ce0a0603f Mon Sep 17 00:00:00 2001 From: Martin Kourim Date: Thu, 12 Mar 2026 18:16:23 +0100 Subject: [PATCH] test(conway): reject legacy certificates and proposals in Conway era - Add negative tests to ensure legacy stake address registration, delegation, pool registration, governance proposals, and MIR certificates are rejected in Conway. - Parametrize tests across all compatible legacy eras (Shelley, Allegra, Mary, Alonzo, Babbage). - Expect transaction submission to fail with a "TextEnvelope type error" or era mismatch error. - Remove obsolete tests for legacy proposal build with Conway CLI. - Add issue marker for cli issue 1347 (Compat stake reg cert accepted without deposit amount). --- cardano_node_tests/tests/issues.py | 6 + .../tests/test_addr_registration.py | 52 ++++++++ cardano_node_tests/tests/test_delegation.py | 73 +++++++++++ cardano_node_tests/tests/test_pools.py | 87 ++++++++++++- .../tests/tests_conway/test_conway.py | 59 +++++++++ .../tests/tests_conway/test_pparam_update.py | 106 ++++------------ .../tests_conway/test_treasury_withdrawals.py | 115 +++++++----------- 7 files changed, 348 insertions(+), 150 deletions(-) diff --git a/cardano_node_tests/tests/issues.py b/cardano_node_tests/tests/issues.py index 21844580b..a3711ee18 100644 --- a/cardano_node_tests/tests/issues.py +++ b/cardano_node_tests/tests/issues.py @@ -121,6 +121,12 @@ fixed_in="10.15.0.1", # Fixed in release after 10.15.0.1 message="Cannot get policyid for SimpleScript reference script.", ) +cli_1347 = blockers.GH( + issue=1347, + repo="IntersectMBO/cardano-cli", + fixed_in="10.15.0.1", # Fixed in some release after 10.15.0.1 + message="Compat stake reg cert accepted without deposit amount.", +) consensus_973 = blockers.GH( issue=973, diff --git a/cardano_node_tests/tests/test_addr_registration.py b/cardano_node_tests/tests/test_addr_registration.py index 5fe8da683..6ee92465b 100644 --- a/cardano_node_tests/tests/test_addr_registration.py +++ b/cardano_node_tests/tests/test_addr_registration.py @@ -6,6 +6,7 @@ import allure import pytest from cardano_clusterlib import clusterlib +from packaging import version from cardano_node_tests.cluster_management import cluster_management from cardano_node_tests.tests import common @@ -813,3 +814,54 @@ def _submit_tx( else: err = f"Invalid issue: {issue}" raise ValueError(err) + + @allure.link(helpers.get_vcs_link()) + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) + @pytest.mark.testnets + @pytest.mark.smoke + def test_legacy_stake_addr_registration_rejected_in_conway( + self, + cluster: clusterlib.ClusterLib, + pool_users: list[clusterlib.PoolUser], + pool_users_disposable: list[clusterlib.PoolUser], + era: str, + ): + """Reject legacy stake address registration in Conway. + + * Generate a stake address registration certificate using the compatible CLI + for a legacy era. + * Attempt to submit the legacy certificate in a Conway-era transaction. + * Expect the transaction submission to fail with a TextEnvelope type error. + """ + temp_template = common.get_test_id(cluster) + + era_api = getattr(cluster.g_compatible, era) + legacy_stake_reg_cert = era_api.stake_address.gen_registration_cert( + name=f"{temp_template}_{era}", + stake_vkey_file=pool_users_disposable[0].stake.vkey_file, + ) + tx_files = clusterlib.TxFiles( + certificate_files=[legacy_stake_reg_cert], + signing_key_files=[ + pool_users[0].payment.skey_file, + pool_users_disposable[0].stake.skey_file, + ], + ) + + err_str = "" + try: + cluster.g_transaction.send_tx( + src_address=pool_users[0].payment.address, + tx_name=f"{temp_template}_{era}_legacy_stake_reg", + tx_files=tx_files, + ) + except clusterlib.CLIError as exc: + err_str = str(exc) + + if not err_str and VERSIONS.cli >= version.parse("10.14.0.0"): + issues.cli_1347.finish_test() + + assert err_str, "Expected transaction submission to fail, but it succeeded" + + with common.allow_unstable_error_messages(): + assert "TextEnvelope type error" in err_str, err_str diff --git a/cardano_node_tests/tests/test_delegation.py b/cardano_node_tests/tests/test_delegation.py index ebaaf98b8..26b880247 100644 --- a/cardano_node_tests/tests/test_delegation.py +++ b/cardano_node_tests/tests/test_delegation.py @@ -5,6 +5,7 @@ import allure import pytest from cardano_clusterlib import clusterlib +from packaging import version from cardano_node_tests.cluster_management import cluster_management from cardano_node_tests.cluster_management import resources_management @@ -15,6 +16,7 @@ from cardano_node_tests.utils import dbsync_utils from cardano_node_tests.utils import helpers from cardano_node_tests.utils import tx_view +from cardano_node_tests.utils.versions import VERSIONS LOGGER = logging.getLogger(__name__) @@ -1316,3 +1318,74 @@ def test_delegatee_not_registered( "DelegateeNotRegisteredDELEG" in exc_value # Before cardano-node 10.0.0 or "DelegateeStakePoolNotRegisteredDELEG" in exc_value ), exc_value + + @allure.link(helpers.get_vcs_link()) + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) + @pytest.mark.testnets + @pytest.mark.smoke + def test_legacy_stake_delegation_rejected_in_conway( + self, + cluster: clusterlib.ClusterLib, + pool_users: list[clusterlib.PoolUser], + pool_users_disposable: list[clusterlib.PoolUser], + era: str, + ): + """Reject legacy stake address delegation in Conway. + + * Register stake address using Conway-era commands. + * Generate a stake address delegation certificate using the compatible CLI + for a legacy era. + * Attempt to submit the legacy certificate in a Conway-era transaction. + * Expect the transaction submission to fail with a TextEnvelope type error. + """ + temp_template = common.get_test_id(cluster) + + user_registered = pool_users_disposable[0] + user_payment = pool_users[0].payment + + # Register stake address using Conway commands + clusterlib_utils.register_stake_address( + cluster_obj=cluster, + pool_user=clusterlib.PoolUser(payment=user_payment, stake=user_registered.stake), + name_template=f"{temp_template}_{era}_reg", + deposit_amt=cluster.g_query.get_address_deposit(), + ) + + # Use an existing registered pool + pool_ids = cluster.g_query.get_stake_pools() + assert pool_ids, "No registered stake pools available on this testnet" + pool_id = pool_ids[0] + + # Generate legacy delegation cert via compatible CLI + era_api = getattr(cluster.g_compatible, era) + legacy_stake_deleg_cert = era_api.stake_address.gen_delegation_cert( + name=f"{temp_template}_{era}", + stake_vkey_file=user_registered.stake.vkey_file, + stake_pool_id=pool_id, + ) + + tx_files = clusterlib.TxFiles( + certificate_files=[legacy_stake_deleg_cert], + signing_key_files=[ + pool_users[0].payment.skey_file, + user_registered.stake.skey_file, + ], + ) + + err_str = "" + try: + cluster.g_transaction.send_tx( + src_address=pool_users[0].payment.address, + tx_name=f"{temp_template}_{era}_legacy_deleg", + tx_files=tx_files, + ) + except clusterlib.CLIError as exc: + err_str = str(exc) + + if not err_str and VERSIONS.cli >= version.parse("10.14.0.0"): + issues.cli_1347.finish_test() + + assert err_str, "Expected transaction submission to fail, but it succeeded" + + with common.allow_unstable_error_messages(): + assert "TextEnvelope type error" in err_str, err_str diff --git a/cardano_node_tests/tests/test_pools.py b/cardano_node_tests/tests/test_pools.py index 257d2eeb2..24f655353 100644 --- a/cardano_node_tests/tests/test_pools.py +++ b/cardano_node_tests/tests/test_pools.py @@ -20,6 +20,7 @@ import pytest_subtests from _pytest.fixtures import FixtureRequest from cardano_clusterlib import clusterlib +from packaging import version from cardano_node_tests.cluster_management import cluster_management from cardano_node_tests.tests import common @@ -2047,7 +2048,8 @@ def pool_users( num=2, fund_idx=[0], caching_key=helpers.get_current_line_str(), - amount=600_000_000, + amount=900_000_000, + min_amount=600_000_000, ) return created_users @@ -2607,6 +2609,89 @@ def test_stake_pool_long_metadata_url( in exc_value ) + @allure.link(helpers.get_vcs_link()) + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) + @pytest.mark.testnets + @pytest.mark.smoke + def test_legacy_pool_registration_rejected_in_conway( + self, + cluster: clusterlib.ClusterLib, + pool_users: list[clusterlib.PoolUser], + testfile_temp_dir: pl.Path, + era: str, + request: FixtureRequest, + ): + """Reject legacy stake pool registration in Conway. + + * Generate a stake pool registration certificate using the compatible CLI + for a legacy era. + * Attempt to submit the legacy certificate in a Conway-era transaction. + * Expect the transaction submission to fail with a TextEnvelope type error. + """ + rand_str = clusterlib.get_rand_str(4) + temp_template = f"{common.get_test_id(cluster)}_{rand_str}" + + node_vrf = cluster.g_node.gen_vrf_key_pair(f"{temp_template}_{era}_vrf") + node_cold = cluster.g_node.gen_cold_key_pair_and_counter(f"{temp_template}_{era}_cold") + + pool_data = clusterlib.PoolData( + pool_name=f"pool_{rand_str}", + pool_pledge=5, + pool_cost=cluster.g_query.get_protocol_params().get("minPoolCost", 500), + pool_margin=0.01, + ) + + era_api = getattr(cluster.g_compatible, era) + legacy_pool_reg_cert = era_api.stake_pool.gen_registration_cert( + name=f"{temp_template}_{era}", + pool_data=pool_data, + vrf_vkey_file=node_vrf.vkey_file, + cold_vkey_file=node_cold.vkey_file, + owner_stake_vkey_files=[pool_users[0].stake.vkey_file], + ) + + tx_files = clusterlib.TxFiles( + certificate_files=[legacy_pool_reg_cert], + signing_key_files=[ + pool_users[0].payment.skey_file, + pool_users[0].stake.skey_file, + node_cold.skey_file, + ], + ) + + err_str = "" + try: + cluster.g_transaction.send_tx( + src_address=pool_users[0].payment.address, + tx_name=f"{temp_template}_{era}_legacy_pool_reg", + tx_files=tx_files, + ) + except clusterlib.CLIError as exc: + err_str = str(exc) + + # Deregister stake pool in case it was unexpectedly registered + def _deregister(): + depoch = 1 if cluster.time_to_epoch_end() >= DEREG_BUFFER_SEC else 2 + with helpers.change_cwd(testfile_temp_dir): + cluster.g_stake_pool.deregister_stake_pool( + pool_owners=pool_users, + cold_key_pair=node_cold, + epoch=cluster.g_query.get_epoch() + depoch, + pool_name=pool_data.pool_name, + tx_name=f"{temp_template}_cleanup", + ) + + if not err_str: + request.addfinalizer(_deregister) + + if not err_str and VERSIONS.cli >= version.parse("10.14.0.0"): + issues.cli_1347.finish_test() + + assert err_str, "Expected transaction submission to fail, but it succeeded" + + with common.allow_unstable_error_messages(): + assert "TextEnvelope type error" in err_str, err_str + @pytest.mark.skipif( VERSIONS.transaction_era < VERSIONS.CONWAY, reason="runs only with Tx era >= Conway" diff --git a/cardano_node_tests/tests/tests_conway/test_conway.py b/cardano_node_tests/tests/tests_conway/test_conway.py index fa8aa0cfe..595c09e09 100644 --- a/cardano_node_tests/tests/tests_conway/test_conway.py +++ b/cardano_node_tests/tests/tests_conway/test_conway.py @@ -208,3 +208,62 @@ def test_ratify_state_fields(self, cluster: clusterlib.ClusterLib): missing = expected_fields - set(ratify_state) assert not missing, f"Missing expected fields in ratify-state: {missing}" + + +class TestNegativeLegacyGovernance: + @allure.link(helpers.get_vcs_link()) + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) + @pytest.mark.smoke + def test_mixed_legacy_govaction_and_conway_vote_cert_fails( + self, + cluster: clusterlib.ClusterLib, + pool_user: clusterlib.PoolUser, + era: str, + ): + """Reject mixed legacy governance action and Conway vote delegation. + + * Generate a legacy governance action using the compatible CLI. + * Generate a Conway-era stake and vote delegation certificate. + * Submit both certificates in a single Conway-era transaction. + * Expect the transaction submission to fail with a TextEnvelope type error. + """ + temp_template = common.get_test_id(cluster) + + payment_rec = pool_user.payment + stake_rec = pool_user.stake + + pool_ids = cluster.g_query.get_stake_pools() + assert pool_ids, "No stake pools available on this testnet" + pool_id = pool_ids[0] + + era_api = getattr(cluster.g_compatible, era) + legacy_prop = era_api.governance.gen_pparams_update( + name=f"{temp_template}_era", + epoch=cluster.g_query.get_epoch(), + genesis_vkey_file=cluster.g_genesis.genesis_keys.genesis_vkeys[0], + cli_args=["--max-block-body-size", "65536"], + ) + + deleg_cert = cluster.g_stake_address.gen_stake_and_vote_delegation_cert( + addr_name=temp_template, + stake_vkey_file=stake_rec.vkey_file, + stake_pool_id=pool_id, + always_abstain=True, + ) + + tx_files = clusterlib.TxFiles( + certificate_files=[deleg_cert], + proposal_files=[legacy_prop], + signing_key_files=[payment_rec.skey_file, stake_rec.skey_file], + ) + + with pytest.raises(clusterlib.CLIError) as excinfo: + cluster.g_transaction.send_tx( + src_address=payment_rec.address, + tx_name=f"{temp_template}_mixed_fail", + tx_files=tx_files, + ) + + exc_value = str(excinfo.value) + with common.allow_unstable_error_messages(): + assert "TextEnvelope type error" in exc_value, exc_value diff --git a/cardano_node_tests/tests/tests_conway/test_pparam_update.py b/cardano_node_tests/tests/tests_conway/test_pparam_update.py index c4bf010a4..dfa573e44 100644 --- a/cardano_node_tests/tests/tests_conway/test_pparam_update.py +++ b/cardano_node_tests/tests/tests_conway/test_pparam_update.py @@ -1460,57 +1460,51 @@ def test_pparam_keys( class TestLegacyProposals: """Tests for legacy update proposals in Conway.""" - @pytest.fixture(scope="class") - def skip_on_missing_legacy(self) -> None: - if not clusterlib_utils.cli_has("legacy governance"): - pytest.skip("`legacy governance` commands are not available") - @allure.link(helpers.get_vcs_link()) @submit_utils.PARAM_SUBMIT_METHOD + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) @pytest.mark.smoke def test_legacy_proposal_submit( self, - skip_on_missing_legacy: None, # noqa: ARG002 cluster: clusterlib.ClusterLib, payment_addr: clusterlib.AddressRecord, submit_method: str, + era: str, ): - """Test submitting a legacy update proposal in Conway. + """Reject legacy update proposal submission in Conway. - Expect failure as the legacy update proposals are not supported in Conway. + * Generate a legacy update proposal using the compatible CLI. + * Attempt to submit the proposal in a Conway-era transaction. + * Expect the transaction submission to fail with a TextEnvelope type error. """ - # TODO: convert to use - # `compatible babbage governance action create-protocol-parameters-update` + era_valid_pparam = { + "shelley": ("--max-block-body-size", 65536, "maxBlockBodySize"), + "allegra": ("--max-block-body-size", 65536, "maxBlockBodySize"), + "mary": ("--max-block-body-size", 65536, "maxBlockBodySize"), + "alonzo": ("--max-collateral-inputs", 4, "maxCollateralInputs"), + "babbage": ("--max-collateral-inputs", 4, "maxCollateralInputs"), + } + temp_template = common.get_test_id(cluster) + arg, val, name = era_valid_pparam[era] + update_proposals = [ clusterlib_utils.UpdateProposal( - arg="--max-collateral-inputs", - value=4, - name="maxCollateralInputs", + arg=arg, + value=val, + name=name, ), ] cli_args = clusterlib_utils.get_pparams_update_args(update_proposals=update_proposals) - out_file = f"{temp_template}_update.proposal" - cluster.cli( - [ - "cardano-cli", - "legacy", - "governance", - "create-update-proposal", - *cli_args, - "--out-file", - str(out_file), - "--epoch", - str(cluster.g_query.get_epoch()), - *helpers.prepend_flag( - "--genesis-verification-key-file", - cluster.g_genesis.genesis_keys.genesis_vkeys, - ), - ], - add_default_args=False, + era_api = getattr(cluster.g_compatible, era) + action_file = era_api.governance.gen_pparams_update( + name=f"{temp_template}_era", + epoch=cluster.g_query.get_epoch(), + genesis_vkey_file=cluster.g_genesis.genesis_keys.genesis_vkeys[0], + cli_args=cli_args, ) with pytest.raises((clusterlib.CLIError, submit_api.SubmitApiError)) as excinfo: @@ -1520,7 +1514,7 @@ def test_legacy_proposal_submit( src_address=payment_addr.address, submit_method=submit_method, tx_files=clusterlib.TxFiles( - proposal_files=[out_file], + proposal_files=[action_file], signing_key_files=[ *cluster.g_genesis.genesis_keys.delegate_skeys, pl.Path(payment_addr.skey_file), @@ -1529,53 +1523,7 @@ def test_legacy_proposal_submit( ) exc_value = str(excinfo.value) with common.allow_unstable_error_messages(): - assert 'TextEnvelopeType "UpdateProposalShelley"' in exc_value, exc_value - - @allure.link(helpers.get_vcs_link()) - @pytest.mark.smoke - def test_legacy_proposal_build( - self, - cluster: clusterlib.ClusterLib, - ): - """Test building a legacy update proposal with Conway cardano-cli. - - Expect failure as the legacy update proposals are not supported in Conway. - """ - temp_template = common.get_test_id(cluster) - - update_proposals = [ - clusterlib_utils.UpdateProposal( - arg="--max-collateral-inputs", - value=4, - name="maxCollateralInputs", - ), - ] - - cli_args = clusterlib_utils.get_pparams_update_args(update_proposals=update_proposals) - out_file = f"{temp_template}_update.proposal" - - with pytest.raises(clusterlib.CLIError) as excinfo: - cluster.cli( - [ - "cardano-cli", - "conway", - "governance", - "create-update-proposal", - *cli_args, - "--out-file", - str(out_file), - "--epoch", - str(cluster.g_query.get_epoch()), - *helpers.prepend_flag( - "--genesis-verification-key-file", - cluster.g_genesis.genesis_keys.genesis_vkeys, - ), - ], - add_default_args=False, - ) - exc_value = str(excinfo.value) - with common.allow_unstable_error_messages(): - assert "Invalid argument `create-update-proposal'" in exc_value, exc_value + assert "TextEnvelope type error" in exc_value, exc_value class TestNegativeCostModels: diff --git a/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py b/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py index f0f64b901..daa327bca 100644 --- a/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py +++ b/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py @@ -11,7 +11,6 @@ from cardano_node_tests.tests import common from cardano_node_tests.tests import reqs_conway as reqc from cardano_node_tests.tests.tests_conway import conway_common -from cardano_node_tests.utils import cluster_nodes from cardano_node_tests.utils import clusterlib_utils from cardano_node_tests.utils import configuration from cardano_node_tests.utils import dbsync_utils @@ -724,83 +723,67 @@ def test_expire_treasury_withdrawals( class TestMIRCerts: - """Tests for MIR certificates.""" - - @pytest.fixture(scope="class") - def skip_on_missing_legacy(self) -> None: - if not clusterlib_utils.cli_has("legacy governance"): - pytest.skip("`legacy governance` commands are not available") + """Tests for MIR certificates in all compatible eras.""" @pytest.fixture - def payment_addr( - self, - skip_on_missing_legacy: None, # noqa: ARG002 - cluster_manager: cluster_management.ClusterManager, - cluster: clusterlib.ClusterLib, - ) -> clusterlib.AddressRecord: - """Create new payment address.""" - addr = common.get_payment_addr( + def payment_addr(self, cluster_manager, cluster): + return common.get_payment_addr( name_template=common.get_test_id(cluster), cluster_manager=cluster_manager, cluster_obj=cluster, caching_key=helpers.get_current_line_str(), amount=4_000_000, ) - return addr @allure.link(helpers.get_vcs_link()) + @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage")) @pytest.mark.parametrize( - "mir_cert", ("to_treasury", "to_rewards", "treasury_to_addr", "reserves_to_addr") + "mir_cert", + ("to_treasury", "to_rewards", "treasury_to_addr", "reserves_to_addr"), ) - @pytest.mark.smoke - def test_mir_certificates( - self, - skip_on_missing_legacy: None, # noqa: ARG002 - cluster: clusterlib.ClusterLib, - payment_addr: clusterlib.AddressRecord, - mir_cert: str, - ): - """Try to use MIR certificates in Conway+ eras. - - Expect failure. + def test_mir_certificates(self, cluster, payment_addr, era, mir_cert): + """Try each MIR certificate across all compatible eras. * Try and fail to build the Tx using `transaction build` - * Successfully build the Tx as Babbage Tx using `transaction build-raw` - * Try and fail to submit the Babbage Tx + * Compatible-era signed transaction builds successfully. + * Submitting a non-Conway transaction in Conway fails due to era mismatch. """ - # TODO: convert to use `compatible babbage governance create-mir-certificate` temp_template = common.get_test_id(cluster) amount = 1_500_000 reqc.cip070.start(url=helpers.get_vcs_link()) + # Get compatible governance for selected era dynamically + gov = getattr(cluster.g_compatible, era).governance + + # Generate cert based on MIR type if mir_cert == "to_treasury": - cert_file = cluster.g_legacy_governance.gen_mir_cert_to_treasury( + cert_file = gov.gen_mir_cert_to_treasury( + name=temp_template, transfer=amount, - tx_name=temp_template, ) elif mir_cert == "to_rewards": - cert_file = cluster.g_legacy_governance.gen_mir_cert_to_rewards( + cert_file = gov.gen_mir_cert_to_rewards( + name=temp_template, transfer=amount, - tx_name=temp_template, ) elif mir_cert == "treasury_to_addr": - cert_file = cluster.g_legacy_governance.gen_mir_cert_stake_addr( - tx_name=temp_template, - stake_addr="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt", + cert_file = gov.gen_mir_cert_stake_addr( + name=temp_template, + stake_address="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt", reward=amount, use_treasury=True, ) elif mir_cert == "reserves_to_addr": - cert_file = cluster.g_legacy_governance.gen_mir_cert_stake_addr( - tx_name=temp_template, - stake_addr="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt", + cert_file = gov.gen_mir_cert_stake_addr( + name=temp_template, + stake_address="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt", reward=amount, use_treasury=False, ) else: - _verr = f"Unknown MIR cert scenario: {mir_cert}" - raise ValueError(_verr) + msg = f"Unknown MIR certificate type: {mir_cert}" + raise ValueError(msg) tx_files = clusterlib.TxFiles( certificate_files=[cert_file], @@ -810,7 +793,6 @@ def test_mir_certificates( ], ) - # The Tx cannot be build in Conway using `build` with pytest.raises(clusterlib.CLIError) as excinfo: cluster.g_transaction.build_tx( tx_name=temp_template, @@ -819,33 +801,26 @@ def test_mir_certificates( ) err_build = str(excinfo.value) with common.allow_unstable_error_messages(): - assert "TextEnvelope type error:" in err_build, err_build - - # The Tx can be build as Babbage Tx using `build-raw`, but cannot be submitted. - # TODO: convert to use `compatible babbage transaction signed-transaction` - if clusterlib_utils.cli_has("babbage transaction build-raw"): - cluster_babbage = cluster_nodes.get_cluster_type().get_cluster_obj( - command_era="babbage" - ) - tx_output = cluster_babbage.g_transaction.build_raw_tx( - tx_name=temp_template, - src_address=payment_addr.address, - fee=400_000, - tx_files=tx_files, - ) + assert "MIR certificates are no longer supported" in err_build, err_build + + # Build signed tx using compatible transaction command + tx_builder = getattr(cluster.g_compatible, era).transaction + signed_tx = tx_builder.gen_signed_tx( + name=temp_template, + src_address=payment_addr.address, + txouts=[], + tx_files=tx_files, + fee=400_000, + ) - out_file_signed = cluster.g_transaction.sign_tx( - tx_body_file=tx_output.out_file, - signing_key_files=tx_files.signing_key_files, - tx_name=temp_template, + # Submitting non-Conway tx in Conway MUST fail + with pytest.raises(clusterlib.CLIError) as excinfo: + cluster.g_transaction.submit_tx( + tx_file=signed_tx.out_file, + txins=signed_tx.txins, ) - - with pytest.raises(clusterlib.CLIError) as excinfo: - cluster.g_transaction.submit_tx(tx_file=out_file_signed, txins=tx_output.txins) - err_submit = str(excinfo.value) - with common.allow_unstable_error_messages(): - assert "Error: The era of the node and the tx do not match." in err_submit, ( - err_submit - ) + err_submit = str(excinfo.value) + with common.allow_unstable_error_messages(): + assert "era" in err_submit or "mismatch" in err_submit, err_submit reqc.cip070.success()