For years, private DeFi has forced users into a trade-off. You could have privacy, but it usually meant leaving your normal wallet, using a separate privacy application, or accepting a user experience that felt disconnected from the rest of DeFi.
As a result, private DeFi never became normal DeFi. STRK20 changes that.
STRK20 is Starknet’s privacy framework for ERC-20 assets. It enables shielded balances, private transfers, and private app flows through supported wallets and applications, making privacy usable where onchain activity already happens.
This is what makes the next wave of Starknet DeFi different. Users can still trade, swap, lend, borrow, and stake, but these actions can now happen with an additional layer of privacy.
That is the unlock: privacy integrated into DeFi that already exists.
Privacy starts in the wallet
The first major change users will notice is simple: supported assets can be shielded directly from the wallet.
Ready X and Xverse will be two of the primary interfaces for shielding assets. In the first phase, users will be able to shield, unshield, manage shielded balances, and execute supported swaps.
This matters because privacy should not require users to remember a separate website or move into a separate product. It should appear inside the wallets and apps they already use to manage assets and interact with DeFi.
Under the hood, different applications can support this in different ways. Some flows may be handled directly through wallet interfaces. Others may be initiated by DeFi applications that connect to the wallet through privacy APIs and anonymizing contracts.
Starknet’s direction is clear: users should be able to manage visible balances, shielded balances, and supported private DeFi flows from familiar wallets and apps.
Swapping through avnu and Ekubo
Swaps are where STRK20’s design becomes clear.
Imagine a user starts with shielded USDC and wants to swap into ETH.
From the user’s perspective, the action should feel familiar: choose the input asset, choose the output asset, confirm the transaction, and receive the new shielded balance.
The important part is what the user does not need to do. They do not need to move into a separate private DEX, wait for a new private market to form, or rely on isolated liquidity for that pair.
The swap can still route through existing Starknet liquidity. avnu can route the trade across available venues, while Ekubo can serve as a core liquidity venue where swaps execute.
That is what makes the design practical: STRK20 connects privacy to the existing DeFi market structure Starknet already has.
What happens under the hood in an anonymous swap
The anonymizing contract is what makes this feel simple to the user while still routing through normal Starknet liquidity.
In the USDC to ETH example, the user signs a private transaction with three main parts.
- Shielded USDC is unshielded into the anonymizing contract, creating the open note that can be used inside the swap flow.
- The anonymizing contract executes the swap through existing Starknet liquidity using the route and arguments provided.
- The anonymizing contract returns the output amount, creating a new private note for the user, which is privately redeposited to the user’s account in the pool.
The user starts with shielded USDC and ends with shielded ETH. The result is one atomic transaction: USDC exits the privacy pool, the swap happens through existing public liquidity, and ETH re-enters the privacy pool as a private balance.
This does not mean every detail disappears. Amounts moving through public liquidity are still visible. What changes is the direct link between the user’s wallet and the DeFi action. The user is no longer simply broadcasting the swap from their ordinary public address.
There is one practical consideration: anonymity depends on the size and quality of the privacy set. If only one person has ever shielded a specific asset, that activity is easier to reason about from the outside. As more users shield, transfer, swap, and manage supported assets, the anonymity set strengthens.
That is the practical design choice. STRK20 does not create a separate private DEX with separate liquidity. It lets users access the liquidity Starknet already has while breaking the direct public link between the user’s wallet and the DeFi action.
Private lending and borrowing through Vesu
Lending is where private DeFi starts to become especially powerful.
A public DeFi loan reveals a lot. Observers can often see what a wallet supplied, what it borrowed, how large the position is, and how that position changes over time. For individuals, this exposes personal financial activity. For larger holders, funds, and institutions, it can reveal capital movements and strategy.
STRK20 introduces a path toward more private credit activity on Starknet, but the first phase will be more manual than wallet-based swaps.
For example, a user could start with shielded strkBTC and want to borrow USDC against it. In the early flow, they need to unshield the strkBTC, supply it as collateral on Vesu, borrow USDC, and then shield the USDC after the loan is executed.
The collateral inside Vesu is still visible while it is locked in the public lending market. The privacy benefit comes from the user’s ability to start from a shielded balance and shield the borrowed asset after execution.
Credit is one of the most important functions in any financial system. This is why lending protocols, such as Vesu, are an important part of STRK20’s broader DeFi vision. Bringing privacy to lending does not mean hiding risk from the protocol. It means reducing unnecessary public exposure while keeping DeFi functional, composable, and useful.
Staking with private assets through Endur
Staking brings the yield layer into private DeFi.
Endur is building liquid staking infrastructure for Starknet assets, including STRK and strkBTC. As Starknet expands both staking and BTCFi, liquid staking tokens can become a core part of Starknet DeFi. STRK20 adds a new dimension to this: assets such as xSTRK and xstrkBTC can become shieldable.
Example flow: a user starts with strkBTC, stakes it through Endur, and receives xstrkBTC. Once supported, that xstrkBTC can be shielded, allowing the user to hold a yield-bearing BTC position privately.
Privacy should not force assets to become idle. Users should be able to protect visibility while still earning yield.
At launch, staking may not be fully private from every interface. Some users may stake through the normal Endur flow and then shield xstrkBTC afterward. As wallet and app integrations improve, staking should become more directly accessible from the same private asset experience.
This is one of the clearest examples of practical privacy. It applies privacy to a normal user goal: earning yield.
What is available now, and what’s to come
The first phase of STRK20 is the start of private DeFi on Starknet.
Through wallets like Ready X and Xverse, users can shield assets, manage shielded balances, and execute supported in-wallet swaps. These swaps can access existing liquidity through venues such as avnu and Ekubo, benefiting from the composability and scalability of STRK20’s design.
More advanced DeFi flows come next. Lending through Vesu, staking through Endur, and more complex private vault strategies from ForgeYields and Troves.
That is the phased rollout. Privacy starts with assets, then expands to broader DeFi workflows.
What private DeFi makes possible
In one broader flow, the user can:
- Shield BTC through strkBTC
- Stake into xstrkBTC
- Shield xstrkBTC
- Borrow USDC against xstrkBTC
- Shield USDC
- Trade privately with shielded USDC
This is the private DeFi unlock: privacy that moves with the user across DeFi, from holding and staking to borrowing, trading, and earning yield.
Every private transaction requires 4 STRK tokens, no variable price points will apply.
Privacy becomes compatible with the activities people already come to DeFi for.
That is why Starknet’s approach matters. Privacy is built into the existing ecosystem, enabling private DeFi that is usable where crypto already works.
Private DeFi starts on Starknet.
