refactor(blocks): use "forged" instead of "minted" terminology

Update tests and utilities to consistently use "forged" instead of "minted"
when referring to block creation. This aligns terminology with Cardano
node logs and documentation.

Author: mkoura

cardano_node_tests/tests/test_blocks.py

@@ -45,14 +45,14 @@ def test_pool_blocks(  # noqa: C901
         cluster_use_pool: tuple[clusterlib.ClusterLib, str],
         for_epoch: str,
     ):
-        """Check that blocks were minted according to leadership schedule.
+        """Check that blocks were forged according to leadership schedule.
 
         * query leadership schedule for selected pool for current epoch or next epoch
         * wait for epoch that comes after the queried epoch
-        * get info about minted blocks in queried epoch for the selected pool
-        * compare leadership schedule with blocks that were actually minted
+        * get info about forged blocks in queried epoch for the selected pool
+        * compare leadership schedule with blocks that were actually forged
         * compare log records with ledger state dump
-        * (optional) check minted blocks in db-sync
+        * (optional) check forged blocks in db-sync
         """
         cluster, pool_name = cluster_use_pool
         pool_short_name = f"{pool_name.replace('node-', '')}"
@@ -94,7 +94,7 @@ def test_pool_blocks(  # noqa: C901
         # Wait for epoch that comes after the queried epoch
         cluster.wait_for_epoch(epoch_no=queried_epoch + 1, padding_seconds=10, future_is_ok=False)
 
-        # Get number of minted blocks from ledger
+        # Get number of forged blocks from ledger
         ledger_state = clusterlib_utils.get_ledger_state(cluster_obj=cluster)
         clusterlib_utils.save_ledger_state(
             cluster_obj=cluster,
@@ -103,13 +103,13 @@ def test_pool_blocks(  # noqa: C901
         )
         blocks_before: dict[str, int] = ledger_state["blocksBefore"]
         pool_id_dec = helpers.decode_bech32(pool_id)
-        minted_blocks_ledger = blocks_before.get(pool_id_dec) or 0
+        forged_blocks_ledger = blocks_before.get(pool_id_dec) or 0
 
         errors: list[str] = []
 
         def _check_logs() -> None:
-            # Get info about minted blocks in queried epoch for the selected pool
-            minted_lines = logfiles.find_msgs_in_logs(
+            # Get info about forged blocks in queried epoch for the selected pool
+            forged_lines = logfiles.find_msgs_in_logs(
                 regex='"TraceForgedBlock"',
                 logfile=pool_log,
                 seek_offset=seek_offset,
@@ -123,67 +123,67 @@ def _check_logs() -> None:
             first_slot_queried_ep = first_slot_this_ep - (ep_num_after_queried * ep_length)
             last_slot_queried_ep = first_slot_queried_ep + ep_length - 1
             slots_pattern = re.compile(r'"slot",Number (\d+)\.0')
-            slots_when_minted = {
+            slots_when_forged = {
                 s
-                for m in minted_lines
+                for m in forged_lines
                 if (o := slots_pattern.search(m)) is not None
                 and first_slot_queried_ep <= (s := int(o.group(1))) <= last_slot_queried_ep
             }
-            with open(f"{debug_log_template}_minted.txt", "w", encoding="utf-8") as out_fp:
-                out_fp.write(f"{pool_id_dec}: {slots_when_minted}")
+            with open(f"{debug_log_template}_forged.txt", "w", encoding="utf-8") as out_fp:
+                out_fp.write(f"{pool_id_dec}: {slots_when_forged}")
 
-            # Compare leadership schedule with blocks that were actually minted
-            difference_scheduled = slots_when_minted.difference(slots_when_scheduled)
+            # Compare leadership schedule with blocks that were actually forged
+            difference_scheduled = slots_when_forged.difference(slots_when_scheduled)
             if difference_scheduled:
                 errors.append(
-                    f"Some blocks were minted in other slots than scheduled: {difference_scheduled}"
+                    f"Some blocks were forged in other slots than scheduled: {difference_scheduled}"
                 )
 
-            difference_minted = slots_when_scheduled.difference(slots_when_minted)
-            if len(difference_minted) > len(leadership_schedule) // 5:
-                errors.append(f"Lot of slots missed: {difference_minted}")
+            difference_forged = slots_when_scheduled.difference(slots_when_forged)
+            if len(difference_forged) > len(leadership_schedule) // 5:
+                errors.append(f"Lot of slots missed: {difference_forged}")
 
             # Compare log records with ledger state dump
-            minted_blocks_logs = len(slots_when_minted)
-            # Some minted block may not be adopted, and so the total number of adopted blocks
-            # may be lower than the number of minted blocks.
-            if minted_blocks_ledger > minted_blocks_logs:
+            forged_blocks_logs = len(slots_when_forged)
+            # Some forged block may not be adopted, and so the total number of adopted blocks
+            # may be lower than the number of forged blocks.
+            if forged_blocks_ledger > forged_blocks_logs:
                 errors.append(
-                    "Number of minted blocks reported by ledger state "
+                    "Number of forged blocks reported by ledger state "
                     "is higher than number extracted from log file: "
-                    f"{minted_blocks_ledger} vs {minted_blocks_logs}"
+                    f"{forged_blocks_ledger} vs {forged_blocks_logs}"
                 )
 
         def _check_dbsync() -> None:
-            # Get info about minted blocks in queried epoch for the selected pool
-            minted_blocks = list(
+            # Get info about forged blocks in queried epoch for the selected pool
+            forged_blocks = list(
                 dbsync_queries.query_blocks(
                     pool_id_bech32=pool_id, epoch_from=queried_epoch, epoch_to=queried_epoch
                 )
             )
-            slots_when_minted = {r.slot_no for r in minted_blocks}
-            with open(f"{debug_log_template}_db_minted.txt", "w", encoding="utf-8") as out_fp:
-                out_fp.write(f"{pool_id_dec}: {slots_when_minted}")
+            slots_when_forged = {r.slot_no for r in forged_blocks}
+            with open(f"{debug_log_template}_db_forged.txt", "w", encoding="utf-8") as out_fp:
+                out_fp.write(f"{pool_id_dec}: {slots_when_forged}")
 
-            # Compare leadership schedule with blocks that were actually minted
-            difference_scheduled = slots_when_minted.difference(slots_when_scheduled)
+            # Compare leadership schedule with blocks that were actually forged
+            difference_scheduled = slots_when_forged.difference(slots_when_scheduled)
             if difference_scheduled:
                 errors.append(
-                    "DB-Sync: Some blocks were minted in other slots than scheduled: "
+                    "DB-Sync: Some blocks were forged in other slots than scheduled: "
                     f"{difference_scheduled}"
                 )
 
-            difference_minted = slots_when_scheduled.difference(slots_when_minted)
-            if len(difference_minted) > len(leadership_schedule) // 3:
-                errors.append(f"DB-Sync: Lot of slots missed: {difference_minted}")
+            difference_forged = slots_when_scheduled.difference(slots_when_forged)
+            if len(difference_forged) > len(leadership_schedule) // 3:
+                errors.append(f"DB-Sync: Lot of slots missed: {difference_forged}")
 
             # Compare db-sync records with ledger state dump
-            minted_blocks_db = len(slots_when_minted)
-            if minted_blocks_ledger != minted_blocks_db:
+            forged_blocks_db = len(slots_when_forged)
+            if forged_blocks_ledger != forged_blocks_db:
                 errors.append(
-                    "DB-Sync: Numbers of minted blocks reported by ledger state "
+                    "DB-Sync: Numbers of forged blocks reported by ledger state "
                     "and db-sync don't match: "
-                    f"{minted_blocks_ledger} vs {minted_blocks_db}"
+                    f"{forged_blocks_ledger} vs {forged_blocks_db}"
                 )
 
         _check_logs()

cardano_node_tests/tests/test_cli.py

@@ -1088,7 +1088,7 @@ def _dump_on_error():
                         f"{expected_pool_ids_dec.symmetric_difference(out_pool_ids_dec)}"
                     )
                 # Active stake can be lower than sum of stakes, as some pools may not be running
-                # and minting blocks
+                # and forging blocks
                 if sum_mark < stake_snapshot["total"]["stakeMark"]:
                     total_stake_errors.append(
                         f"active_mark: {sum_mark} < {stake_snapshot['total']['stakeMark']}"

cardano_node_tests/tests/test_kes.py

@@ -115,11 +115,11 @@ def _check_block_production(
         ledger_state=ledger_state,
     )
 
-    # Check if the pool is minting any blocks
+    # Check if the pool is forging any blocks
     blocks_made = ledger_state["blocksCurrent"] or {}
-    is_minting = pool_id_dec in blocks_made
+    is_forging = pool_id_dec in blocks_made
 
-    return epoch, is_minting
+    return epoch, is_forging
 
 
 class TestKES:
@@ -146,9 +146,9 @@ def test_expired_kes(
         * start local cluster instance configured with short KES period and low number of key
           evolutions, so KES expires soon on all pools
         * refresh opcert on 2 of the 3 pools, so KES doesn't expire on those 2 pools and
-          the pools keep minting blocks
+          the pools keep forging blocks
         * wait for KES expiration on the selected pool
-        * check that the pool with expired KES didn't mint blocks in an epoch that followed after
+        * check that the pool with expired KES didn't forg blocks in an epoch that followed after
           KES expiration
         * check KES period info command with an operational certificate with an expired KES
         * check KES period info command with operational certificates with a valid KES
@@ -167,7 +167,7 @@ def test_expired_kes(
         expire_pool_id_dec = helpers.decode_bech32(expire_pool_id)
 
         # Refresh opcert on all pools except of pool1, so KES doesn't expire on those pools and
-        # the pools keep minting blocks.
+        # the pools keep forging blocks.
         refreshed_nodes = [
             f"pool{i}" for i in range(2, len(cluster_management.Resources.ALL_POOLS) + 1)
         ]
@@ -312,7 +312,7 @@ def _check_kes_period_info(
             # supposed to expire.
             _refresh_opcerts()
 
-            this_epoch, is_minting = _check_block_production(
+            this_epoch, is_forging = _check_block_production(
                 cluster_obj=cluster,
                 temp_template=temp_template,
                 pool_id_dec=expire_pool_id_dec,
@@ -322,9 +322,9 @@ def _check_kes_period_info(
             _save_all_metrics(temp_template=f"{temp_template}_{this_epoch}_before_refresh")
             _save_all_period_info(temp_template=f"{temp_template}_{this_epoch}_before_refresh")
 
-            # Check that the expired pool is not minting any blocks
-            assert not is_minting, (
-                f"The pool '{expire_pool_name}' has minted blocks in epoch {this_epoch}"
+            # Check that the expired pool is not forging any blocks
+            assert not is_forging, (
+                f"The pool '{expire_pool_name}' has forged blocks in epoch {this_epoch}"
             )
 
             # Refresh opcerts one more time on pools that are not supposed to expire
@@ -358,16 +358,16 @@ def test_opcert_invalid_kes_period(
 
         * generate new operational certificate with `--kes-period` in the future
         * restart the node with the new operational certificate
-        * check that the pool is not minting any blocks
+        * check that the pool is not forging any blocks
         * if network era > Alonzo
 
             - generate new operational certificate with valid `--kes-period`, but counter value +2
               from last used operational certificate
             - restart the node
-            - check that the pool is not minting any blocks
+            - check that the pool is not forging any blocks
 
         * generate new operational certificate with valid `--kes-period` and restart the node
-        * check that the pool is minting blocks again
+        * check that the pool is forging blocks again
         """
         __: tp.Any  # mypy workaround
         kes_period_info_errors_list = []
@@ -425,17 +425,17 @@ def test_opcert_invalid_kes_period(
                 LOGGER.info("Checking blocks production for 4 epochs.")
                 this_epoch = cluster.g_query.get_epoch()
                 for invalid_opcert_epoch in range(4):
-                    this_epoch, is_minting = _check_block_production(
+                    this_epoch, is_forging = _check_block_production(
                         cluster_obj=cluster,
                         temp_template=temp_template,
                         pool_id_dec=pool_id_dec,
                         in_epoch=this_epoch + 1,
                     )
                     _save_metrics(pool_num=pool_num, temp_template=f"{temp_template}_{this_epoch}")
 
-                    # Check that the pool is not minting any blocks
-                    assert not is_minting, (
-                        f"The pool '{pool_name}' has minted blocks in epoch {this_epoch}"
+                    # Check that the pool is not forging any blocks
+                    assert not is_forging, (
+                        f"The pool '{pool_name}' has forged blocks in epoch {this_epoch}"
                     )
 
                     if invalid_opcert_epoch == 1:
@@ -532,16 +532,16 @@ def test_opcert_invalid_kes_period(
             updated_epoch = cluster.g_query.get_epoch()
             this_epoch = updated_epoch
             for __ in range(6):
-                this_epoch, is_minting = _check_block_production(
+                this_epoch, is_forging = _check_block_production(
                     cluster_obj=cluster,
                     temp_template=temp_template,
                     pool_id_dec=pool_id_dec,
                     in_epoch=this_epoch + 1,
                 )
                 _save_metrics(pool_num=pool_num, temp_template=f"{temp_template}_{this_epoch}")
 
-                # Check that the pool is minting blocks
-                if is_minting:
+                # Check that the pool is forging blocks
+                if is_forging:
                     break
             else:
                 try:
@@ -560,7 +560,7 @@ def test_opcert_invalid_kes_period(
                     raise
 
                 msg = (
-                    f"The pool '{pool_name}' has not minted any blocks since epoch {updated_epoch}."
+                    f"The pool '{pool_name}' has not forged any blocks since epoch {updated_epoch}."
                 )
                 raise AssertionError(msg)
 
@@ -608,12 +608,12 @@ def test_update_valid_opcert(
 
         * generate new operational certificate with valid `--kes-period`
         * copy new operational certificate to the node
-        * stop the node so the corresponding pool is not minting new blocks
-        * check `kes-period-info` while the pool is not minting blocks
+        * stop the node so the corresponding pool is not forging new blocks
+        * check `kes-period-info` while the pool is not forging blocks
         * start the node with the new operational certificate
-        * check that the pool is minting blocks again
+        * check that the pool is forging blocks again
         * check that metrics reported by `kes-period-info` got updated once the pool started
-          minting blocks again
+          forging blocks again
         * check `kes-period-info` with the old (replaced) operational certificate
         """
         __: tp.Any  # mypy workaround
@@ -652,12 +652,12 @@ def test_update_valid_opcert(
             )
             shutil.copy(new_opcert_file, opcert_file)
 
-            # Stop the node so the corresponding pool is not minting new blocks
+            # Stop the node so the corresponding pool is not forging new blocks
             cluster_nodes.stop_nodes([node_name])
 
             time.sleep(10)
 
-            # Check kes-period-info while the pool is not minting blocks
+            # Check kes-period-info while the pool is not forging blocks
             kes_period_info_new = cluster.g_query.get_kes_period_info(opcert_file)
             with open(f"{temp_template}_kes_period_info_1.json", "w", encoding="utf-8") as out_fp:
                 json.dump(kes_period_info_new, out_fp, indent=2)
@@ -700,16 +700,16 @@ def test_update_valid_opcert(
             updated_epoch = cluster.g_query.get_epoch()
             this_epoch = updated_epoch
             for __ in range(6):
-                this_epoch, is_minting = _check_block_production(
+                this_epoch, is_forging = _check_block_production(
                     cluster_obj=cluster,
                     temp_template=temp_template,
                     pool_id_dec=pool_id_dec,
                     in_epoch=this_epoch + 1,
                 )
                 _save_metrics(pool_num=pool_num, temp_template=f"{temp_template}_{this_epoch}")
 
-                # Check that the pool is minting blocks
-                if is_minting:
+                # Check that the pool is forging blocks
+                if is_forging:
                     break
             else:
                 try:
@@ -728,12 +728,12 @@ def test_update_valid_opcert(
                     raise
 
                 msg = (
-                    f"The pool '{pool_name}' has not minted any blocks since epoch {updated_epoch}."
+                    f"The pool '{pool_name}' has not forged any blocks since epoch {updated_epoch}."
                 )
                 raise AssertionError(msg)
 
         # Check that metrics reported by kes-period-info got updated once the pool started
-        # minting blocks again
+        # forging blocks again
         kes_period_info_updated = cluster.g_query.get_kes_period_info(opcert_file)
         with open(f"{temp_template}_kes_period_info_3.json", "w", encoding="utf-8") as out_fp:
             json.dump(kes_period_info_updated, out_fp, indent=2)

cardano_node_tests/tests/test_ledger_state.py

@@ -201,7 +201,7 @@ def _get_delegations(snapshot: str) -> dict[str, list[str]]:
             if sum_go != stake_snapshot["total"]["stakeGo"]:
                 errors.append(f"total_go: {sum_go} != {stake_snapshot['total']['stakeGo']}")
         # Active stake can be lower than sum of stakes, as some pools may not be running
-        # and minting blocks
+        # and forging blocks
         else:
             if sum_mark < stake_snapshot["activeStakeMark"]:
                 errors.append(f"active_mark: {sum_mark} < {stake_snapshot['activeStakeMark']}")

cardano_node_tests/tests/test_pool_saturation.py

@@ -35,7 +35,7 @@ class PoolRecord:
     delegation_out: delegation.DelegationOut
     user_rewards: list[RewardRecord]
     owner_rewards: list[RewardRecord]
-    blocks_minted: dict[int, int]
+    blocks_forged: dict[int, int]
     saturation_amounts: dict[int, int]
 
 
@@ -96,7 +96,7 @@ def _get_reward_per_block(pool_record: PoolRecord, owner_rewards: bool = False)
         assert for_epoch == rew_for.epoch_no
         results[for_epoch] = (
             rew_received.reward_per_epoch
-            / pool_record.blocks_minted[for_epoch]
+            / pool_record.blocks_forged[for_epoch]
             / rew_for.stake_total
         )
 
@@ -282,7 +282,7 @@ def _save_pool_records() -> None:
                 delegation_out=delegation_out,
                 user_rewards=[],
                 owner_rewards=[],
-                blocks_minted={},
+                blocks_forged={},
                 saturation_amounts={},
             )
 
@@ -344,7 +344,7 @@ def _save_pool_records() -> None:
                     prev_user_reward = pool_rec.user_rewards[-1].reward_total
                     prev_owner_reward = pool_rec.owner_rewards[-1].reward_total
 
-                    pool_rec.blocks_minted[this_epoch - 1] = (
+                    pool_rec.blocks_forged[this_epoch - 1] = (
                         ledger_state["blocksBefore"].get(pool_rec.id_dec) or 0
                     )