In the last few weeks, Starknet made its leap into building a privacy solution that works for the practical crypto world with STRK20. STRK20 is Starknet’s privacy capability: it lets any ERC-20 token exist privately on Starknet through shielding, giving those assets shielded balances and private transfers. That capability has been live on mainnet for a while. Today opens up the next part: the Privacy SDK and Privacy Wallet API, so any builder, wallet, or app can build with that same capability instead of building the infrastructure and flows themselves. This is Push to Private: an open door for builders to build on and contribute to privacy that works for crypto.

Privacy, but make it practical

Most privacy products don’t fail because people don’t want them. They fail because they’re slow, expensive, isolated from real liquidity, hard to integrate, or hard to square with compliance. Starknet isn’t trying to win an argument about privacy as ideology. The goal is privacy that’s usable where onchain activity already happens: inside the assets, wallets, and apps people already use. 

The Missing Piece

STRK20 has been live on Starknet mainnet for a while, giving users shielded balances and private transfers through supported wallets. With the open sourcing of the SDK, it’s now open to builders too. The Privacy SDK lets any team build custom integrations and explore new ways to bring privacy features into their own apps. On top of that, wallets like Ready are shipping their own Wallet APIs, so builders can add shielding functionality without building the flow from scratch.

The Toolkit

Privacy SDK: a TypeScript client (Apache 2.0) for wallets and advanced integrators who want to manage viewing keys, proving, and notes directly. It wraps the low-level steps: registering a viewing key, opening channels and per-token subchannels, generating proofs against a configurable proving backend, and submitting them onchain.

Privacy Wallet API (spec v0.10.3): the application-layer route most dapps should use. Through starknet.js, your app asks the user’s privacy-enabled wallet to shield, transfer, unshield, or swap; the wallet handles proving and notes under the hood, so your app never touches a viewing key. Ready extension + starknet.js v10.4.0 are the current start path, with Xverse’s Wallet API rolling out.

Both routes sit on top of the same foundation: STRK20 and the privacy pool that powers it, already live on Starknet mainnet.

How it works

STRK20 is the capability; the pool is the infrastructure underneath it that actually holds and moves shielded balances.

The pool: not a mixer. Shielding deposits an ERC-20 into the pool, where the balance is held as an encrypted note (a UTXO). Private transfers spend existing notes and create new ones. Every private transaction carries a zero-knowledge STARK proof, verified onchain, confirming the notes are real, unspent, and that value is conserved, without revealing sender, receiver, or amount. Deposit and withdrawal amounts, and the fact that someone is interacting with the pool, stay visible; what happens inside it doesn’t.

Two ways in for builders: go direct with the SDK if you’re a wallet or advanced integrator who wants to own proving and note management. Go through the Wallet API if you’re building a normal dapp. You never touch viewing keys, notes, or proofs; the user’s wallet does that work.

For DeFi flows: anonymizer contracts do the work: app-specific contracts the pool calls atomically through a single entrypoint. The pool withdraws, your contract does its thing (swap, lend, or similar), and the result is credited back as private notes, all in one transaction. If any step reverts, the whole thing rolls back and funds return to the pool.

Want to run your own proving? Teams that need control over proving infrastructure can self-host using the open-source Prover Crate instead of relying on hosted proving. As a rough sense of cost: engineering benchmarks from a 12-core / 46 GiB machine generated proofs in roughly 29 seconds on a default build, faster with CPU-specific optimizations. Treat this as machine-dependent infrastructure data, not a laptop or phone number.

Coming next: private sub-accounts, which will let apps run everyday transactions (borrowing, staking, swapping) through accounts with no public onchain link back to a user’s main wallet. Not live yet; wallet and SDK support are still landing.

What’s possible with STRK20

By integrating STRK20 in your app flows, you can allow your users to participate in Starknet’s existing privacy ecosystem.

  • Anonymous DeFi from day one: private swaps run against Starknet’s existing liquidity instead of a separate, isolated pool. No cold-start liquidity problem, no unshield-swap-reshield dance.
  • Multi-call, one transaction: unshield, swap, borrow, repay, and reshield can all happen inside a single private transaction.
  • No new wallet to install: STRK20 works through your existing signing key via Starknet’s native account abstraction, rather than asking users to adopt a separate privacy wallet.
  • Confidential by default, disclosable when required: viewing keys give scoped, per-user visibility instead of an all-or-nothing choice between fully public and fully hidden.
  • Built for speed: Starknet is targeting sub-5-second finality and sub-$0.20 transactions at scale.

What builders can do with it

Concrete, available now:

  • Let users shield and unshield supported assets
  • Add private transfers to your app
  • Route private swaps through existing AMM liquidity
  • Start building private lending and staking flows: anonymizer helpers are already in progress for protocols like Vesu and Ekubo

Which route to use depends on who you are: wallets, DeFi protocols, and established teams typically go direct with the SDK plus their own anonymizer contract; most other dapps should start with the Wallet API through starknet.js.

Who else is building already

A first wave of ecosystem teams are already building privacy-enabled features on top of the stack:

avnu is Starknet’s trading and routing layer for STRK20 and private asset flows, starting with strkBTC.

Troves is building automated yield and vault strategies with private deposits and positions.

ForgeYields is building non-custodial cross-chain yield vaults on Starknet, and exploring how privacy can unlock institutional-grade allocation, letting depositors earn structured yield without revealing their positions, strategy exposure, or portfolio size on-chain.

Provable Games, the team behind Loot Survivor and other Starknet game infrastructure, is exploring how STRK20’s private token ownership can power private onchain organizations.

DeFa Invoicemate is building a private mainnet on Starknet, aiming to give lenders yield opportunities through TradFi and PayFi strategies, with a one-click toggle to keep wallet address and positions private.

Also building with the stack: Ready and Xverse on the wallet side, Endur (Starknet’s liquid staking layer, supporting private staking flows for shielded tokens like xstrkBTC), Polyhedge, and Ekubo.

And across the wider ecosystem: DashX, ArcX, Privily, Zylith, Vesu, Opus, and Cartridge are all building on or exploring the privacy stack in their own way.

Get Building

Privacy that works for crypto: built into assets, accessed through wallets, used across apps.