Testnet v0.16: Last Stop Before Mainnet!

Miden v0.14 gave builders a redesigned client API, a new wallet foundation, and programmable assets. Miden v0.15 added crosschain transfers, native swaps, Guardian recovery, and better Rust tooling.

Miden v0.16 is the last major testnet release before mainnet. For the first time, testnet will operate with network fees enabled. The release also improves multi-party signing, encrypts private transaction inputs, reduces the Web SDK’s production binary size, and continues to improve the core developer tools.

Together, these changes make the full stack more robust, easier to build with, and ready for mainnet!

Fees arrive on testnet

This is an important one: v0.16 enables fees on testnet and adds protocol and client support for fee policies, fee schedules, and fee conversion.

Fees are handled by the account’s authentication procedure, which makes the fee payment part of the transaction the user signs. The client calculates and handles the payment automatically, but the signing account needs enough testnet MIDEN to cover it. Builders and users can get free testnet MIDEN from the Miden faucet.

Fees vary with transaction complexity and grow logarithmically with the number of execution cycles. With the initial fee schedule, a typical transaction should cost around one-hundredth of a cent, assuming one testnet MIDEN is treated as $1.

On mainnet, fees will be denominated in USDCx. Following the USDCx on Miden announcement, v0.16 puts the protocol foundations in place. The wallet and client experience is being polished, and we will explain the complete design in a future article.

One toolchain from setup to build

Midenup first appeared in Miden v0.12 as Miden’s installer and project-scaffolding tool. With v0.16, it manages the VM, compiler, client, standard library, and transaction kernel as one versioned toolchain behind a unified miden command.

Builders can install midenup and use it to get the toolchain deployed to testnet:

cargo install midenup
midenup init
midenup install testnet

The first two commands install and initialize midenup. The third installs the compatible component versions deployed to testnet. Builders can then create a project and build one of its contracts with the miden command, for example:

miden new counter-project
cd counter-project/contracts/counter-account
miden build

The commands should feel familiar to Rust developers. Midenup also keeps the installed components on compatible versions, so an update to one part of the toolchain is less likely to break another.

That means less time setting things up or debugging version mismatches, and more time building.

Safer transaction flows across clients

v0.16 also changes how multi-party transactions are prepared, signed, and executed.

The signed transaction summary now commits to the reference block used to prepare it. A proposer can pass the required chain data alongside the transaction, allowing another client to reproduce and execute it even if that client has synced to a later block.

This directly strengthens the Guardian-based flow used in Miden Wallet: the user and Guardian approve the same anchored transaction summary. It also means multisig and offline co-signing no longer require every participant’s client to be synced to the same block.

Private transaction inputs are encrypted before submission

Private transaction inputs are now encrypted before submission. The client verifies the validator set’s public encryption key against the latest chain state, uses it to encrypt the inputs, and submits them alongside the proven transaction. Thanks to this, RPC relays and sequencers can forward both, but cannot decrypt the inputs.

Reminder: stage 1 of Miden’s privacy roadmap hides private transaction data from other users, but not from validators. Technically, a transaction proof can be cryptographically verified using public data alone, but during this stage, clients also send the encrypted private inputs to validators.

These “training wheels” are an interim design for security reasons. They provide an extra check while Miden operates the validator set and the proof system matures, because proving systems can have bugs. As part of this check, validators decrypt the inputs, re-execute the transaction, and compare the re-executed transaction with the proven transaction. If the results do not match, the validator rejects the transaction before block inclusion. For perspective, this extra check would have caught most of the VM findings rated critical during Miden’s audits.

Longer term, proof verification should be enough, without validators receiving or re-executing the private inputs. Doing so will keep private transaction inputs hidden from validator operators too.

This approach, by the way, is another example of what practical means for Miden. It applies to both the privacy we enable and to how we build: one useful step at a time. Work on sequencer and validator privacy will continue in future releases.

Lighter web applications

With Miden v0.16, the Web SDK’s single-threaded production binary is about 30% smaller, falling from 27.4 MB to 18.8 MB.

Production builds now remove embedded MASM debugging metadata that applications do not need at runtime. Development builds keep it for testing.

The exact effect on load times will depend on the application and how it is deployed, but the payload itself is substantially smaller in production.

Swaps and bridges

Another important user-facing feature is our Miden-native swap flow. Miden v0.15 introduced PSWAP notes. v0.16 makes them behave more like limit orders: users can set the minimum amount they will accept and a minimum fill size to prevent dust-sized partial fills.

Last but not least, the Agglayer and Epoch integrations are ready and testable. The Miden Bridge page provides a usable testnet UI for each. We will cover the underlying flows in more detail in an upcoming blog post – keep your eyes peeled!

Upgrading to Miden v0.16

Miden v0.16 is a breaking upgrade across the protocol, node, SDKs, and local stores.

Builders will need to rebuild existing packages, upgrade clients and nodes together, and recreate local stores created before Miden v0.16. Before deleting a store, export any private-note data held only on that device if you want to preserve it.

The published Miden v0.16 migration guide provides the exact sequence and current package references.

With the major protocol work in place, the remaining work is rollout, testing, and polish. So get ready: mainnet is coming!

‍