Right now on Plasma, transactions are being accepted into a batch, XPL is deducted at admission, and execution is attempted against the current Plasma state. Some of those transactions do not make it to a state change. They still consume XPL. You can see this by watching Plasma blocks where a transaction enters a batch, never mutates state, and yet the XPL balance decreases on the sender side. Plasma is not waiting for successful execution to charge the fee.
On Plasma, the fee event happens before execution completes. When a user submits a transaction, Plasma checks basic validity and fee sufficiency, then immediately locks and consumes the XPL associated with that transaction as it is queued into a batch. The Plasma operator does not defer fee deduction until after state transition success. If execution later fails because the Plasma state has moved, because a nonce is no longer valid, or because the transaction exhausts its execution budget, the XPL is already gone. Plasma records the failure, but the fee is not reversed.
Watching Plasma batches in production shows a clear sequence. Transactions are ordered, XPL is charged, execution is attempted sequentially. If a transaction hits a state conflict mid-batch on Plasma, such as reading a balance that was modified by an earlier transaction in the same batch, execution aborts for that transaction. Plasma still advances the batch, and the failed transaction does not get reinserted automatically. The XPL associated with that transaction stays burned or consumed according to Plasma’s fee rules. There is no conditional refund path tied to execution success on Plasma today.
This behavior changes how retries work on Plasma. A bot submitting multiple dependent transactions to Plasma cannot assume that a failure is free. Each retry is a fresh Plasma transaction, and each retry consumes new XPL at submission. In practice on Plasma, this pushes bots and automation to either overestimate fees and state safety or slow down submission frequency. Fast resubmission loops that work on some legacy execution layers become expensive on Plasma because XPL is consumed even when nothing executes.
For users on Plasma, this shows up most clearly during congestion or contention. A user submits a Plasma transaction expecting a state condition to hold. Another transaction in the same Plasma batch modifies that state first. The user transaction fails, but the XPL is already deducted. The Plasma explorer shows a failed execution flag, yet the XPL balance reflects the cost. Plasma treats the fee as payment for execution attempt, not execution success.
Developers building on Plasma need to model this explicitly. Fee estimation on Plasma is not just about average execution cost, but about the probability of failure inside a batch. Any Plasma application that relies on optimistic assumptions about state, such as trading, arbitrage, or automated withdrawals, must treat XPL fees as sunk costs per attempt. Plasma makes this visible by charging upfront and not coupling XPL consumption to successful state transitions.
There is a real limitation here on Plasma. In a high-contention scenario, such as multiple users targeting the same Plasma contract state in a single batch, repeated failures can drain XPL quickly without any state progress. A simple example on Plasma is two bots racing the same balance update. One succeeds. The others fail. All of them pay XPL. Plasma does not currently provide a built-in mechanism to detect or defer obviously conflicting transactions before fee consumption.
What this ultimately reframes on Plasma is not price or incentives, but behavior. The opening observation of XPL being burned on failed transactions is not an edge case. It is Plasma’s normal execution posture. Plasma charges for the attempt, moves on, and leaves it to users, bots, and developers to adapt their submission logic accordingly.