Skip to content

Fix issue #2070. Don't fail context update when there is a record of rejected transaction #2098

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
LGLO merged 3 commits into from
Sep 11, 2026
+92 −18
Merged

Fix issue #2070. Don't fail context update when there is a record of rejected transaction #2098

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
f9ae431
Fix issue #2070. Don't fail context update when there is a
LGLO Sep 4, 2026
8daa5ea
Merge branch 'main' into fix-issue-2070
LGLO Sep 11, 2026
9a76b47
Count well_formed error to FAILED_TXS counter
LGLO Sep 11, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 28 additions & 0 deletions changes/toolkit/changed/fix-replay-abort-on-well-formed-failure.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,28 @@
#toolkit #bugfix
# Don't abort context replay on a `well_formed` failure the chain itself tolerated

`LedgerContext::apply_txs_collect_events` (in both the ledger-8 and ledger-9
implementations, behind `update_from_block`) aborted the whole block replay
whenever a transaction's `well_formed` check returned `Err`, e.g.
`OutOfDustValidityWindow` for a dust action whose `ctime` lands a couple of
seconds past the including block's `tblock`. This made every toolkit workflow
that replays a context (transaction generation, wallet inspection, faucets,
test-data generators) unusable against a chain — such as Preview — carrying a
transaction the chain itself had accepted: on-chain,
`pallet_midnight::send_mn_transaction` hits this same check via
`LedgerApi::apply_transaction`, but only fails that one extrinsic's dispatch
(storage rolled back, `ExtrinsicFailed` emitted) without affecting block
validity, so a `well_formed` failure alone is not evidence of an invalid block.

`apply_txs_collect_events` now matches on `LedgerContextError::InvalidTransaction`
specifically and, on that variant, logs a warning and moves on to the next
transaction instead of propagating the error and aborting the replay. Every
other error variant still aborts. `update_from_tx` (used by the `batches`
generator to validate each transaction it builds before chaining more on top
of it) is untouched and keeps hard-failing: a generator needs to know
immediately if its own just-built transaction is doomed, since tolerating it
there would let a doomed transaction ship in the output batch and further
batches get built against funds it never actually created.

PR: https://github.com/midnightntwrk/midnight-node/pull/2098
Issue: https://github.com/midnightntwrk/midnight-node/issues/2070
41 changes: 32 additions & 9 deletions ledger/helpers/unsafe/src/ledger_8/context.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ use crate::ledger_8::{
clamp_and_normalize, compute_overall_fullness, default_storage, deserialize,
mn_ledger_serialize as serialize, mn_ledger_storage as storage, types::StorableSyntheticCost,
};
use crate::replay_stats::{FAILED_TXS, PARTIALLY_FAILED_TXS};
use derive_where::derive_where;
use hex::encode as hex_encode;
use lazy_static::lazy_static;
Expand Down Expand Up @@ -173,10 +174,26 @@ impl<D: DB + Clone> LedgerContext<D> {
let mut all_events: Vec<Event<D>> = Vec::new();
let strictness = Self::strictness_for(block_context, root_verified);
for tx in txs {
let (events, cost) =
self.update_from_tx_with_strictness(tx, block_context, strictness)?;
all_events.extend(events);
total_cost = total_cost + cost;
match self.update_from_tx_with_strictness(tx, block_context, strictness) {
Ok((events, cost)) => {
all_events.extend(events);
total_cost = total_cost + cost;
},
// A `well_formed` rejection (e.g. `OutOfDustValidityWindow` from a dust action
// whose `ctime` lands a couple of seconds past the including block's `tblock`)
// is not evidence of an invalid block: on-chain, `pallet_midnight::send_mn_transaction`
// hits this same check via `LedgerApi::apply_transaction` and simply fails that
// one extrinsic's dispatch (storage rolled back, `ExtrinsicFailed` emitted)
// without affecting block validity. Already-committed, external chain history is
// replayed here, so mirror that instead of aborting the whole replay.
Err(LedgerContextError::InvalidTransaction(reason)) => {
let hash = hex::encode(tx.transaction_hash().0.0);
log::warn!(
"Tolerating well_formed rejection {reason} of tx 0x{hash} while replaying block"
Comment thread
gilescope marked this conversation as resolved.
);
},
Comment thread
LGLO marked this conversation as resolved.
Err(e) => return Err(e),
}
}

let mut latest_ledger_state = self
Expand Down Expand Up @@ -383,6 +400,11 @@ impl<D: DB + Clone> LedgerContext<D> {
)
}

/// A `well_formed` rejection surfaces as `Err(LedgerContextError::InvalidTransaction(_))`,
/// distinct from every other (fatal) error variant, so callers can decide for themselves
/// whether to tolerate it: `apply_txs_collect_events` (block replay) does, `update_from_tx`
/// (this function's only other caller, used to validate a transaction the caller is about
/// to build more transactions on top of or submit itself) does not.
fn update_from_tx_with_strictness<S: SignatureKind<D>, P: ProofKind<D> + std::fmt::Debug>(
&self,
tx: &SerdeTransaction<S, P, D>,
Expand Down Expand Up @@ -414,7 +436,10 @@ impl<D: DB + Clone> LedgerContext<D> {
} else {
tx.erase_proofs().well_formed(ref_state, strictness, tblock)
}
.map_err(|e| LedgerContextError::InvalidTransaction(format!("{e:?}")))?;
.map_err(|e| {
FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
LedgerContextError::InvalidTransaction(format!("{e:?}"))
})?;
let cost = tx
.cost(&tx_context.ref_state.parameters, false)
.map_err(|e| LedgerContextError::CostCalculation(format!("{e:?}")))?;
Expand All @@ -424,17 +449,15 @@ impl<D: DB + Clone> LedgerContext<D> {
match result {
TransactionResult::Success(events) => (new_ledger_state, offers, events, cost),
TransactionResult::PartialSuccess(failure, events) => {
crate::replay_stats::PARTIALLY_FAILED_TXS
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
PARTIALLY_FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let hash = hex::encode(tx.transaction_hash().0.0);
log::debug!(
"Partially failing result {failure:?} of applying tx 0x{hash} to update Local Ledger State"
);
(new_ledger_state, offers, events, cost)
},
TransactionResult::Failure(failure) => {
crate::replay_stats::FAILED_TXS
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let hash = hex::encode(tx.transaction_hash().0.0);
log::warn!(
"Failing result {failure:?} of applying tx 0x{hash} to update Local Ledger State"
Expand Down
41 changes: 32 additions & 9 deletions ledger/helpers/unsafe/src/ledger_9/context.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ use crate::ledger_9::{
clamp_and_normalize, compute_overall_fullness, default_storage, deserialize,
mn_ledger_serialize as serialize, mn_ledger_storage as storage, types::StorableSyntheticCost,
};
use crate::replay_stats::{FAILED_TXS, PARTIALLY_FAILED_TXS};
use derive_where::derive_where;
use hex::encode as hex_encode;
use lazy_static::lazy_static;
Expand Down Expand Up @@ -173,10 +174,26 @@ impl<D: DB + Clone> LedgerContext<D> {
let mut all_events: Vec<Event<D>> = Vec::new();
let strictness = Self::strictness_for(block_context, root_verified);
for tx in txs {
let (events, cost) =
self.update_from_tx_with_strictness(tx, block_context, strictness)?;
all_events.extend(events);
total_cost = total_cost + cost;
match self.update_from_tx_with_strictness(tx, block_context, strictness) {
Ok((events, cost)) => {
all_events.extend(events);
total_cost = total_cost + cost;
},
// A `well_formed` rejection (e.g. `OutOfDustValidityWindow` from a dust action
// whose `ctime` lands a couple of seconds past the including block's `tblock`)
// is not evidence of an invalid block: on-chain, `pallet_midnight::send_mn_transaction`
// hits this same check via `LedgerApi::apply_transaction` and simply fails that
// one extrinsic's dispatch (storage rolled back, `ExtrinsicFailed` emitted)
// without affecting block validity. Already-committed, external chain history is
// replayed here, so mirror that instead of aborting the whole replay.
Err(LedgerContextError::InvalidTransaction(reason)) => {
let hash = hex::encode(tx.transaction_hash().0.0);
log::warn!(
"Tolerating well_formed rejection {reason} of tx 0x{hash} while replaying block"
);
},
Comment thread
LGLO marked this conversation as resolved.
Err(e) => return Err(e),
}
}

let mut latest_ledger_state = self
Expand Down Expand Up @@ -383,6 +400,11 @@ impl<D: DB + Clone> LedgerContext<D> {
)
}

/// A `well_formed` rejection surfaces as `Err(LedgerContextError::InvalidTransaction(_))`,
/// distinct from every other (fatal) error variant, so callers can decide for themselves
/// whether to tolerate it: `apply_txs_collect_events` (block replay) does, `update_from_tx`
/// (this function's only other caller, used to validate a transaction the caller is about
/// to build more transactions on top of or submit itself) does not.
fn update_from_tx_with_strictness<S: SignatureKind<D>, P: ProofKind<D> + std::fmt::Debug>(
&self,
tx: &SerdeTransaction<S, P, D>,
Expand Down Expand Up @@ -414,7 +436,10 @@ impl<D: DB + Clone> LedgerContext<D> {
} else {
tx.erase_proofs().well_formed(ref_state, strictness, tblock)
}
.map_err(|e| LedgerContextError::InvalidTransaction(format!("{e:?}")))?;
.map_err(|e| {
FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
LedgerContextError::InvalidTransaction(format!("{e:?}"))
})?;
let cost = tx
.cost(&tx_context.ref_state.parameters, false)
.map_err(|e| LedgerContextError::CostCalculation(format!("{e:?}")))?;
Expand All @@ -424,17 +449,15 @@ impl<D: DB + Clone> LedgerContext<D> {
match result {
TransactionResult::Success(events) => (new_ledger_state, offers, events, cost),
TransactionResult::PartialSuccess(failure, events) => {
crate::replay_stats::PARTIALLY_FAILED_TXS
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
PARTIALLY_FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let hash = hex::encode(tx.transaction_hash().0.0);
log::debug!(
"Partially failing result {failure:?} of applying tx 0x{hash} to update Local Ledger State"
);
(new_ledger_state, offers, events, cost)
},
TransactionResult::Failure(failure) => {
crate::replay_stats::FAILED_TXS
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
FAILED_TXS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let hash = hex::encode(tx.transaction_hash().0.0);
log::warn!(
"Failing result {failure:?} of applying tx 0x{hash} to update Local Ledger State"
Expand Down
Loading