In `@crates/chain/tests/api/hardfork_tests.rs`:
- Around line 777-781: The test currently awaits genesis_node.post_data_tx(...)
but drops the Result, which can hide submission failures; change the calls to
propagate errors by using the `?` operator on the awaited Result (e.g.,
`genesis_node.post_data_tx(anchor, data.into_bytes(), signer).await?`) or
otherwise return a Result from the test and propagate errors; update both
occurrences of genesis_node.post_data_tx(...) (around the current block and the
similar block at the other location) so failures surface immediately instead of
being silently ignored.

In `@crates/domain/src/models/block_tree.rs`:
- Around line 417-452: The data-tx validation currently compares the union of
all ledger tx IDs which allows mismatches across ledgers; change it to validate
per-ledger equality: for each ledger in block.data_ledgers compute expected_ids
from ledger.tx_ids and fetch the corresponding entry in transactions.data_txs
(use the ledger's identifier/key that maps into transactions.data_txs), then
ensure the HashSet of expected IDs equals the HashSet of actual IDs for that
ledger; also ensure there are no extra ledger entries in transactions.data_txs
(i.e., check that transactions.data_txs.keys() == block.data_ledgers.keys()).
Update the block_tree.rs checks around expected_data_ids/actual_data_ids to
iterate per-ledger and use eyre::ensure! per ledger with a clear error message
including the block hash and ledger identifier.

In `@crates/actors/src/mempool_service/lifecycle.rs`:
- Around line 847-858: The current flow removes commitment transactions from
mempool via mempool_state.remove_commitment_txs(...) before persisting them with
irys_db.update_eyre(...) and insert_commitment_tx(...), which risks losing them
if the DB commit fails; change the ordering so you first persist all
commitment_txs inside irys_db.update_eyre (calling insert_commitment_tx for
each) and only after that succeeds call
mempool_state.remove_commitment_txs(...), or alternatively wrap the DB commit in
a try and on failure re-insert the removed txs via mempool_state.add or a
rollback helper; update references in this block (remove_commitment_txs,
insert_commitment_tx, irys_db.update_eyre, mempool_state) accordingly so
removals happen only after a successful DB persist.
- Around line 889-892: The loop is unnecessarily cloning publish_txs; since
publish_tx_ids is already computed above and publish_txs isn't used afterward,
change the iteration inside the self.irys_db.update_eyre closure from for mut
header in publish_txs.clone() to consuming iteration (e.g., for mut header in
publish_txs.into_iter()) so the vector is moved instead of cloned, keeping the
surrounding update_eyre(...) and mut header usage intact.

In `@crates/chain/tests/api/hardfork_tests.rs`:
- Around line 1078-1101: After the second peer restart, add the same DB
integrity checks you ran in Step 7 (the block index hash checks, PoA chunk
validations and any DB content assertions) for the restarted peer_node: after
peer_node.wait_until_height(final_height, ...).await? and before
peer_node.stop().await, call the existing helper(s) used earlier (e.g. the
functions that validated block index hashes, PoA chunks and DB contents in Step
7—reuse those exact function names) to spot-check the restarted node’s database
contents and ensure they match expected state.
- Line 799: The subtraction pre_activation_height - block_migration_depth as u64
can underflow; change the calculation that sets pre_aurora_migrated_height to
use saturating_sub (e.g.,
pre_activation_height.saturating_sub(block_migration_depth as u64)) or add a
guard that ensures block_migration_depth as u64 <= pre_activation_height before
subtracting, and apply the same fix to the other occurrence mentioned (the
analogous subtraction at the second spot around line 918) so both use saturating
arithmetic or a proper check.

In `@crates/actors/src/block_tree_service.rs`:
- Around line 452-461: The code currently uses unwrap_or_default() when reading
transactions from cache.blocks for each block_to_migrate, which silently returns
an empty BlockTransactions on a cache miss; replace this silent fallback with a
loud failure: change the lookup to unwrap the Option with expect (or otherwise
return/propagate an Err) so that a missing cache entry for
block_to_migrate.block_hash fails immediately with a clear message including the
block_hash and context (e.g., in the block migration function where
self.cache.read(), cache.blocks.get(&block_to_migrate.block_hash) and
.map(|meta| meta.transactions.clone()) are used).

In `@crates/domain/src/models/block_tree.rs`:
- Around line 2583-2616: The helper mock_transactions_for_block duplicates
integer-to-enum mapping for data ledgers; replace the manual match with
DataLedger::try_from(data_ledger.ledger_id) (the same approach used in
add_common) and skip entries on Err, so ledger conversion is consistent with
production code and avoids hardcoded IDs; update use sites in
mock_transactions_for_block to check the Result and only insert when Ok(ledger).
- Around line 1482-1510: The load_data_transactions function currently drops
missing transactions returned as None from tx_header_by_txid, which can hide DB
corruption for blocks inserted into the cache (start block) without add_common
validation; update load_data_transactions to detect when tx_header_by_txid
returns None for any tx_id and either (a) return an Err/eyre::Report describing
the missing tx and include the tx_id and DataLedger, or (b) at minimum log a
clear warning with the tx_id and ledger and then return an Err so callers
(including the start block insertion path) fail-fast; modify any callers
expecting Ok(HashMap...) accordingly and ensure references to
load_data_transactions, tx_header_by_txid, and the start-block insertion code
path are updated to handle the error.

In `@crates/actors/src/mempool_service/lifecycle.rs`:
- Around line 870-877: The loop over submit_txs currently swallows
insert_tx_header errors (logging and continuing) which can leave the DB in a
partially-migrated state; change the behavior in the update_eyre closure so any
failure in insert_tx_header aborts the operation and causes the DB transaction
to roll back — e.g., replace the error-logging-only branch in the for header in
&submit_txs loop with logic that propagates the error (use ? or return Err(...))
up from the closure so the transaction does not commit after a failed insert.

In `@crates/chain/tests/api/hardfork_tests.rs`:
- Around line 839-845: Add a brief clarifying comment around the
stop/sleep/activation sequence: explain that the sleep after calling
genesis_node.stop().await is to ensure the node has fully stopped before
sampling activation_timestamp (the variable activation_timestamp = now_secs()),
and note that the test assumes blocks mined by mine_block may have timestamps
equal to activation_timestamp and that Aurora activation treats timestamps >=
activation_timestamp as active; optionally mention increasing the sleep if you
want a larger gap.
- Around line 866-893: The V1 rejection check currently reuses the same signer
that just posted a V2 commitment (see v2_signer_idx, signers, create_stake_tx,
TxVersion::V2/V1 inside the epoch loop), which is correct but unclear; either
(a) reserve a dedicated "rejection probe" signer from the signers array and use
that signer when creating the V1 probe tx so intent is explicit, or (b) add a
short clarifying comment above the V1 probe explaining that reusing the same
signer is intentional because the rejection happens at mempool validation;
update references to v2_signer_idx/signers accordingly to avoid off-by-one
signing mix-ups.
- Around line 1065-1072: The manual reconstruction of IrysNodeTest is
unnecessary—replace the explicit IrysNodeTest { node_ctx: (), cfg:
stopped_peer.cfg.clone(), temp_dir: stopped_peer.temp_dir, name:
stopped_peer.name }.start().await with calling start() directly on the
stopped_peer returned by stop(); in other words, use let peer_node =
stopped_peer.start().await; so you rely on the start() method on the
stopped_peer (IrysNodeTest<()>) rather than rebuilding the struct.