Critical Bug: State changes are not committed between bundle transactions

The documentation states that "Each transaction is simulated on the in-memory state produced by the previous transaction in the bundle" (lines 327-329), but the implementation does not commit state changes after successful transactions.

In the execute_bundle method (line 222), db.commit(state) is called after each successful transaction to ensure subsequent transactions see the state changes. However, in this simulation implementation, the state from ExecResultAndState is discarded without being committed.

Solution: Add state.commit(tx_state) after pushing the result:

Ok(ExecResultAndState { result, state: tx_state })
    if result.is_success() || allowed_to_fail =>
{
    results.push(result);
    state.commit(tx_state); // Commit to allow next tx to see changes
    // Note: No db.commit(state) for simulation
}

Without this fix, each transaction in the bundle will execute against the original database state, not the cumulative state from previous transactions, which breaks bundle semantics.

Yeah, you should do db.commit
But you shouldn't do merge_transitions

Documentation Inaccuracy: State changes ARE persisted in simulation

The documentation states "Each transaction is simulated on the in-memory state produced by the previous transaction in the bundle, but changes are not committed or persisted" (lines 327-329). However, this is misleading.

While the final state is not returned (line 416 returns BundleState::default()), the in-memory state changes should still be committed within the State object between transactions for the simulation to work correctly. The documentation should clarify that:

• State changes are committed in-memory between transactions within the bundle
• The final aggregated state is not persisted/returned (unlike execute_bundle)

Consider revising to: "Each transaction is simulated on the in-memory state produced by the previous transaction in the bundle. State changes are applied in-memory for subsequent transactions, but the final state is not persisted."

Misleading comment about state commitment

The comment says "No db.commit(state) for simulation" but the variable is named state, not db. This is inconsistent with the actual code and could be confusing.

Additionally, this comment is misleading because state changes should be committed between transactions (as noted in the bug comment above). The comment should clarify that:

• State changes ARE committed in-memory between transactions (via state.commit(tx_state))
• The final state is not returned (line 416 returns BundleState::default())

Consider revising to: "State changes committed in-memory but not returned (simulation)"

I don't see why we shouldn't do post-execution validation on simulated bundle as well.
The implementation should be almost same as execute_bundle, but without merging transitions.

totally agree, thanks for the feeback julio. addressing it