max_tx_ex_steps

The Cardano Blockchain has over 40 parameters that lets you tune the system to work on a wide range of applications. In this installment of our series to explore these parameters, we will be covering the max transaction execution steps, aka the max_tx_ex_steps network parameter. In a previous article we covered the max_block_ex_steps, the parent parameter of sort to our parameter of the day.

What is max_tx_ex_steps?

Both max_tx_ex_steps and its parent max_tx_block_steps defines the upper limit on the number of Plutus script execution steps allowed in a single block. The difference between the two is that the parent has a limit on the sum of all transactions in the entire block. The max_tx_ex_steps on the other hand is only concerned with the limit on a single transaction. The “steps” mentioned here are not exactly your typical second or milliseconds, but rather units of computation as measured in Cardano’s abstract execution cost model. The cost model is designed to make smart contract resource usage predictable and fair across the decentralized network. You can think of these execution steps as the number of operations the blockchain is willing to process in a single transaction, where each operation represents a unit of Cardano specific work. When a transaction uses a smart contract, that contract runs code. The code is run in a special interpreter on-chain. As it processes the logic, the interpreter keeps track of how many computational “steps” it takes. Too many steps? The transaction fails immediately. Due to Cardano’s pre-deterministic nature, the transaction won’t even get a chance to make it into a block.

Why does this matter?

As is true with most things in life, resources are finite. Validators (block producers) must be able to verify blocks quickly and efficiently to keep the chain healthy. max_tx_ex_steps puts a ceiling on how much thinking (computation) a single transaction can demand. This combined with its parent parameter ensures that no block stalls the network with excessive on-chain logic. It also allows pool operators to predict and plan far ahead of time what computational they would need to purchase to service the network. It also plays a key role in smart contract throughput. A higher max_tx_ex_steps means more complex scripts, improving dApp scalability. But increasing it comes at a cost: heavier computation burden on block producers, which might strain less powerful nodes.

How many steps is too many?

As of this writing, the mainnet limit for max_tx_ex_steps is set at 1 Billion steps per transaction. To give a sense of scale: a single Plutus smart contract interaction (like voting in governance, or claiming a reward from a staking pool) might use tens of thousands of steps. This means that, depending on complexity, a single transaction can be quite complex with many business logic.

But it also means developers must carefully budget their scripts. The more efficient the code, the more you can do in a single transaction.

What’s next for this parameter?

Cardano was set up from the beginning to be continuously optimized and improved. As the network evolves, and as node software becomes more performant, parameters like max_tx_ex_steps are regularly reviewed by technical bodies within the ecosystem. With Cardano on-chain governance live on mainnet, anyone can raise a request to update this and other updatable parameters.

Upgrades like input endorsers and pipelining aim to decouple transaction validation from block production, potentially making higher max_tx_ex_steps limits are more feasible without compromising decentralization.

TL;DR

• max_block_ex_steps limits the total computation per transaction in abstract “steps.”
• It’s like a CPU cap for the blockchain
• Prevents overly complex transactions that would bog down the system.
• Helps ensure consistent performance and decentralization.
• Developers must stay under this cap or risk failed transactions.
• Future upgrades may allow increasing this limit to enable more dApp activity.