Tier lists ranking crypto cards have been popular on X for over a year, they praise the best options and criticize the rest. Yet most users still don’t realize the real risks they face when paying with these cards, or if any risks even exist.

Besides the obvious lack of privacy, there is something that we have been fixing in crypto wallets for ages — user experience. My theory is that achieving perfect or near-perfect UX is easy when you cover the problem of settlement and finalization in crypto cards or direct payments in general.

The Settlement Question is Overlooked

In the context of crypto payments, we can say that literally every transaction is a top-up.

• When someone sends you money, they top up your account.

• When you send someone money, you top up their account.

• When you pay for something, you top up the merchant’s account.

But those top-ups are actually quite different from each other and depend on which application or service you use. Topping up a CEX, topping up a crypto wallet, topping up a crypto card, and topping up a crypto payments service: those are all different top-ups with different trust assumptions and completely different UX.

Be aware that here I’m talking about UX in general, not UI (user interface) in particular. If we coin the term “instant UX,” which means that transactions are finalized at the exact time you click the button, it’s almost impossible because we have such a thing as latency (which applies to both traditional and crypto transactions).

I don’t want to manipulate technical terms for marketing, so I’m gonna use the “near-instant UX” term, which means you can finalize your transaction in under 1 second.

If you pay a merchant with crypto, there is only one outcome that you and your merchant want: the operation must be processed as fast as possible, so the merchant can let you walk out of the store to save your time and to let you to enjoy the stuff you bought.

• It is possible when you use a crypto card, because you’re not actually paying with crypto. At the point of sale, you pay with fiat money borrowed against your crypto.

• Payment terminals know how to work with those cards because they’re connected to global payment networks like Amex, Visa, or Mastercard, not because they accept crypto.

• You never paid with crypto, you use fiat money.

The problem of settlement exists in crypto cards only at the point of top-up — when you or someone else tops up your crypto card, you have to wait some time before the assets become spendable. The process looks something like this:

1. Send 100 USDC to address A.

2. Address A confirms it received 100 USDC.

3. 100 USDC is shown in the crypto card application.

4. 100 USDC is routed to another address using something like @RelayProtocol.

5. Address A no longer holds 100 USDC, but the application shows that you have that money.

In crypto cards, the problem of settlement at the point of sale doesn’t exist, because there’s nothing to be settled!

When you pay with a crypto card, you don’t send or initiate any onchain transactions: you spend real money. If you buy $10 worth of groceries, this $10 goes through Visa. There is no onchain transaction marking that you have spent exactly $10.

However, the end game is using real crypto to pay for things, not abstracting it away, because only that way can you have permissionless onchain payments available to everyone. The end game will be native crypto payments between buyer and merchant.

So in this case, we do indeed have the problem of settlement at the point of sale, because the transaction is onchain and subject to settlement and finalization, which do not happen instantly on the blockchains that are used the most today.

How Traditional Payments Handle Settlement

I would sound stupid if I said with a serious face that traditional finance is complicated and involves middlemen, because it’s obvious to 99.99% of people. However, it’s “middlemen”, not “middleman”, a lot of systems carry their own portion of risk:

• Visa or Mastercard relays the authorization to the bank.

• Your bank approves or denies the transaction. Bank can claw the money back up to 120 days after the deposit if you report fraud or something malicious (such chargebacks can cost millions annually).

• The merchant’s bank pays the merchant before it has actually received the money from your bank. It’s fronting the cash and trusting that the other side of the transaction will follow through later.

• The actual money movement between banks doesn’t happen until 1–3 days later, and even then, the transaction can still be reversed if something goes wrong.

In traditional payments, banks and card networks act as a buffer or safe place, they take on those risks and charge fees (make money) for providing this service. You never care about it, because it’s hidden — that’s how systems work.

Crypto payments are peer-to-peer, they don’t have middlemen to hide the complexity of settlement. There is no one to make promises and defend you.

Achieving “near-instant UX” here is different, it’s more complicated. We can’t just take tools from traditional banking and import them into crypto, because then we end up with traditional banking again, where we don’t really own our money.

Near-instant UX for crypto payments must have near-instant settlement, or some mechanism that protects against failed or reorganized transactions. I’d also say that the UX must be network-agnostic for everyday transactions, otherwise, it has too many frictions.

However, the settlement problem is a consequence of the problem of finalization.

Confirmation Does Not Mean Completion

A fundamental feature of most L1 blockchains is having two types of finality, optimistic and economic.

• Optimistic finality happens when you see in your wallet “your transaction is confirmed” and have either sent or received the funds. As the name suggests, it’s optimistic to say that you received or sent your money completely — it’s not yet realistic.

• Economic (deterministic) finality happens when your transaction is non-reversible. As the name suggests, it’s deterministic to say that you have received or sent your money completely — it’s realistic.

That only applies to blockchains like Solana, Ethereum, BNB Chain, or Hyperliquid. For example, Bitcoin doesn’t have a definition of finality that we got used to. There’s no moment where a transaction is absolutely final, it just becomes progressively more secure with each additional block.

But in most cases, proof-of-stake blockchains and rollups built on top of them have the same problem. The problem is the time difference between optimistic finality and economic finality.

Why does this gap in time happen? Distributed consensus across many nodes takes time. Faster finality can theoretically be achieved with fewer validators, stronger trust assumptions, or more complex protocol design, but it doesn’t mean it will be cheaper or that it will keep the same level of decentralization.

During this gap in time, reorganizations (reorgs) can happen. A reorg is when the blockchain throws out one or more recent blocks and replaces them with a different version of history, because a competing chain turned out to be longer or heavier. Being reorged has more chances than getting ADL’ed on 10 October, so this is something to keep in mind.

Why are they dangerous? Well, let me show a very high-level scenario:

• Alice sends you 1 ETH (Transaction A). It appears in the mempool but has zero confirmations.

• You immediately send 0.5 ETH from that to Bob (Transaction B). This transaction depends on Transaction A existing, so they are processed sequentially.

• Transaction A gets reversed (dropped from the chain due to a reorg).

• Now Transaction B is also invalid, because it references outputs that no longer exist. The network rejects it.

Who gets hurt in this scenario?

• Bob is the primary victim. He thought he received 0.5 ETH from you and may have already provided you goods or services in exchange. Now his incoming payment has vanished.

• You are hurt if Alice was attacking you. You gave Bob something of value based on funds you thought you had but never actually received.

• Alice (if malicious) is the only winner — she double-spent, keeping both her original ETH and whatever you gave her in exchange.

You can imagine a scenario with fewer or more people, but the final receiver in this chain of events ends up being hurt the most. So sending transactions here is literally like playing a hot potato game: throw funds to the next person as fast as possible.

If you have ever deposited crypto into a CEX, you know that you have to wait for multiple block confirmations before you’re able to trade the money you’ve deposited.

That’s exactly the difference between optimistic and economic finality. When optimistic finality is reached, a CEX will show you that your funds are processed. When economic finality is reached, a CEX will show you that your funds are available to spend.

CEXs are actually pretty conservative here, because they want to prevent the worst-case scenario where you might have already traded those funds or withdrawn other assets against that balance, so the CEX ends up taking a loss.

In the context of global crypto payments, we can’t just copy the CEX mechanism, because hey, the cashier is not gonna sit here and wait 15 minutes until your 64 Ethereum blocks are confirmed.

So after all of that, can’t we just use Bitcoin for payments then if it mitigates this finality problem? Well, no, because Bitcoin is very expensive and slow. It kills one problem, but it adds multiple other ones. Lightning Network was kind of like a solution back in the day, but transactions weren’t onchain anyway, it’s not as secure as using Bitcoin.

At the end of the day, we want to escape chain wars and have a network-agnostic solution, so people don’t care which chain they’re using. As almost every single blockchain right now is proof-of-stake, we’ve got to care about finality — we can’t escape it, unfortunately.

scenario 1: make people use a single chain or only chains that are fast and minimize the time between soft and hard finality.

One of the initial thoughts that pop up is what if we made available only a handful of chains that have faster block times than Ethereum or something similar.

Faster blocks and faster blockchains don’t necessarily mean that the gap between optimistic finality and economic finality is thinner. As I mentioned earlier, a merchant’s risk is not for a transaction to pop up, but for waiting for that transaction to become irreversible.

But there are also chains with really fast finality like Monad, Sei, or Sui, or even chains specifically focused on payments like Plasma, Arc, or Tempo. Can’t we just use them? I think it’s more of a BD problem than a technological problem, but also an economic problem.

Whether you like it or not, a lot of funds are already parked on giants like Solana, Ethereum, and even Tron. Bridging them to specific rails at point of sale can be either expensive, time-costly, or both (I’m not talking about scenarios where you already have funds on those chains).

With the amount of capital and volume on major L1s, you can’t exclude them from the race. The cost of an economic attack or other malicious activity is trending towards infinity, and it would be shameful to try to attack the grandpa who sells $3 pad thai at the side of the road in Thailand.

As much as we want to minimize the gap between optimistic and economic finalities, we can’t get rid of the money giants, even if they’re slow.

scenario 2: issue some kind of guarantee before finalization (insurance).

Even if we can minimize the finality gap, we still have to work with chains that we can’t modify to ensure accessibility for everyone. We can’t completely escape reorgs at the moment, but what if we have insurance?

Insurance can cover potential losses for merchants who sold their goods, but whose payment later got reorged (as we remember, the people who suffer the most from a reorg are end receivers in the supply chain).

If we take insurance as the final model, there are tens of ways we can design such a system — whether merchants will pay for this insurance on some subscription basis or this process will be automated. Insurance can be either a separate solution or a native part of crypto payment rails.

• If it’s separated, it’s pretty clear that the insurance fund is backed by money paid by merchants for this facility.

• If it’s a native part of payment rails, it is more interesting, as insurance can be a default protection for free for merchants if the insurance fund is filled with money from fees the payment rails are already making.

There are a lot of different options to think about. Someone might call it treating the symptom instead of the disease.

I would argue that near-instant UX across many chains with completely different mechanism design is like cancer in a positive way. It’s unsolvable yet, but we’re already finding amazing treatments.

What Merchant Really Cares About

We’ve been fixing the problem of complexity of blockchain solutions for many years already. A merchant doesn’t care whether a chain is L1, L2, L5, a rollup, proof-of-stake or proof-of-anything.

They care about one thing: can I be sure that my money will stay in my wallet after I provide them the service?

Protocol debates about decentralization and block times mostly miss the point from a merchant’s perspective. It’s also why traditional payments still dominate despite being slower underneath.

Visa says: “you’ll get paid, don’t worry” (in majority of the cases).
They don’t have any cryptographic finality or anything.

Crypto, as an industry, has an opportunity to not say anything and be the trustless, go-to option fundamentally, but at the same time we don’t need to scare merchants and buyers away by telling them all of that geeky stuff.

How Crypto Payment Models Handle Settlement Risk

We can divide crypto payment models nowadays into two categories: crypto cards and wallet payments.

As I said countless times before, crypto cards are literally just traditional cards: multiple middlemen absorb the whole risk, potential onchain failures are invisible to merchants, uptime and reliability guarantees are provided by Visa, Mastercard, or Amex, underlying banks provide guarantees of payment itself.

I would say that the biggest advantage here is that the scaling question is pretty straightforward, because the infrastructure is already here. There are no modifications needed at the point of sale, you just tap the card and that’s it.

The tradeoff is that this model inherits every limitation of traditional card payments: interchange fees, chargeback windows, processor dependency, etc. It doesn’t fix the fundamental problem — user custody and the right for everyone to transact (you can’t open a crypto card if you’re from a sanctioned country).

Are wallet payments different?

I define “wallet payments” as fully permissionless payments made from your wallet like Metamask or Phantom directly to merchants. Merchants can display a QR code or payment address (maybe even an ENS domain), and buyers can use that to pay.

This system is fully permissionless and transparent, and it sounds like an end game, right? Yes, but... due to several reasons, this exact scenario is very unlikely to happen anytime in the future.

The merchant absorbs nearly all settlement risk and is not protected from reorgs in any way. Even if we use scenario 1 or scenario 2 from the previous sections where reorg risk is minimized or almost completely eliminated, there is still such a thing as compliance and regulation.

Sure, your friend might sell you their PlayStation 5 without any legal stuff, but if you go to an official store, it’s unlikely they will let you buy it with crypto without any verification beforehand. No merchants know how to tell if they’re dealing with dirty onchain money, so this is eventually their protection and your protection to make sure no one steals anything.

The question of scaling is two-sided: yes, it’s very scalable, we have millions of units of blockspace, infinite transactions, IBRL. But crypto payments still need to be integrated in some way into PoS terminals or similar infrastructure.

Attempts of WalletConnect

One of the examples of native integration, but not optimized UX at the moment, is WalletConnect. They have recently announced their integration with PoS terminals, where you can pay with your crypto, however, the UX is far from perfect yet.

You have to scan the QR code with your phone, open the payment page, connect your wallet, choose the token you’re paying with, choose the network, and only then is your payment processed.

These are a lot of steps, but the main concern is connecting your wallet. These integrations will be used by crypto guys at first, so people who care about security are pretty paranoid about connecting their wallet for payment, when there could be another option of just sending it without connecting the wallet.

Even though UX friction from the merchant side is minimized, imagine telling them you will pay with crypto, or if you’re from a less safe country, imagine hearing some people in line say that you have crypto.

No single model dominates across all dimensions, which is fine — every market has different solutions where different users with different preferences use different solutions. But there is huge room for improvement for every model.

I believe that scenario 2 with insurance hasn’t really been covered anywhere, so next I want to focus on the part where we can have crypto-native payments and not care about finality, but just ensure merchants that they will receive the money.

Flexa & Guaranteed Finality

As I said before, the core problem we want to fix is finality and bringing “near-instant UX” for merchants and buyers.

If we take the insurance model (where the gap between optimistic finality and economic finality is insured), we can have a model like @FlexaHQ — putting up economic value that exceeds the risk of non-settlement. Or simply put:

“Guaranteeing that the cost of an economic attack is greater than the value that can be extracted (classic MEV conversations back in the day).”

• In Flexa’s case, the QR code scan can go both ways — either the merchant presents the QR code and the customer scans it (which renders a hosted payment page for soliciting payments from any wallet), or the consumer presents a QR code from within their wallet.

• After that, Flexa locks a corresponding amount of AMP from the relevant collateral pool (before any onchain confirmations). This AMP is held in escrow by a collateral manager smart contract on Ethereum. The merchant receives an instant authorization and guaranteed payout. AMP token is used as collateral in Flexa network.

• On one track, the merchant gets settled in their preferred currency (this happens immediately because the collateral backs it).

• On another track, the consumer’s actual crypto transaction propagates through its native blockchain and eventually reaches sufficient confirmations.

• Once that underlying transaction achieves finality, the locked AMP is released back into the pool and is now available to collateralize the next transaction.

• If the transaction fails for any reason, the AMP collateral is liquidated to cover the merchant’s payout, so the merchant loses nothing.

The collateral providers (people who have staked AMP into Flexa’s Capacity collateral pools) earn rewards from network transaction fees for taking on this risk.

Flexa separates merchant payment settlement from onchain confirmation: it fully backs each transaction with AMP collateral at the point of sale.

From the merchant’s perspective, the payment is finalized at this exact moment, there is no reason to ask the buyer anything, click any additional buttons, etc. Even if you pay with BTC and the transaction can take minutes to confirm, your payment will be done beforehand, since that time gap is covered by AMP.

Basically, the collateral decouples merchant settlement from consumer payment finality: these become two independent processes. The cost of attacking the system must be weighed against the fact that the collateral bears the loss, not the merchant.

This is scenario 2 that I described earlier. Fees from payments are essentially yield for collateral providers (stakers) who delegate their AMP, and if the transaction was malicious or reorged, AMP is liquidated and sold into the open market.

In every other approach, the guarantee is somehow tied to the chain’s confirmation process — you either wait for confirmations (slow), use a payment channel that eventually settles onchain (not efficient), or trust a custodial intermediary who absorbs the risk (centralized).

Flexa’s authorization depends only on verifying that sufficient AMP collateral is available and locking it, which is a function of the collateral manager contract, not the speed of whatever blockchain the consumer is paying with.

All blockchains have different finality properties, different confirmation times, and different attack vectors, hardly any of them provide instant finality suitable for retail payments.

• A merchant accepting 15 different tokens through Flexa doesn’t need to understand or worry about the finality guarantees of 15 different blockchains.

• Merchants don’t even need to care about the tokens they accept or the crypto aspect at all — they just scan the flexcode and receive the payment in their desired currency.

If you’re a Chinese reader with a VPN or someone who has been to China, you have used Alipay, where you just show your code to the merchant, they scan it, and the payment is completed within milliseconds.

The only reason why Flexa offers both types where either customer or merchant generates QR code is because it’s not realistic to ask big enterprise chains to up and install QR code displays if they don’t already have them.

This UI is already widely accepted among billions of people in the largest economies, so why wouldn’t we bring it to the USA as well? (Flexa is currently available in the USA, Canada, Latin America).

Who will be winning?

All of the issues come down to problems with the gap between two types of finality.

CEXes ask you to wait. For CEX, you can afford to wait to trade, but expecting a watermelon seller to wait for you while there’s a line of 10 other people who also want to buy watermelons would be weird. Weird and simply unoptimized.

Crypto payments are still in that early stage. Despite the fact that these are seemingly the most obvious use cases for crypto, a lot depends on the buyer’s side, the merchant’s side, and the overall environment in which all of this is happening.

There will be many solutions, there will be a very competitive market, but what we can do is look at and take the best from models that exist in traditional payments, and try to adapt them for crypto payments — taking the benefits from both approaches.

If we take the benefits of traditional payments in terms of UX (especially in Asia) and combine that with self-custody (which is the most important thing of crypto), we will be winning.

We take it, build specialized payments, and optimize them. In terms of optimization, two types of solutions could dominate: fully monolithic (where we simply use one chain and it handles everything) and modular (allow a lot of chains).

As many great people have said, collaboration always beats competition.

This research is part of a Hazeflow collaboration supported by the Amp Grant Program, with the sole goal of educating more people on the crypto payments landscape and the solutions available in this space.

This piece is mostly inspired by Vitalik’s recent tweet about changes and the current state of the market. While the whole market is down, it’s difficult to blame someone in particular, and I’m not here for it.

I’m here as someone who has worked with many Ethereum teams, invested on behalf of a venture fund in multiple protocols building on Ethereum, and was overall a huge fan of anything related to Ethereum and the EVM.

Unfortunately, I can’t say the same things anymore, as I feel like Ethereum doesn’t know where it’s going (and many people feel the same).

I don’t want to discuss the price action of ETH, but I also cannot ignore the fact that the number 2 cryptocurrency in the whole world behaves pretty uncertainly. No matter where the global market goes, ETH behaves more like a depegging stablecoin.

This essay is about what has happened to Ethereum over the past couple of years and why many are losing hope or have already lost it. Ethereum is not losing to Solana or something else, Ethereum is losing to itself.

Rollup-centric Roadmap

When Ethereum introduced a rollup-centric roadmap, literally everyone was excited. The promise was that rollups (and validiums) would scale, so transactions by end users would happen on rollups, while Ethereum would serve as a verification layer, a.k.a. focused on being L1 for rollups first, not for users.

Rollups are way faster and cheaper to develop than developing L1, so the future of 1000s of rollups seemed very possible and optimistic.

What could go wrong?

It turns out that everything could go wrong. Useless debates, prioritizing ideology over needs, constant fights within the community, an identity crisis, and abandoning the rollup-centric vision too late.

Anything that could go wrong went wrong. Most of the community saw Max Resnick as an absolutely incompetent evil person, only to find out that he was right in almost everything that he said.

Max, while working at Consensys, said a ton of things about what Ethereum needs to do to move forward, but only faced critics with very little support.

The peak of stupidity was when the whole industry started discussing whether some L2 is Ethereum or not, like:

• Opinion A: “Base is an extension of Ethereum, we contribute a lot to the Ethereum ecosystem”

• Opinion B: “Base is not an extension of Ethereum, it’s a separate one”

What the f*ck are we discussing here?

How does this conversation lead to a better future for Ethereum and its ecosystem? Why are people seriously arguing over what’s Ethereum and what’s not Ethereum? Don’t we have more important problems to solve?

If we decide that rollups are extensions of Ethereum because they use ETH as a gas fee, we’re on the right track. If we decide that rollups are not extensions of Ethereum, but apps that benefit from Ethereum, we’re on the right track.

Right? Absolutely not.

This ideological discussion is not really a discussion, but a confrontation between two circlejerks that are trying to prove who is right. We don’t need to PvP, we need to PvE. We need to understand that it’s not us against each other, it’s us together against the problem and the future.

Unfortunately, a lot of people prefer mental stimulation rather than even considering that their opinion may not be correct.

Prioritization of technical ideology over users’ needs

Based rollups, booster rollups, native rollups, gigagas rollups, keystore rollups.

• Which one is better, what will be the future, how will they be connected

• “this type is the future,” “no, this type is the future”

• “there is no reason not to develop based rollups”

• “native rollups will overtake the ecosystem because they are Ethereum-aligned”

All of these discussions... only for Arbitrum and Base to continue winning.

Technological superiority gives a lot of advantages to a player, but not when you compare apples to pears, or oranges to mandarins. It’s similar, it’s very similar, to an extent that users don’t really care about it. Nobody cares about it outside of the bubble. One precompile more, one precompile less — you’re not winning there.

“Oh, we’re actually Ethereum-aligned, we have an advantage, we’re very close to Ethereum and we reflect its core values, users are going to choose us.”

Which values, may I ask, and which users will choose you?

@0xFacet became the first Stage 2 rollup, they’re the definition of Ethereum alignment.

Where are they? Where are their users, developers, technical KOLs, and supporters of the Ethereum ecosystem and alignment? Where are those people? How many of you have heard of Facet? How many applications are available on Facet?

I have nothing against Facet personally. I talked to the founder multiple times and I respect him, he is a great guy. But where are all those people who said that we needed more Stage 2 rollups? I have no idea, and you have no idea as well.

Financial incentives are much stronger than technological incentives. I was a huge fan of Taiko and especially of their research around based rollups. Lots of benefits: stronger censorship resistance, neutrality, no sequencer downtime risk, L1 validators earn more money.

Where is the catch?

The catch is the financials behind the model. You can’t force people to give up their revenue just for the sake of “alignment.”

Arbitrum promised a decentralized sequencer. Scroll promised a decentralized sequencer. Linea, zkSync, and Optimism promised a decentralized sequencer. Where are they? Where are those sequencers?

Every rollup team had the line in their docs: “we currently have a centralized sequencer, but we have strong intentions to decentralize it in the future.” Almost nobody delivered. Metis delivered it, but people don’t care about Metis, fortunately or unfortunately.

• Do I think that they specifically overpromised it to be liked by influential ETH maxis? Yes.

• Do I think that they really wanted to decentralize their sequencers? Also yes, but it doesn’t make sense for them.

Coinbase (Base) is legally obligated to make as much money as they possibly can to deliver value to the company. The same goes for other teams, why would you kill your revenue source? It doesn’t make any sense.

Approximately only 5% of Base’s revenue goes to Ethereum. Rollups were never extensions of Ethereum.

Taiko had days when it paid more fees to Ethereum for sequencing than it received in fees from users’ transactions. And companies like Taiko had a lot of other expenses besides paying fees to Ethereum, obviously. Based rollups or any “Ethereum-aligned” rollup vision was only possible if teams gave up their revenue.

I’m not underestimating the importance of decentralization, security, and permissionlessness. But all of that doesn’t make sense when your only goal is to be ideologically right, not user-focused.

Not surprisingly, this weakness and the promises of Ethereum alignment brought grifters to this space.

Сonsequences of the rollup-centric roadmap

Eclipse, Movement, Blast, Gasp (Mangata), Mantra: these protocols were never meant to be built for the long-term future. It was really easy to hide behind the mask of Ethereum alignment, making Ethereum better, bringing SVM to Ethereum, etc.

All of them rugged in one way or another. All of the rollups realize that their token is almost useless because they pay fees in ETH, while their tokens have almost no utility. Grifters realized that you can create a lot of hype around the rollup-centric narrative and capitalize on that by dumping worthless tokens on retail.

Ethereum never recognized Polygon as a true L2, even though they played a significant role in securing more value for ETH. If you believe that rollups are “cultural” extensions of Ethereum, why not recognize something that is closely tied to Ethereum’s security and usage?

Polygon was very important for Ethereum in the 2021 bull market and contributed a lot to the growth of ETH as an asset, but yeah, it’s not an L2 and it doesn’t deserve to be appreciated by the Ethereum community. If Polygon were an L1, it would be valued way higher.

Even Paradigm, arguably one of the best VCs in crypto that contributed the most to the Ethereum ecosystem and even developed their own L2 (Ithaca), switched to developing an L1 (Tempo) with Stripe.

I think when your biggest believers go to build your competitor, you’re doing something wrong.

Ethereum Foundation doesn’t have direction

Even though Ethereum is technically decentralized, it’s culturally centralized around Vitalik. Ethereum’s inner circles are real, and as people say, all you have to do to succeed (however you define this word) is get the attention of people who are close to Vitalik and a couple of VCs who are influential in the space.

I’m not saying that you have to agree with everything Vitalik says, but his opinions basically define what’s good and what’s bad for Ethereum, and you cannot compete against that.

Firstly, it was ultrasound money, where the economics of ETH became deflationary with EIP-1559 and The Merge, and it would be a better store of value than Bitcoin. In 2024, ETH’s annual inflation rate turned positive.

So the ultrasound money vision only lasted 3 years? It can’t become a store of value this way. The narrative was dead, moreover, it was never true, because ETH wasn’t designed to be a store of value, it was the purpose of Bitcoin, and you can’t compete with it.

Then Ethereum couldn’t decide whether its token is a commodity (not applicable because of dynamic supply changes and staking mechanisms) or more like a tech stock (not applicable because there’s not enough revenue to value Ethereum like a tech company).

Other people argue that ETH is not money at all. What’s happening here? We need to pick a side.

Ethereum can’t be multiple things at once — you either have a globally defined direction, or you lag behind.

Financial Incentives… Again

I still cannot imagine how a Lead Engineer like Péter Szilágyi was paid around $100k per year for his contributions to Ethereum. The person who was there from the beginning and helped Ethereum reach $450b from almost zero was paid only 0.0001% of the market cap.

The most influential and most successful protocol in the history of crypto (after Bitcoin) didn’t offer any incentives or equity. It’s easy to justify this by hiding behind the decentralization, open-source, and permissionless ethos: “we’re not here to make money, we’re here to move forward.”

But you have to incentivize even your most devoted soldiers, or they will leave or take deals on the side.

• Péter left, Danny Ryan left, Dankrad Feist went straight to Tempo.

• Justin Drake and Dankrad accepted advisory roles with EigenLayer in 2024, where they were allocated tokens, and the community started hating them for it.

Poor guys making peanuts in the EF (compared to FAANG companies and AI research labs) got hate because they’re making money and helping a protocol that is not Ethereum, but the separate protocol that wanted to make Ethereum better.

Are you stupid? Sometimes I feel like if you’re an honest and hard-working person in Ethereum, you’re not allowed to earn money and are just expected to be a slave for the sake of “recognition” from the Ethereum side.

EF was constantly selling ETH to fund different operations, initiatives, and research. But maybe pay your researchers first?

Zero tolerance for adaptability

“Day 1. Ethereum is going to win. The most decentralized blockchain with the highest uptime.”

We hear this every day, just as we hear excuses from Ethereum every day.

• Yes, Ethereum is expensive and slow. But we have rollups, use rollups, rollups are Ethereum!

• Yes, ETH’s price lags behind everything. But Ethereum has the largest developer ecosystem, we have a strong foundation, the demand will follow.

• Ethereum is the most decentralized blockchain! Solana sucks, they don’t have client diversity.

• Ethereum has 100% uptime! Solana sucks, it went down multiple times.

• Ethereum has lower network activity than Solana. Well, that’s because Solana’s activity is spam and memecoin gamblers. We’re an ethical chain!

Same excuses, same answers, same responses over the last years. Everything is shit besides Ethereum and rollups. If Ethereum underperforms in any metric, we say it’s day 1, we know what we’re doing, there is no place better than Ethereum.

Everyone is tired of the excuses that the community makes over and over again.

Ethereum feels like an old rich grandma who can barely walk and denies any innovation, but gives money to her kids and grandkids who parasite on her.

Reforms

I was finishing this essay just a few hours before Vitalik tweeted that the rollup-centric roadmap was a failure and that they needed to find a different path and scale L1.

You know what, I’m happy when people realize their mistakes, it takes bravery to say this out loud. But I think it might be too late. Ethereum has found a path it needs to take over the long term again, but things are still moving slowly.

The EF had some changes recently: new leadership, treasury transparency, R&D restructuring, and lots of other things. The EF started hiring new young talents from the devrel and marketing side like Abbas Khan, Binji, Lou3e, and others.

But changes need to happen fast. Ethereum has to sprint to prove everyone wrong.

Let’s see if, after those reforms and changes in the EF, we can see Ethereum becoming an object of excitement rather than an object of blind delusional belief and disappointment.

This article is about the network effects of private blockchains, which are way stronger than those of public blockchains. I’m sure that a single player can basically capture the whole market, and it’s way easier than it seems.

The key privacy player will have no competition at all for years to come and will become an industry standard that everyone will adopt.

I won’t explain why different users need privacy, because it is obvious. Everyone needs privacy — it’s a fundamental human right stated in many constitutions across the world.

I will explain how powerful private network effects are, and why there’s a high possibility of just one solution eating the whole pie.

How Private Network Effects Work

When you use a private blockchain (send some transactions), you’re actually locked into this chain. It’s similar to how public chains try to attract users and lock them into their ecosystem, but the incentives here are completely different.

Most acquisition mechanisms of new chains are financial: higher yields, earning points, farming rewards, etc. It’s a fairly easy method to acquire new users (who doesn’t like money?), but it’s also quite easy to game and max-extract value from users themselves.

Most public chains have nothing to offer besides financial incentives, so people join the chain → farm incentives → incentives are distributed → leave.

• Users stay because of liquidity mining campaigns, not because of other users.

• These mechanisms don’t have strong network effects, and there is almost no retention (which is justified because of financial motives).

In private blockchains, users might actually stay because of other users, because the data stays private if it doesn’t leave the blockchain (closed system).

The effect of saying “I’m transacting here privately” is more powerful than the effect of saying “I’m getting good yield here”.

I agree that good yield might sound more attractive in the short term, but there is absolutely no competition long-term. One product can be timeless, while the other one is like Clubhouse during COVID times.

When users choose a private blockchain, their choice matters much more than in public ones, because once they join one, they’re less likely to move and risk being exposed. This eventually creates a winner-takes-most scenario.

One privacy solution can dominate the whole market because of justified strong network effects without financial incentives.

• As Ali Yahua from a16z said, privacy creates chain lock-in.

• When you move from one zone to another, your data (even for a moment) ends up in-between those zones and can be targeted (more on that in the next section).

If enough users / participants / people join a certain private platform, it can very easily become a standard. Why? Because of network effects + developing permissionless private tech is more expensive (both in terms of time and money), there is less competition.

• That’s why Solidity (EVM) became a standard — developing a new virtual machine and a programming language is expensive.

• And that’s the same reason why Solana (SVM) became the strongest competitor — developers can use Rust, a language that already had established network effects.

An end-game private chain must be the destination: a platform where people are ready to hold their funds long-term and not bridge to other platforms. If participants use the chain just for a couple of transfers, it’s like a layover where people need privacy at a particular moment.

Private chains should always aim to become the destination where all actions (including the most significant ones) happen inside.

The platform will get a winner-take-most outcome, but an even more likely winner-take-all outcome in the end. A privacy chain can choose its specific dimension (like Bitcoin dominating “store of value”) and dominate very easily with private network effects.

There could be another player with a similar purpose (like what silver is to gold), but once a standard has been accepted by the majority and/or key players, there is no second-best option and absolutely no competition.

Messaging between private chains

Thank God we can say that we fixed interoperability. @debridge produces millions in daily bridging volume and LayerZero became a dominant messaging protocol between public chains.

I can bluntly say that now it’s “trivial” to move assets and other data from one chain to another as long as everything is public. You see, when we were exploring interoperability, the main concern was the same as Bitcoin’s — make it secure and avoid any fraud. We made it secure (despite a couple of exploits), but privacy was never part of the conversation.

Privacy was never part of the design of all modern interoperability protocols. In fact, messaging protocols don’t have to be private, or we will have Tornado Cash 2.0 and innocent founders will go to jail because DPRK will launder money there.

So there’s always a risk when you’re moving out of one zone to another: your transaction can be used against you, either via MEV exposure, congestion, address poisoning, and a dozen other things.

It doesn’t matter if it’s public <> public, public <> private, or private <> private connection, because bridges have to be transparent enough to track fraud activity. Bridges have to leak transaction timings, size correlations, and similar data.

I doubt we can really change that, but here is also an opinion from @fede_intern:

I also want to make it clear that the supremacy of a single private chain doesn’t eliminate the idea of app-specific chains. Sometimes apps are better off existing on their own rails, like Hyperliquid and Lighter.

But do you know any other examples?

Appchains are not in demand. As I mentioned earlier, new general-purpose chains often have nothing to offer besides financial incentives. Therefore, there is no reason to waste time figuring out privacy transfers between them, even though the private network effects thesis doesn’t conflict with it.

Private Foundation vs. Private Opt-In

Another argument that someone might make is that we don’t really need private chains; we can build privacy solutions on top of public chains. At the end of the day, institutions want to buy and sell crypto without people knowing what they’re doing.

• As the guys from

  @tiger_research

  mentioned, NVIDIA doesn’t want to tell everyone how much they transfer to Samsung, and a hedge fund doesn’t want to tell everyone exactly when they’re deploying capital.

• At the same time, when your blockchain is completely private like Monero, where transactions are untraceable, you will very likely have problems with regulators.

• Still, at the same time, blockchains like Zcash also don’t fit, because this selective privacy is not flexible enough. You can choose which transactions to make private, but you can’t choose which exact details to hide.

The definition of a private blockchain has changed over the years. It was first imagined as an invisible permissionless black box; now it’s more like a permissionless black box where you can color the parts you want. Just being private is not enough anymore — you want to be privacy-flexible.

It’s also one of the reasons why zkTLS gained so much traction over the last year: you can import your personal (private) data into web3 and only disclose the specific details. If you want to buy alcohol, you prove you’re over 18 (or 21 in the land of freedom), with no need to disclose your exact age or show documents with way more data than needed.

If you’re curious about zkTLS, you can learn more here:

Pavel Paramonov

@paramonoww

OP

Private Network Effects: Winner Takes It All

This article is about the network effects of private blockchains, which are way stronger than those of public blockchains. I’m sure that a single player can basically capture the whole market, and it’s way easier than it seems.

The key privacy player will have no competition at all for years to come and will become an industry standard that everyone will adopt.

I won’t explain why different users need privacy, because it is obvious. Everyone needs privacy — it’s a fundamental human right stated in many constitutions across the world.

I will explain how powerful private network effects are, and why there’s a high possibility of just one solution eating the whole pie.

How Private Network Effects Work

When you use a private blockchain (send some transactions), you’re actually locked into this chain. It’s similar to how public chains try to attract users and lock them into their ecosystem, but the incentives here are completely different.

Most acquisition mechanisms of new chains are financial: higher yields, earning points, farming rewards, etc. It’s a fairly easy method to acquire new users (who doesn’t like money?), but it’s also quite easy to game and max-extract value from users themselves.

Most public chains have nothing to offer besides financial incentives, so people join the chain → farm incentives → incentives are distributed → leave.

• Users stay because of liquidity mining campaigns, not because of other users.

• These mechanisms don’t have strong network effects, and there is almost no retention (which is justified because of financial motives).

In private blockchains, users might actually stay because of other users, because the data stays private if it doesn’t leave the blockchain (closed system).

The effect of saying “I’m transacting here privately” is more powerful than the effect of saying “I’m getting good yield here”.

I agree that good yield might sound more attractive in the short term, but there is absolutely no competition long-term. One product can be timeless, while the other one is like Clubhouse during COVID times.

When users choose a private blockchain, their choice matters much more than in public ones, because once they join one, they’re less likely to move and risk being exposed. This eventually creates a winner-takes-most scenario.

One privacy solution can dominate the whole market because of justified strong network effects without financial incentives.

• As Ali Yahua from a16z said, privacy creates chain lock-in.

• When you move from one zone to another, your data (even for a moment) ends up in-between those zones and can be targeted (more on that in the next section).

Ali Yahya

@alive_eth

·

Dec 5, 2025

Privacy will be the most important moat in crypto.

Why? Because secrets are hard to migrate.

Everyone is launching a new “high performance” blockchain lately. But these chains are hardly different from one another. Blockspace is functionally the same everywhere. And with

Show more

If enough users / participants / people join a certain private platform, it can very easily become a standard. Why? Because of network effects + developing permissionless private tech is more expensive (both in terms of time and money), there is less competition.

• That’s why Solidity (EVM) became a standard — developing a new virtual machine and a programming language is expensive.

• And that’s the same reason why Solana (SVM) became the strongest competitor — developers can use Rust, a language that already had established network effects.

An end-game private chain must be the destination: a platform where people are ready to hold their funds long-term and not bridge to other platforms. If participants use the chain just for a couple of transfers, it’s like a layover where people need privacy at a particular moment.

Private chains should always aim to become the destination where all actions (including the most significant ones) happen inside.

The platform will get a winner-take-most outcome, but an even more likely winner-take-all outcome in the end. A privacy chain can choose its specific dimension (like Bitcoin dominating “store of value”) and dominate very easily with private network effects.

There could be another player with a similar purpose (like what silver is to gold), but once a standard has been accepted by the majority and/or key players, there is no second-best option and absolutely no competition.

Messaging between private chains

Thank God we can say that we fixed interoperability.

@debridge

produces millions in daily bridging volume and LayerZero became a dominant messaging protocol between public chains.

I can bluntly say that now it’s “trivial” to move assets and other data from one chain to another as long as everything is public. You see, when we were exploring interoperability, the main concern was the same as Bitcoin’s — make it secure and avoid any fraud. We made it secure (despite a couple of exploits), but privacy was never part of the conversation.

Privacy was never part of the design of all modern interoperability protocols. In fact, messaging protocols don’t have to be private, or we will have Tornado Cash 2.0 and innocent founders will go to jail because DPRK will launder money there.

So there’s always a risk when you’re moving out of one zone to another: your transaction can be used against you, either via MEV exposure, congestion, address poisoning, and a dozen other things.

It doesn’t matter if it’s public <> public, public <> private, or private <> private connection, because bridges have to be transparent enough to track fraud activity. Bridges have to leak transaction timings, size correlations, and similar data.

I doubt we can really change that, but here is also an opinion from

@fede_intern

:

I also want to make it clear that the supremacy of a single private chain doesn’t eliminate the idea of app-specific chains. Sometimes apps are better off existing on their own rails, like Hyperliquid and Lighter.

But do you know any other examples?

Appchains are not in demand. As I mentioned earlier, new general-purpose chains often have nothing to offer besides financial incentives. Therefore, there is no reason to waste time figuring out privacy transfers between them, even though the private network effects thesis doesn’t conflict with it.

Private Foundation vs. Private Opt-In

Another argument that someone might make is that we don’t really need private chains; we can build privacy solutions on top of public chains. At the end of the day, institutions want to buy and sell crypto without people knowing what they’re doing.

• As the guys from @tiger_research mentioned, NVIDIA doesn’t want to tell everyone how much they transfer to Samsung, and a hedge fund doesn’t want to tell everyone exactly when they’re deploying capital.

• At the same time, when your blockchain is completely private like Monero, where transactions are untraceable, you will very likely have problems with regulators.

• Still, at the same time, blockchains like Zcash also don’t fit, because this selective privacy is not flexible enough. You can choose which transactions to make private, but you can’t choose which exact details to hide.

The definition of a private blockchain has changed over the years. It was first imagined as an invisible permissionless black box; now it’s more like a permissionless black box where you can color the parts you want. Just being private is not enough anymore — you want to be privacy-flexible.

It’s also one of the reasons why zkTLS gained so much traction over the last year: you can import your personal (private) data into web3 and only disclose the specific details. If you want to buy alcohol, you prove you’re over 18 (or 21 in the land of freedom), with no need to disclose your exact age or show documents with way more data than needed.

If you’re curious about zkTLS, you can learn more here:

Anyway, this type of selective and flexible privacy is only possible when the foundation (blockchain) was designed with privacy in mind. So in most cases, privacy on public chains is questionable.

Pseudonymity, security, trustlessness — yes. But not privacy in essence. It doesn’t matter if some liquidity pool is private if ramps, vaults, and actions before and after this private element are public.

The conversations about whether private blockchains should use TEE, MPC, FHE, or ZK are pointless as well, because there will always be smart people on all sides advocating for their side.

• Moreover, we can combine these technologies together to create better designs.

• Their trade-offs are unrelated and can be compensated.

• For example, MPC can replace hardware keys and serve as a key management service for TEEs.

The general-purpose foundation must be some combination of privacy and high-throughput to capture the whole market and open opportunities for everyone to participate (users and developers). Some solutions already exist today (I will mention them in the next sections), but there’s obviously still a long way to go.

The future of DeFi cannot exist without foundational infrastructure of selective privacy. At the end of the day, privacy protocols on top of public chains often treat the symptoms, not the cause.

Public chains lost their edge

Blockspace has become excessive. Well, it’s excessive for simple and moderate operations, but if we take all the blockspace of all blockchains in the world, it still wouldn’t be enough to launch something like DoorDash or Uber just in LA.

Blockspace is like an infinite pool that we will never fill, but at the same time you cannot put a shark here (that’s one of the reasons why companies like @eigencloud gain a lot of traction). Blockspace doesn’t differ anywhere, so there is nothing to compete on for public chains.

• Blockchain fees are trending towards zero, tech is pretty similar, but at the same time very different everywhere.

• However, it doesn’t change the fact that people stopped caring — we rarely see discussions anymore about whether based rollups, native rollups, or validiums will win.

• General-purpose rollups are having a tough time. Debates are over and they weren’t even settled.

What do public chains compete on now?

Developer tools, funding, speed, support, ecosystem vision? Maybe, but all of that can be unified into a single term — the best network effects. Bitcoin, Solana, and Ethereum have already established strong network effects.

Private network effects are way stronger than public network effects, so in this dimension, I don’t think there is competition. Now, anyone can spin up a fast chain, subsidize fees for some time, attract temporary liquidity, and exit, just like Movement, Eclipse, or Blast. Network effects didn’t last there.

Public blockchains attract network effects to crypto as a whole, while private blockchains attract network effects only to themselves.

Secrets aren’t supposed to be transferred

Ali Yahya said that bridging secrets is hard. True, but also what’s true is that secrets are not supposed to be bridged or shared.

Secrets are valuable. When you tell multiple people your secret in real life, it’s not a secret anymore — it’s public knowledge. Private things become public very quickly, but public things rarely become private.

We’re not supposed to move secrets, so the opportunity for a closed system (private blockchain) to flourish and dominate the field is practically unmatched. It will be the combination of encrypted store of value, programmability, and obviously verifiability.

I imagine scenarios with confidential transfers on public chains (similar to shielded pools on Zcash), but I hardly imagine huge, blooming privacy-preserving infrastructure built on top of public chains.

How should private platform look like?

Well, this question is pretty easy to answer. The platform must be built with compliance in mind. And if we have compliance in mind, we have to make sure that the platform is permissionless, so it has to be a decentralized L1 (not like Ripple) or a non-financially motivated L2 (not like Base).

What happens if critical financial infrastructure is operated by people who are legally obligated to generate financial value for stakeholders? Nothing good, for sure.

The only viable option is a permissionless open-source blockchain which has no one to satisfy (legally). It’s needed to build trust. The only way to build trust today is to make sure that people who support the infrastructure can’t extract profit from it whenever they want.

That is even more critical for a private chain, because the value can be extracted not only from manipulating the transactions, but also from manipulating the information inside these transactions (data confidentiality).

If institutions and participants adopt something like this on-chain, it will serve as a universal source of truth just like permissionless blockchains today, but with reduced transparency and the ability to control what information to disclose.

Legal risks, margins, large orders, and information safety — everything can be protected and verified.

Who are the candidates for winning?

The winner will allow everyone to have confidentiality: positions can remain private, participants can remain anonymous (not pseudonymous like right now), and the exact logic of a particular transfer will not be observable. Liquidity will flow like lightning, while the containers remain dark.

There won’t be any tradeoffs like there were before — no compromises in UX, high-throughput, and overall usability. The winning chain will have highly flexible privacy on-demand, but designed as a private chain from the ground up.

I don’t believe Monero or Zcash will take the stage, simply because they don’t have native smart contracts. Both blockchains are used by privacy enthusiasts, but it’s time for new players to shine.

Now we have a few candidates: Aleo, Seismic, Canton, Aztec, and Miden. I will not analyze each chain (this part will be longer than the whole article), but I can say that each of them can win. Well, some of them are already winning.

• Canton Network has the biggest traction so far, and honestly, it seems like they’re ahead of everyone at the moment.

• Miden is unproven yet, but technically impressive.

• If the Ethereum roadmap shifts more towards privacy, Aztec might win.

• Aleo can win developers with Solidity.

• Seismic can eat the market share of Canton with a16z support and a background in fintech.

Anything can happen and no one knows who will dominate or where the exact moment will be when we can say “yeah, they won”. It will come with time, and what’s left for observers is to observe and what’s left for builders is to build.

Crypto protocols are not media outlets, they don’t have to push multiple long-form pieces per day. You optimize for quality over quantity: you want to gain recognition in the field, you want to keep it technically accessible for potential users, but you also want it to be deep enough for technical people to understand the difference.

The core difficulty is how

to present the product, the thoughts behind it, the architecture behind it, and the outcome in a way that people care about.

You can brainstorm this with AI, but it’s impossible for any model to lay a foundation for work that has even a small part of creativity.

Humans like to read things that other humans write. The taste of the presentation, the vision behind it, and just the “gut” that something is right make people care about the thing they’re reading.

• @a16z defined New Media as their service that helps startup founders with brand strategy, storytelling expertise, and media distribution to grow influence and build generational companies.

• I want to define New Media slightly differently — it’s the authentic human publications that make your product, brand, or company more recognizable in the field you operate in over time.

Different Stages For Caring

Each crypto company often experiences four stages: pre-fundraising, pre-product, pre-TGE, and post-TGE. Each stage is obviously very different from each other because priorities, target audiences, and outcomes are also different.

Founders experience the whole color spectrum when they have to pivot to slightly different intermediate goals, even if they’re doing alright.

• When you’re pre-fundraising, you want to look good in front of investors.

• When you’re pre-product, you want to look good to potential developers and new hires.

• When you’re pre-TGE, you want to look good to potential token holders (I’m not talking about teams who want to dump everything on TGE).

• When you’re post-TGE, you want to look good in front of basically everyone because now you have two things to justify: your core protocol and token performance.

Each stage is different, and each stage requires deep thinking and explanation of why things are built this way and how they’re built this way.

I think the most challenging part here is when you’re pre-product. To brag is not an option because you don’t have the data to back up your thesis (and you don’t want to lie). You don’t really have a lot to show yet, but you still want to capture attention for the upcoming product.

What should you do?

Hazeflow x Raiku

That’s one of the cases that we have been working with Raiku. First, I want to say that they’re an amazing team who we’ve been working with for over seven months now, and I believe Robin assembled Barcelona in its prime (sorry Real Madrid fans).

Anyway, Raiku is still in the development stage and their product is not live yet, but you can already start building a connection between the product and audience — precisely, builders at the moment.

You can’t build a deep connection without deep conversations.

After someone has finished your article, they shouldn’t only think about how good the article was, they should also think about who was behind this article. This is something that builds connection and retention.

In the current chaos on X where the “tips format” is popular, do you really care who was behind writing these tips if they were put out without much thought behind them? No!

You might find them useful right now, but you forget them after you exit the page. Each article (and content strategy in general) should be done with deep research behind it — people only come back when you give them some value.

Each piece of content has a different value behind it, whether it’s an interesting statistic, an explanation of how a particular architecture component functions, or a case study that shows how the product was used, can be used, or will be used in the future.

You have to highlight weaknesses

Every protocol / ecosystem / infrastructure you’re building on has some weaknesses. If you’re planning to live in a new country, you usually want to know both pros and cons.

• It’s easier to highlight pros because they’re usually on the surface.

• Finding cons (especially non-obvious ones) is harder. You don’t want to move into a new country without knowing what might make your stay not so pleasant.

Developers moving to a new ecosystem is the same process as people moving to new countries. You want to know something in advance (reading docs), something when you go there for tourism (exploring tools), and everything when you move there (focusing on development).

It’s better to build trust through saying “Yes, we know, guys, there are such problems at the moment, it’s not ideal, but we still love it here because of x, y, and z”. Rather than saying “We love it here, it’s the best place in the world…”

You want to relate to potential users, investors, developers, and ecosystem users. It’s tough to relate when you’re fully unaware of problems, and you can only be aware of different problems and mention them to others when you do research!

It’s fundamental to research before producing and saying something.

Clarity & Depth

Every team should aim for effective communication internally and externally (I still believe the comms role is very underrated).

When you talk to a bunch of people externally, all of them have different interests. Someone wants X, someone wants Y, someone wants Z: how do you fit this into a single article?

Well, that’s the beauty of the combination of a technical job and a creative job — making complex topics accessible without dumbing down.

The core thing that we’re doing with Raiku is making sure that articles are understandable to a broad audience while retaining technical flexibility.

• If some segments are intended for validators or developers, we add more precise technical terms.

• If some segments are for the general reader, we balance the technical stuff with analogies.

It sounds simple, but cooking all of this is difficult but fun (otherwise Hazeflow wouldn’t exist).

Examples

Debunking Myths

One myth that we wanted to debunk about Solana is that it goes down. Solana had a series of outages back in 2021-2022 during the bull market peak activity. That is something that each Ethereum maxi or competing chains like to bring even nowadays, but those moments are well behind.

Of course, it’s not that easy to just say “Solana is stable more than ever” — we need to back it up with some data.

• Pump.fun peak activity with 70,000+ tokens launched in a single day didn’t break it.

• When Donald Trump launched his token, Solana processed $38B in DEX volume (Ethereum’s max was $6B) and didn’t break.

• When the market got ADL’d in October 2025, the slot duration was only 395ms (versus 392ms baseline), only a 3ms increase despite a 32x fee spike and 2.7x transaction surge.

• And more stuff.

So eventually we’re saying that outages happened, but they were in the past and those times are not relevant for us now. It only shows that the network is more stable than ever and the network has matured, so potential developers join the ecosystem that is constantly innovating. Here is the article that we have made: click here.

Applying Medicine

Another goal that we had is showing the problem of transactions failing on Solana, because Raiku is literally a solution to this problem in different ways. Transactions can land, but they can also be delayed as well.

• If a transaction lands late, you can miss a liquidation, lose an opportunity to arbitrage, or even fail loan repayment.

• Some transactions must land immediately, some at an exact time, and some just need to land cheaply in general.

That was an ideal topic to discuss the two execution paths that Raiku has: Just-In-Time and Ahead-Of-Time. We explained why transactions fail in the first place (gives value to a general reader), what AOT and JIT are (gives value to institutions), and how Raiku works in general (gives value to developers).

There are multiple topics that we have covered in a single article which educated people, gave technical explanation, and introduced a product. To learn more, here it is: click here.

Explaining Benefits

While Raiku’s product is not fully live, we’re obviously at the pre-product stage. In Raiku’s case, we need to attract more builders to Solana in general and establish ourselves as an authority in the field, so when people think of Solana, they also think about Raiku (and Mert, Solana’s CEO, as well).

So we have decided to dig really deep into accounts, programs, ownership, transactions, PDAs, and other different stuff and learn how it all works together.

This is one of the most fundamental articles about how Solana works, and we’ve received a lot of positive feedback on it from the team and from builders as well.

I believe that if you fully understand the topic, there are countless ideas that you can explore, and they can be unfolded in a way of combining something deeply technical with something deeply creative. To read, click here.

New Media

This is our definition of new media. Something authentic and AI-free, both creatively unique and technically precise, written by humans for humans that makes your product more recognizable over time.

We’re happy to continue working with the Raiku team on that horizon and looking forward to working with new long-term talented teams.

My general thesis is that crypto cards are a temporary solution to the problem that we all know — two problems, to be exact: bringing crypto to the masses and making sure crypto is accepted as a payment method worldwide.

Crypto cards are still cards, and if someone has true crypto values and believes in a future dominated by cards, you might want to rethink your vision.

All crypto cards companies will eventually die

Crypto cards will most likely die long-term, but not traditional ones. Crypto cards add another layer of abstraction: it’s not a pure crypto use case. Card issuers are still banks. Yes, they have a different logo, different design, different UX, but as I said before, it’s abstraction, and abstracting makes things function differently and more conveniently for the end user, but the processes stay the same.

Different L1s and rollups are obsessed with comparing their TPS and infrastructure to Visa and Mastercard. And it has been a goal for years: the goal “to replace” or if you’re more contrarian “to dethrone” Visa, Mastercard, AmEx, and other payment processors.

This goal is not possible with crypto cards — they’re not a replacement, they bring even more value to Visa and Mastercard.

• They are still critical gatekeepers, and they wield the authority to set any rules and define their compliance standards, etc.

• Most importantly, they retain the option to ban your card, ban your company, or even ban your bank if they decide to do so.

How come the industry that has always aimed for permissionlessness and decentralization now wants to hand all of that over to payment processors?

1. Your card is Visa, not Ethereum.

2. Your card is a traditional bank, not MetaMask.

3. You spend fiat, not crypto.

Most of your favorite crypto card companies don’t do anything besides slapping their logo on the card, and that’s it. They just ride on narratives, they won’t be around in a few years, and digital cards issued until 2030 won’t function until then.

I will explain later in this writing how easy it is to make your own crypto card these days — in the future, you can even make your own!

Same issues + more fees

The best comparison I’ve managed to come up with is app-specific sequencing. Yes, the idea that apps can navigate their own transactions and profit from it is cool, but this is temporary: infrastructure costs are going down, communication is maturing, and the economic problems are a layer higher, not lower.

(Here is a good talk about ASS by @mvyletel_jr, if you’re interested).

Same with crypto cards: yes, you can deposit crypto and your card will convert it to fiat so you can pay, but centralization and permissioned access are still issues.

It certainly is helpful temporarily: retailers don’t need to adopt new payment methods, and crypto spending is kind of invisible.

But this is just another step toward what most crypto believers want:

• Need: paying with your stablecoins, Solana, Ethereum, Zcash directly

• No need: paying with USDT → Crypto Card → Bank → Fiat indirectly

Adding one more layer of abstraction adds one more layer of fees: spread fees, withdrawals, transfers, or even custody yields sometimes. It might seem insignificant to you, but hey, it’s compounding: a penny saved is a penny earned.

Using a crypto card doesn’t mean you’re unbanked or bankless

Another thesis that I’ve been observing is that people think they’re unbanked or that they go bankless if they’re using a crypto card.

Of course, that’s not true. Under the crypto card label, there is a bank, and the bank is required to send information to its local government about you. Not all data, of course, but at least some of it.

If you’re an EU citizen or resident, the government knows your interest earned on bank accounts, large suspicious transactions, certain investment income, account balances, and more. If the underlying bank is American, they know even more.

Surprisingly enough, that is both good and bad from a crypto perspective.

• It’s good in terms of transparency and verifiability, but the same rules apply if you use a standard debit or credit card issued by your local bank.

• It’s bad because it’s not anonymous or pseudonymous: banks still see your name, not an EVM or SVM address, and you still do KYC.

Restrictions are still present

You might say that crypto cards are great because they’re really easy to set up: you download the app, complete KYC, wait for verification for 1–2 minutes, top up crypto, and you’re good to go. Yes, this is honestly a killer feature in terms of how easy and convenient it is, but it’s not accessible to everyone.

Russia, Ukraine, Syria, Iraq, Iran, Myanmar, Lebanon, Afghanistan, and half of Africa — citizens of those countries are not eligible to use crypto for their daily spending if they don’t have residency in another country.

But hey, those are just 10–20 countries that are not eligible for most crypto cards, what about the other 150+ countries? It’s not about the majority who are eligible — it’s about crypto values: a decentralized network of equal nodes, equal access to finance, equal rights for everyone. This is not present in crypto cards because they’re simply not crypto.

Max Karpis broke it down perfectly here on why “neobanks” are designed to fail at first.

For reference, the real time I actually paid with crypto was when I booked my flight tickets on Trip.com. They recently added an option to pay with stablecoins, so you pay straight from your wallet, and of course, it’s accessible to every single person in the world.

Here, it is a real crypto use case and a real crypto payment. I believe that the endgame will look exactly like this: wallets will improve UX specifically for spending and payments, or, less likely, they will become crypto cards (if crypto payments are adopted in some way or another).

Crypto cards function similar to a liquidity bridge (Rain)

Another interesting observation that I’ve made is that self-custodial crypto cards function similarly to cross-chain bridges.

• This applies only to self-custodial cards: CEX cards are not self-custodial, so Coinbase and other exchanges have no obligation to make people delusional by saying that their funds are under users’ control.

• One good use case of CEXes, and CEX cards in particular, is that they serve as a good source of proof of funds for governments, visa applications, or similar activities. When you use a crypto card attached to your CEX balance, you’re technically in the same ecosystem.

With self-custodial crypto cards, it’s different: they function similarly to liquidity bridges, where you lock funds (crypto) on Chain A (crypto balance) and unlock them (fiat) on Chain B (real world).

This bridge in the crypto card landscape is what shovels used to be in the California Gold Rush: the precious safe spot connecting crypto-native users and businesses who want to issue their own card.

@stablewatchHQ did a really good job highlighting this kind of bridge as essentially a Card-as-a-Service (CaaS) model. This is the most overlooked aspect by everyone talking about crypto cards. These CaaS platforms provide the infrastructure to launch their own branded card.

Rain: How crypto cards are made

Probably half of your favorite crypto cards are powered by @raincards, and you probably haven’t heard of them. This is one of the most foundational protocols in neobank systems because they carry basically every piece behind your crypto cards. What companies are left to do is just slap their logo on top of it (that’s harsh, but that’s close to how things really are).

Rain allows companies to launch their crypto cards, and honestly, Rain is infrastructure that can last even outside crypto with its execution. So yep, don’t be delusional and believe that teams need to raise tens of millions of dollars to launch their crypto card. They don’t need that — they need Rain.

The reason I’m talking about Rain so much is that people overestimate the effort needed to launch a crypto card. Maybe I will write a separate article on Rain in the future, because this is a really underrated piece of technology.

Crypto cards don’t have any privacy and anonymity

Crypto cards not having privacy or anonymity is not a problem of crypto cards, it’s a problem ignored by people pushing crypto cards forward while hiding behind so-called “crypto values”.

• Privacy doesn’t exist in crypto as a widely used feature. Pseudoprivacy (pseudo-anonymity) does exist because we don’t see names, just addresses.

• However, if you’re ZachXBT, Igor Igamberdiev from Wintermute, Storm from Paradigm, or any other person with strong on-chain skills, you can significantly narrow down which address belongs to whom.

Of course, the situation with crypto cards doesn’t offer any near pseudoprivacy like traditional crypto does, because you do KYC when you open a crypto card (because you don’t really open a crypto card, you open a bank account).

• If you’re based in the EU, your crypto card provider still sends some of your data to the government for tax purposes or any other purposes the government would like to know.

• Now, you give authorities one more opportunity to track you: linking your crypto address to the real person.

Personal data as a currency of the future

Cash is still here (the only form of anonymity, except that the seller sees you), and it will still be around for a long time. But eventually, everything will be converted into digital. Current digital systems don’t benefit the privacy of spenders in any way: you spend more, you pay more fees, and in return, they know even more about you. Good trade!

Privacy is a luxury, and it will continue to be so in the crypto card landscape. An interesting thought is that if we achieve really good privacy to an extent that companies and entities are willing to pay for it (not the Facebook way, but with our own consent), it might become one of the currencies of the future, if not the only one, in a no-job, AI-driven world.

If it’s all doomed, why are Tempo, Arc Plasma, Stable being built?

The answer is pretty simple — locking users into ecosystems.

Most of the non-custodial cards choose L2s (MetaMask on @LineaBuild) or separate L1s (Plasma Card on @Plasma). Ethereum or Bitcoin is usually impractical for such operations because of high costs and finality. There are some cards that use Solana, but I’m not here to start another war, it’s still a minority.

Of course, companies choose different blockchains not only because of their infrastructure but also because of monetary benefits.

• MetaMask is using Linea rails not because Linea is the fastest or most secure, but because both Linea and MetaMask are parts of the broader ConsenSys system.

• I’m using MetaMask as an example here specifically because of their usage of Linea. As most of you know, almost no one uses Linea, and it’s nowhere near the competition among different L2s like Base or Arbitrum.

But ConsenSys made a smart decision by having Linea underneath their card, because users get locked into the ecosystem. They get used to good UX not via something they use every day. Linea attracts liquidity, volume, and all other metrics in a natural way, not because of liquidity mining campaigns or begging users to bridge.

This approach is similar to what Apple did when the iPhone arrived in 2007, so people stay on iOS and get used to it to an extent that they can’t go to another ecosystem anymore. You should never underestimate the power of habit.

EtherFi is the only viable crypto card

After all these thoughts, I came to the conclusion that @ether_fi is probably the only viable real crypto card that aligns most with the crypto ethos (this research is not sponsored by EtherFi, but even if it were, I wouldn’t mind).

In most crypto cards, they sell the crypto that you deposit and top up your balance with cash (similar to a liquidity bridge that I described before).

It’s different in EtherFi: the system never sells your crypto; they give you cash as a loan and use your crypto to yield rewards.

EtherFi functions similarly to Aave with this model. While most DeFi users are dreaming of the ability to take a cash loan against their crypto assets seamlessly, it’s already here. You might wonder: “But isn’t it the same thing? I can top up crypto and use a crypto card as a normal debit card; this one extra step isn’t needed”.

Well, the problem is: selling your crypto is a taxable event, sometimes even more taxable than daily purchases. And with most cards, each of your operations is taxed, so you have to pay more to the government (again, using a crypto card doesn’t mean going bankless).

• EtherFi kind of fixes this because you don’t really sell your crypto; you just get a loan against it.

• Just because of this reason alone (on top of no FX fees in USD, cashback, and different perks), it makes EtherFi the best example of the DeFi × TradFi intersection.

While most cards try to pretend that they’re crypto while being literally a liquidity bridge, EtherFi is literally aimed at crypto users first rather than focused on bringing crypto to the masses: they bring crypto to locals and make locals spend in front of the masses until they realize how cool that is. Out of all crypto cards, EtherFi is possibly the only one that will survive over the years.

I like to think of crypto cards as a field for experimentation, but unfortunately, most of the teams you see just capitalize on the narrative without giving proper credit to the underlying systems and the people who work on these cards.

Let's see where progress and innovation will lead us. Currently, we see a lot of globalization (horizontal growth) of crypto cards, but we don't see enough vertical growth, which is needed in the early days of a technology like crypto cards designed for spending.

This article is part of the Institutional Crypto Series. You can read the second installment by following this link: Institutional Crypto Series (II): The Next Evolution of Real-World Asset (RWA) Markets.

Thanks to RWA.xyz for providing comprehensive data and analytics that made this market analysis possible. Their platform continues to be an invaluable resource for tracking the evolution of tokenized real-world assets.

Six of Wall Street’s largest institutions have moved onto the blockchain. BlackRock, Franklin Templeton, WisdomTree, Fidelity, Hamilton Lane, and UBS now operate tokenized funds worth $4.37 billion combined, representing 13% of the entire $33.71 billion real-world asset (RWA) tokenization market.

When firms managing trillions deploy resources to build blockchain infrastructure, they’re committing to a fundamental shift in how institutional capital moves.

What is Asset Manager Tokenization?

Traditional asset managers are putting regulated investment funds on the blockchain. You get a token representing your share of a fund that could hold U.S. Treasuries, corporate bonds, equities, or private credit, depending on the product.

The difference from traditional funds is instant transfers, 24/7 access, and the ability to use your investment as collateral in other applications while still earning yield.

BlackRock BUIDL: The Market Leader in Tokenized Treasuries

BlackRock, the world’s largest asset manager with more than $13.5 trillion under management, entered onchain finance in March 2024 with a new product: the BlackRock USD Institutional Digital Liquidity Fund (BUIDL).

BUIDL is BlackRock’s first tokenized fund issued on a public blockchain, launched in partnership with Securitize, a tokenization platform and SEC-registered transfer agent that handles the technical infrastructure and regulatory compliance for blockchain-based securities.

Investors can subscribe through Securitize Markets to access this fund, which invests 100% of its assets in cash, U.S. Treasury bills, and repurchase agreements.

BlackRock’s Tokenized Fund

• Fund name: BlackRock USD Institutional Digital Liquidity Fund (BUIDL)

• Launch date: March 20, 2024

• AUM: $2.52 billion (–11.44% over the past 30 days)

• Asset Class: U.S. Treasuries

• Holders: 97 (institutions only; all wallets are whitelisted)

• Yield: 3.77% APY(7D), distributed as onchain monthly dividends

• Minimum investment: $5,000,000

• Platform: Securitize (SEC-registered transfer agent & broker-dealer)

• Custodian: Bank of New York Mellon

BUIDL holds mostly short-duration U.S. Treasuries and repos. It remains stable at $1 and pays out a yield automatically. Because it is a regulated security, only verified institutional investors can buy or transfer it.

Multi-Chain Presence (8 Blockchains)

BlackRock’s BUIDL launched exclusively on Ethereum in March 2024, maintaining single-chain operations for the first seven months. In late October 2024, BlackRock initiated a multi-chain deployment, expanding to Avalanche, Polygon, Arbitrum, and Optimism.

The distribution remained heavily Ethereum-concentrated through mid-2025. By July 1, 2025, while the fund had grown to $2.86 billion, Ethereum still commanded 93.06% ($2.66 billion) of total assets, with other chains holding minimal shares: Avalanche at 1.88%, Aptos at 1.67%, and remaining chains below 1.1% each.

A dramatic rebalancing occurred between July and November 2025. By November 15, 2025, BUIDL’s $2.52 billion was distributed nearly equally across four major chains:

• Ethereum: 23.12% ($583.6M)

• Avalanche: 21.91% ($553M)

• Aptos: 21.58% ($544.7M)

• Polygon: 21.02% ($530.6M)

This shift marks a move from heavy Ethereum concentration to a more balanced multi-chain spread, with the top four networks now holding nearly equal allocations. Securitize clarified that “chain selection and allocation decisions are entirely determined by investors,” which means the drop on Ethereum wasn’t a pullback by BlackRock; investors simply redistributed their holdings toward Avalanche, Aptos, and Polygon.

BUIDL Holder Distribution

BlackRock’s BUIDL fund has 97 total holders as of November 2025, with a highly concentrated ownership structure. The top five holders control approximately $2 billion of the fund’s $2.5 billion in total assets:

• Holder 1 (Aptos): $501.4M

• Holder 2 (Polygon): $501.2M

• Holder 3 (Avalanche): $501.2M

• Holder 4 (Ethereum): $262.8M

• Holder 5 (Solana): $229.1M

The top three holders each hold nearly identical amounts (~$501M), suggesting coordinated institutional deployments or strategic rebalancing across the chain:

Key Developments

1. Binance Now Accepts BUIDL as Collateral

Binance, the world’s largest crypto exchange, now allows institutions to use BUIDL as trading collateral. This matters because:

Traders can earn yield (~4%) on their posted collateral. Exchanges treat BUIDL as high-quality collateral, often safer than stablecoins. BlackRock is issuing a BNB-Chain share class to support this integration. This follows similar moves by Deribit and Coinbase-owned derivative platforms.

2. Onchain Operations

Yield is paid directly on-chain every month. Current redemption: token → redemption wallet → wire transfer. Future plan: on-chain redemption into USDC, already tested at 1:1. Long-term goal: fully on-chain funding and settlement without banks.

3. Regulatory Structure

BUIDL is a Reg D security. Only KYC’d, whitelisted institutional wallets can hold it. Peer-to-peer transfers are allowed only between approved wallets.

Fidelity FDIT: The New Challenger in Tokenized Treasuries

Fidelity Investments is a Boston-based financial services company established in 1946, with $5.9 trillion in assets under management. The firm began exploring blockchain technology in 2014 by mining bitcoin and launched Fidelity Digital Assets in 2018 for institutional crypto services.

The firm began exploring blockchain technology in 2014 by mining bitcoin and launched Fidelity Digital Assets in 2018 for institutional crypto services.This was a “tipping point” for institutional blockchain adoption, with Fidelity now competing directly with BlackRock’s BUIDL in the tokenized Treasury market.

Fidelity’s Tokenized Fund

• Fund name: Fidelity Digital Interest Token (FDIT)

• Launch date: August 4, 2025

• AUM: $235.4 million (early-stage growth of +5.81% over the past 30 days)

• Asset Class: U.S. Treasuries

• Holders: 3 (institutional investors only)

• Platform: Fidelity Investments

• Custodian: Bank of New York Mellon Corporation

FDIT represents one share of the Fidelity Treasury Digital Fund (FYOXX), investing at least 99.5% of assets in cash and U.S. Treasury securities. The fund maintains a stable $1 NAV and charges a 0.20% management fee (with a 0.05% waiver effective through August 31, 2027).

Single-Chain Presence (Ethereum Only)

As a newly launched product, FDIT operates exclusively on Ethereum as an ERC-20 token. Unlike BlackRock’s established multi-chain infrastructure, Fidelity has taken a focused approach, deploying all tokens on a single blockchain at this early stage.

FDIT Holder Distribution

Given its recent launch just three months ago, FDIT has 3 holders with highly concentrated ownership:

• Holder 1: $233.4M (99.15% of total) - Ondo Finance, serving as the anchor investor

• Holder 2: $1.0M (0.43%)

• Holder 3: $1.0M (0.42%)

Ondo Finance’s dominant position reflects its role as the initial anchor investor, using FDIT as a reserve asset for its OUSG yield-generating token. The limited holder count is typical for newly launched institutional tokenized products.

Key Developments

1. Strategic Launch with Ondo Finance: Fidelity partnered with Ondo Finance as its anchor investor at launch, providing immediate liquidity. Ondo’s OUSG token, which has grown to over $730 million in total value locked, now uses FDIT as part of its diversified reserve assets alongside BlackRock’s BUIDL, Franklin Templeton’s BENJI, WisdomTree’s WTGXX, and Wellington Management’s ULTRA. This positions FDIT within a broader ecosystem of institutional tokenized products.

2. Regulatory Framework: FDIT is registered under the U.S. Securities Act Form N-1A for Mutual Funds and regulated by the SEC, establishing a compliant foundation for future growth.

Recent Trend (Since Launch)

• Growth: +$13.3M in 30 days (+5.81%) - showing steady early adoption

• Holders: Growing from 2 to 3 institutional participants (+50% expansion in holder base)

As a three-month-old product competing against BlackRock’s 20-month head start and $2.5B AUM, FDIT represents Fidelity’s fresh entry into the tokenized treasury space, with significant room for expansion as more institutions discover and adopt the product.

Franklin Templeton BENJI: Tokenized Treasury Overview

Franklin Templeton is a global investment management firm with $1.65 trillion in assets under management, operating in over 150 countries with more than 75 years of investment experience

Franklin Templeton launched BENJI in 2021 as the first U.S. registered mutual fund to use blockchain for processing transactions and recording share ownership, representing shares of the Franklin OnChain U.S. Government Money Fund (FOBXX).

Franklin Templeton’s Tokenized Fund

• Fund name: Franklin OnChain U.S. Government Money Fund (BENJI)

• Launch date: 2021

• AUM: $794.68 million (+0.02% over the past 30 days)

• Asset Class: U.S. Treasuries

• Holders: 940 (+0.97% over the past 30 days)

• Yield: 3.87% APY (30D)

• Platform: Franklin Templeton Benji Investments

• Eligible Investors: U.S. and Global Retail

BENJI is one of the only tokenized MMFs available to both retail and institutional investors, depending on jurisdiction.

Multi-Chain Expansion

Franklin Templeton’s BENJI started as a Stellar-only product and gradually began expanding. By late December, BENJI had moved onto two chains with $325.51 million in assets, though it remained overwhelmingly concentrated on Stellar at 99.3% (with only $161 on Arbitrum and $2.06M on Polygon).

By late December 2024, BENJI had reached seven chains with $555.0 million in assets. Stellar’s dominance had reduced to 53.29% ($293.8M) as other ecosystems gained traction:

By November 16, 2025, BENJI had grown to $849.7 million across 10 chains, showing a significant reconcentration toward Stellar.

Holder Concentration

Unlike BUIDL and FDIT, BENJI has broad distribution:

• 940+ holders (mixed retail + institutional)

• No single dominant holder shown in available data

• Used across multiple jurisdictions and financial apps

BENJI is the most accessible of the major tokenized MMFs.

Key Developments

1. Early Pioneer in Tokenization (Since 2021)

BENJI launched in 2021 on Stellar, the first U.S.-registered mutual fund on blockchain.

2. Canton Network Integration (Nov 2025)

BENJI expanded to Canton Network, a permissioned blockchain used by institutions handling multi-trillion-dollar markets (e.g., Broadridge $4T+ monthly repos). This enables:

• Privacy-preserving settlements

• Collateral management

• Regulated institutional workflows

3. Broad Institutional + Enterprise Adoption: Used for:

Broad Institutional & Enterprise Adoption: Use Cases

• Collateral in CeDeFi (BounceBit)

• Treasury management

• Multi-chain payments (VeChain)

• Institutional settlement flows (Canton)

• DeFi integrations (Arbitrum, Ethereum, Base)

WisdomTree: The Diversified Leader in Tokenized Assets

WisdomTree is a global asset manager and financial innovator listed on the NYSE (ticker: WT) with over 20 years of experience building and managing regulated investment products. The company has been recognized on Fortune’s list of America’s Most Innovative Companies 2025 for its leadership in offering tokenized real world assets (RWA) to both retail and institutional investors.

WisdomTree pioneered tokenized assets in October 2022 with the launch of WTGOLD (WisdomTree Gold Token), making it one of the earliest major asset managers to embrace blockchain technology. The company has systematically expanded its offerings, growing from $664,504 in October 2022 to $728.84 million by November 2025 - a remarkable 1,096x growth over three years.

WisdomTree’s Tokenized Platform

• Platform name: WisdomTree Connect (institutional) & WisdomTree Prime (retail)

• Pioneer launch: October 2, 2022 (WTGOLD)

• Total AUM: $728.84 million (+16.31% over the past 30 days)

• Number of Assets: 15 tokenized products (largest collection in the market)

• Asset Classes: Money Market, Equities, Fixed Income, Commodities, Private Credit

• Holders: 2,050 (retail and institutional)

• Eligible Investors: Both U.S./Global retail and institutional investors

• Platform: WisdomTree (SEC-registered funds under Investment Company Act of 1940)

Multi-Chain Presence

WisdomTree deployed its tokenized funds across six blockchains as of November 2025:

• Ethereum: 92.50% ($674.2M)

• Stellar: 4.61% ($33.6M)

• Arbitrum: 1.50% ($10.9M)

• Plume: 1.39% ($10.1M)

• Base: 0.00% ($28.6)

• Avalanche: 0.00% ($25.1)

Complete Fund Lineup with Launch Timeline

WisdomTree launched its tokenization platform in October 2022 with WTGOLD and a short-term treasury fund, starting with just $1.66 million. The company systematically expanded through five phases: adding five treasury funds in January 2023 ($6.72M), launching the breakthrough WTGXX money market fund in November 2023 (now $694.79M flagship), diversifying into six equity and multi-asset funds in 2024 ($29.37M), and introducing private credit in 2025.

Growth Trajectory

• October 2022: $664,504 (WTGOLD + WTSYX only)

• December 2022: $1.66M (+150%)

• January 2023: $6.72M (+304% - Major treasury expansion)

• November 2023: $7.66M (+14% - WTGXX launch)

• December 2024: $29.37M (+283% - Equity funds added)

• September 2025: $864.82M (+2,844% - WTGXX dominance)

• November 2025: $728.84M (-16% from Sep peak, but +16.31% from Oct)

Key Developments

1. Retail-Focused Innovation WisdomTree Prime Visa Debit Card allows users to spend directly from tokenized funds, earning yield on daily purchases. WisdomTree Prime is available in 45 U.S. states.

2. Stablecoin Integration Full USDC support for subscriptions and redemptions. WisdomTree launched USDW, its proprietary stablecoin, as the transactional layer for seamless value movement.

3. Multi-Asset Portfolio Building Institutions can build complete diversified portfolios on-chain across 15 different strategies without leaving the ecosystem.

4. Regulatory Structure All funds registered under the Investment Company Act of 1940. Uses soulbound NFTs for wallet verification. Only verified, permissioned wallets can transact.

As the pioneer that launched 17 months before BlackRock’s BUIDL (October 2022 vs March 2024), WisdomTree has established itself as the most diversified tokenized asset platform, offering retail accessibility alongside institutional solutions across 15 different investment strategies spanning 3+ years of continuous innovation.

UBS Asset Management

On November 1, 2024, UBS Asset Management launched its first tokenized investment fund, the “UBS USD Money Market Investment Fund Token” (uMINT), built on Ethereum blockchain technology. The fund provides institutional-grade cash management solutions backed by high-quality money market instruments, available through authorized distribution partners.

Thomas Kaegi, Co-Head of UBS Asset Management APAC, noted growing investor appetite for tokenized financial assets, prompting UBS to leverage its global capabilities and collaborate with regulators to deliver innovative solutions.

Hamilton Lane

In Q4 2022, Hamilton Lane partnered with Securitize to tokenize its funds, marking the first time Hamilton Lane products became available in tokenized form in the U.S., dramatically reducing minimum investments from typical $5 million requirements to $20,000.Hamilton Lane has been active in private markets for over 24 years and its data shows private equity funds have outperformed public markets in 19 of the last 20 years.

Hamilton Lane Tokenized Funds on Polygon (via Securitize)

• HLEOV (Equity Opportunities Fund V) — closed Jan 2023 at ~$2.1B.

• HLSCOPE (Senior Credit Opportunities Fund) — launched May 2023, evergreen private credit.

• HLSF6 (Secondary Fund VI) — launched Aug 2024 with ~$5.6B in commitments.

• HLSPCA (SCOPE Private Credit Access) — launched via Libre SAF VCC structure.

Hamilton Lane also joined Securitize’s $47M strategic funding round led by BlackRock in 2024.

Conclusion

The tokenized asset management market has rapidly matured into a $4.37 billion industry in ~2 years, led by established financial giants who are fundamentally reshaping how institutional capital moves.

BlackRock’s $2.52 billion BUIDL dominates the tokenized Treasury space, while Franklin Templeton’s $849.7 million BENJI pioneered retail accessibility since 2021. WisdomTree leads in diversification with 15 tokenized products across $728.8 million, Fidelity’s $235.4 million FDIT represents the newest major entrant, and Hamilton Lane has democratized private equity access with $29.5 million in tokenized funds.

These platforms have collectively reduced minimum investments from millions to thousands of dollars, enabled 24/7 trading with instant settlement, and introduced innovative use cases like using yield-bearing assets as collateral or spending directly from tokenized funds via debit cards. As UBS and other trillion-dollar managers enter the space, tokenization is transitioning from experimental technology to core financial infrastructure, proving that blockchain-based assets are not just an alternative, but increasingly the standard for how modern finance operates.

This article is part of the Institutional Crypto Series. You can read the first installment by following this link: Institutional Crypto Series (I): Verifiability of Actions.

Tokenized real-world assets (RWAs) have become a buzz phrase on Wall Street and in crypto circles alike.Despite headlines touting billions in “tokenized assets,” actual on-chain RWA volumes remain modest, around $17 billion excluding stablecoins(~$300 b), these numbers may seem low and there was a debate upon static/unused RWA capital deployed which shows a greater number of ~$36 billion. Even flagship categories like tokenized U.S. Treasuries amount to just a few billion in assets under management, versus roughly a $20 trillion traditional Treasury market.

These statistics are not an argument against the promise of tokenization but rather they highlight how early the industry is at the moment.

Most current institutional RWA products focus on narrow, familiar securities (high-grade bonds, funds, money market equivalents), which is just a tiny slice of the hundreds of trillions of value sitting in real-world assets. All the major asset managers forecast $2-16 trillion of tokenized RWA by 2028.

Current Limitation of RWA on blockchains

To date, most tokenization efforts have focused on straightforward financial products because they have clear legal structures and existing markets. But these familiar assets are only a small percentage of global wealth. The real world is very big, the true opportunity lies in all kinds of tangible and complex assets. For example:

• Real Estate: Commercial, residential, and agricultural properties.

• Infrastructure: Toll roads, bridges, airports, power plants, etc.

• Commodities & Natural Resources: Crops, oil & gas, minerals, timber .

• Equipment & Inventory: Industrial machinery, vehicles, shipping containers .

• Intellectual Property & Contracts: Patents, music or film royalties, long-term service agreements.

• Collectibles & Luxury Goods: Fine art, classic cars, wine collections.

• Environmental Assets: Carbon credits, water rights, renewable-energy certificates.

Each of these categories contains trillions in latent value and most remain illiquid, opaque, and unpriced in real time. The fundamental reason is that they cannot yet be denominated in continuous, machine-verifiable data.

Unlike financial securities whose entire lifecycle is digital(and can be put on Blockchain using oracles like Chainlink) these assets operate in the physical world, where data about their state (output, utilization, location, condition) is either unrecorded or trapped in siloed systems. Without reliable streams of structured telemetry, a blockchain cannot evaluate or enforce the underlying economic claims of such assets. Simply put, what cannot be measured cannot be tokenized.

This is precisely where IoT oracles enter the premise.

Oracles 2.0

RWA depend on physical facts, and blockchains alone can’t enforce contracts without reliable off-chain data. Traditional finance relies on legal and custodial intermediaries (auditors, inspectors, custodians) to verify things like rent payments, production milestones, or collateral status.

On-chain RWAs have to replace those assurances with code which means they must have a trusted bridge to the real world.

By embedding sensors, meters, and smart devices directly into the physical environment, IoT oracles will convert real-world activity into authenticated, real-time data streams that blockchains can trust.

IoT oracles will stream virtually anything measurable: operating hours, crop moisture, GPS location, or energy yield which can be transmitted, hashed, and verified on-chain enabling smart contracts to trigger payments, insurance settlements, or ownership transfers automatically.

By continuously feeding verified metrics into code, they transform static assets into programmable digital tokens assets that evolve, accrue value, or settle obligations as real-world conditions change.

In short, any asset that can be continuously monitored can enter the on-chain world and once it does, markets can begin to price and trade its performance directly, forming the foundation of the next wave of financial innovation.

Creating New Markets from Real-World Data

One of the most powerful implications of IoT oracles is that any measurable event can become a tradable data point. By publishing real-world data to the blockchain, entirely new markets can emerge.

For example, consider healthcare: if hospital bed availability, equipment usage, and procedure pricing were fed live into on-chain oracles, parties could arbitrage cost differences across regions, book underutilized resources in real time, or create insurance pools around utilization metrics.

In agriculture, IoT-verified crop yields or weather data could underpin new futures or insurance contracts.

In manufacturing and logistics, machine uptime or shipping-container location could be tokenized into revenue-linked securities.

And in energy, continuous telemetry from solar farms or grids could drive dynamic power-trading markets.

In each case, a physical event that was once hidden or siloed becomes a financial primitive.

Composable Finance

Once assets are tokenized and verifiable on-chain, they become building blocks for entirely new financial products. Smart contracts don’t care whether a token represents Bitcoin or a barrel of oil, they can combine diverse assets in complex structures. Imagine a permissionless environment where anyone can:

• Collateralize tokenized GPU compute leases to hedge against surging AI training costs.

• Long or short IoT-linked weather derivatives, for example betting on rainfall levels that drive crop insurance.

• Trade BTC (or stablecoins) for tokenized pension-fund cash flows or other income streams as one package.

These kinds of cross-asset products are difficult in legacy finance due to siloed data and varying regulations, but on-chain protocols make them straightforward. IoT oracles provide the connective tissue needed: by verifying each asset’s performance in real time, they let these diverse RWA tokens interact under institutional-grade conditions.

The emergence of decentralized sensor networks often referred to as DePINs (Decentralized Physical Infrastructure Networks) is already laying the groundwork for IoT-oracle-driven markets. Projects like IoTeX, Helium, Chirp, WeatherXM, Geodnet, and DIMO demonstrate how physical data collection itself can be decentralized, verified, and rewarded on-chain. Each network specializes in a different sensing vertical connectivity, mobility, environmental data, or geolocation but all share a common architecture: individuals deploy sensors or gateways, stream authenticated data to the network, and earn tokens for contributing to the shared data layer.

In effect, these systems turn the world into a living oracle one where location pings, temperature readings, and energy outputs flow directly into digital markets. As these networks mature, they will provide the infrastructure for AI and autonomous agents which will be more than 99% of internet traffic in future to consume trustless, real-time data from the physical world and transact on-chain without human mediation which will be the true foundation of the coming machine economy.

The Future

The ultimate evolution of tokenization will merge physical assets, IoT devices, and programmable contracts into a single real-time economy where every measurable activity becomes a financial signal, some examples below:-

Pay-Per-Use and the Machine Economy

Instead of purchasing machines outright, enterprises will lease them through blockchain contracts that meter usage directly via IoT sensors.

A CNC machine or solar inverter could stream data to a smart contract that calculates operating hours and automatically settles payments in stablecoins. The vendor retains ownership; the user pays only for what they consume.

Electricity, Bandwidth, and the Rise of Intangible DePINs

Among all sectors, the electricity industry is the most advanced and utilizing this system. Power is an intangible asset which is already digitized and measured via smart meters. IoT oracles can feed this data into blockchain systems to enable micro-settlement, demand-response auctions, or decentralized energy trading.

Similar logic underpins networks like Helium, where bandwidth, another intangible, becomes a tokenized resource. Yet, derivatives such as electricity futures or power-price hedging remain largely off-chain. As data reliability improves, these high-value derivative markets will migrate on-chain, creating transparent, composable hedging and yield instruments.

Tokenized Service Contracts and Automated Enforcement

Beyond goods and energy, services themselves can be tokenized. Construction projects, cloud-compute leases, or data-center GPU rentals can be represented by tokens whose cash flows depend on IoT-verified milestones. Smart contracts could disburse funds progressively as oracles confirm task completion. Enforcement shifts from human to algorithmic: non-payment can trigger automated collateral seizure or disable IoT-linked equipment, much like remote-kill switches in vehicles today but executed transparently on-chain.

Auditing and compliance, too, become autonomous: every data feed leaves an immutable trail, enabling real-time ESG or regulatory proofs without manual paperwork.

Conclusion: From Passive to Programmable Assets

Tokenizing real-world assets is only the first step. To truly unlock their value, those digital tokens must be programmable and responsive to the actual world. IoT-powered oracle infrastructure is the bridge that makes on-chain assets come alive. By continuously supplying trusted, real-time data, oracles anchor digital tokens in reality, enabling automated payouts, dynamic pricing, embedded compliance, and cross-asset DeFi.

For institutions, the takeaway is clear: platforms that build rock-solid IoT oracle layers will have the advantage, because those infrastructures will determine whether we can truly tap into trillions of dollars of real-world value through code.

The real world is full of value, but it only becomes liquid when it’s visible and verifiable and IoT oracles can make that leap. The next evolution of global finance will depend on assets becoming truly programmable and interoperable, with real-world data at their core. Without this foundation, the promise of on-chain RWAs will remain out of reach.

The institutional interest in crypto is the highest it has ever been: institutions want to get involved either by investing in digital tokens, transitioning part of their infrastructure onto blockchain rails, or discovering new use cases enabled by crypto. However, it’s tough out there: both for crypto-native users navigating the institutional landscape and for institutions trying to understand what’s worth their time.

In a new multi-part series called “Institutional Crypto,” we will describe what’s important for institutions in this space and what’s not, what different types of TradFi firms are looking for in the blockchain industry, why it’s happening now, and how to navigate this landscape.

Our global goal is simple: we want to eliminate the cumbersome complexity of blockchain faced by nearly everyone inside and outside this space. Now, we want to fix it for institutions and anyone interested in the institutional crypto landscape.

In Part I (the one you’re reading right now), we will cover the institutional space from the perspective of interactions between components, systems, and people overall: and why institutions might consider moving their infrastructure (at least parts of it) on-chain.

Why are we beginning this series with verifiability?

We believe that verifiability is the most important and the most scalable feature of the blockchain industry, one that can be applied to a variety of different products outside the crypto space. People want to know the truth without having to trust anyone (media and information, in general); scientists want to make sure their hypotheses are definitively proved or non-provable; and computer systems want to ensure their algorithms work exactly as they’re supposed to.

Every part of this applies to institutions, as they are probably some of the most complex structures in the modern world: thousands of infrastructure systems, millions of people involved, and billions of outcomes and actions happening every day.

Are we saying that current institutions’ systems are not functioning properly? Yes.

What do institutions miss and lack?

Large institutions suffer from frequent errors, delays, and poorly coordinated processes. It doesn’t matter how much money an organization has or how much it has raised: it lies in the nature of institutions: they are large systems with a lot of hierarchy and approval processes. When you have that level of complexity, everything not only moves slowly (wasting time) but also leads to fraud within the organization and an inability to capture upcoming opportunities (wasting money), and most people also operate inefficiently, waiting for approvals for weeks or even months (wasting resources).

Operations Inefficiency

TradFi infrastructure is full of friction: in capital markets, it can take six weeks to issue a bond and almost a month for a dividend payment to reach investors. Settlement systems are aging and slow: about 27% of settlement technology is over 20 years old. These delays tie up capital and increase costs (settlement costs in capital markets grow by ~14% each year).

Payment networks and banks also have large back offices with too much manual reconciliation. Small errors in payment processing can compound quickly: companies end up spending up to 20% of a transaction’s value just on recovering from failed payments and reconciliation issues. Institutions can lose up to 20–30% of their revenue to operational waste each year.

Trust as Fundamental Assumption

When processes become too complicated, involving thousands of interactions, hundreds of people, and dozens of systems, it naturally becomes difficult for stakeholders to ensure that outcomes are correct or at least minimally deviate from the true value.

A major historical case was the collapse of a company called Enron, which involved widespread accounting fraud that led to the energy company’s bankruptcy, as complex off-book entities hid massive debts. Investors lost their money, and thousands of employees lost their jobs as well as a portion of their retirement savings.

The most important conclusion we can draw from this story is that complex systems with no oversight can allow fraud to grow undetected. Disorganized record-keeping lowers stakeholder trust: funds or clients have to assume the institution is handling things correctly, but they cannot easily verify it. This is true in other sectors too: supply chain firms struggle to verify product origins, and governments struggle to show taxpayers exactly where their funds go. In all of these processes, the lack of verifiability leads to errors and misconduct.

Legacy

Institutions carry a lot of legacy. They deal with outdated core systems that may cause transaction errors → fintechs and payment processors grapple with fraud and data mismatches across partners → supply chains see goods “disappearing” due to siloed databases.

In each case, the institution lacks a single source of truth that all parties can observe. The result is often finger-pointing and slow manual fixes. For instance, 68% of companies say their finance teams waste a lot of time on payment operations, and over half of payment processes still involve manual steps, which naturally leads to high error rates and delays.

Our thesis is that current institutional systems lack a guarantee that everything is running correctly. Different types of institutions experience this pain in different ways:

How exactly can current systems be fixed and improved?

Actions can be verifiable and auditable by design. If key processes are moved on-chain, institutions gain an unchangeable record of all events which is shared across participants. Below we explain how adding crypto-style verifiability can improve current systems.

Immutability and Audit Trails

An immutable audit trail is created when every change is directly linked to the previous change, if we translate it to crypto terms, “when a hash is linked to the hash of the prior state.” Systems can trace every step of a transaction’s history, mistakes can’t be covered up, and fraud entries can’t be covered up. Undeniable proof is here: digital signatures prove who executed a transaction. Of course, any system has some pitfalls, but this is far better than relying on trust to improve accountability inside large organizations.

Verification can also be automated. Smart contracts can enforce business rules and automatically check conditions. A smart contract could be used in supply chain finance to automatically release payment once a shipment is delivered and IoT sensors report the arrival, where payments will only execute if all verifiable conditions are met. Systems essentially trust code to handle the workflow, which is far better than trusting paper trails or manual checks.

Transparency Inside Organizations

Institutions can prove to others that they are acting correctly without revealing sensitive data (privacy-preserving protocols and zkTLS-style of verification).

For example, a blockchain-based audit trail in public finance can let citizens and oversight bodies track every dollar from budget to outcome. In corporate culture, a company could offer partners access to some kind of permissioned ledger showing product provenance or inventory levels. Increased transparency means issues like mismatches or fraud become immediately visible to all stakeholders.

Game theory tells us that when defection or cheating is easily detected, actors are far less likely to attempt it. Verifiable actions change incentives: if a bank knows any mismatch in its books will be obvious to regulators (because records are on a shared ledger), they will try as hard as possible to avoid it.

In many institutional processes, multiple middlemen exist to broker trust (clearinghouses, auditors, etc.). Verifiable ledgers can reduce the need for some of these, or make their jobs easier. Real-time auditing becomes possible: instead of waiting for quarterly reports, an auditor could have node access to the company’s blockchain system and observe transactions as they happen (or at least get cryptographic proofs of them). One World Bank pilot, FundsChain, is using blockchain to produce automated financial reports for project funds in real time. This kind of instant oversight means problems are caught and corrected sooner.

If verifiability is so great, why isn’t everything on-chain yet?

Adoption of verifiable principles seems pretty obvious, but there are several reasons why it wasn’t implemented before as well as why institutions are not rushing to implement it right now. There are several challenges, and past obstacles have slowed adoption, including limitations of existing blockchain infrastructure and the unwillingness of managers to adapt to new things.

The most obvious thing that we can point out is transparency. But we mentioned transparency as a good feature in the previous section, didn’t we? Yes, but blockchains usually operate with radical transparency. No major bank or large institution is comfortable moving billions of dollars on a completely public ledger where every transaction detail is visible to competitors or outsiders.

Institutions have legitimate confidentiality requirements (client data, trading positions, etc). Early on-chain solutions seemed “all or nothing”: either you use a fully public chain (transparent but exposing sensitive info) or you stick to private databases. Only recently are hybrid approaches emerging (like zk proofs and privacy networks) that offer privacy with actual verifiability. This verifiability without full public visibility is considered a holy grail for regulated markets, and networks like the Canton Network allow participants to verify data accuracy without revealing all details publicly. The need to balance transparency with privacy has been a key reason institutions held back on blockchain projects.

Moving on-chain is tough when you have a ton of legacy

Unfortunately, implementing crypto-grade verifiability is not a plug-and-play solution for institutions. Many enterprise processes weren’t designed to run on smart contracts or to share data externally in real-time. Rewriting or interfacing these systems with blockchain involves significant engineering effort and new skills that organizations may lack.

Besides that, smart contract platforms have their own limitations, as they mostly require dealing with limited scalability and programming in unfamiliar languages. The “expressiveness of code” on-chain can be lower: complex business logic might need to be simplified to run within blockchain constraints, which naturally limits the ability for institutions to operate efficiently.

Some early blockchain projects (like the Australian Securities Exchange’s attempt to replace its settlement system with DLT) failed or were delayed due to technical complexity.

Early blockchains had issues with throughput and latency. Institutional systems often need to process thousands of transactions per second (think Visa’s payments or stock trades). Traditional blockchains couldn’t meet those demands without compromising security or decentralization. Newer innovations (rollups, L1s focused on speed) are addressing scalability, but for years this was a valid blocker.

The most famous example here is the absence of flexibility of blockspace. Currently, all rollups on Ethereum do around 400 transactions per second (TPS) collectively.

That might mean that the majority of blockspace is free considering most of the rollups are capable of thousands of TPS; however, it’s not true. While there is a lot of blockspace to fill available, it doesn’t suit legacy systems. You can’t call an API, run bot detection algorithms, or do anything complex on-chain. Most of the smart contracts are not designed for that, so alternative solutions are needed that combine on-chain verifiability and the programmability of traditional systems, like EigenCloud.

Large institutions are inherently slow to change. Processes and people gravitate to the status quo. Implementing blockchain verifiability might cut out certain manual roles or require new governance models. Top management might not deeply understand the tech and thus hesitate to greenlight major projects.

Previous Bad Image of Crypto Industry

There’s been a lot of hype in the crypto world, especially during bull runs. Institutions saw buzzwords flying around, but many projects hid their true value propositions under layers of complexity.

Adoption is hampered by “over-promised benefits” and “under-delivered business value.” Many organizations grew wary after proofs of concept failed to show immediate improvements. The crypto bubble and bust cycles also played a role; headlines about scams or collapsed crypto firms (FTX, Terra) further made boards and regulators cautious. So even if verifiability sounded good, decision-makers weren’t ready to overhaul systems without clearer, proven cases; they didn’t want to be beta-testers of overhyped tech.

However, the landscape is changing. Enterprise requirements can be met today: we see interoperability standards, better development tools, and clearer regulations in some jurisdictions. The overhyped expectations have been transformed into practical and achievable pilot projects. Essentially, the industry has done a much-needed “reality check,” and forward-thinking institutions are now making informed, cautious moves rather than being sidelined.

What are the suitables types of verifiability?

When we talk about verifiability, it’s not one-size-fits-all. Depending on an institution’s goals and constraints, different approaches can be used to achieve verifiable systems.

Stage 1. Transparency of Public Ledger

This is the classic blockchain approach (as with Bitcoin/Ethereum) where all transactions are publicly visible. It offers the strongest form of verifiability: anyone can independently audit the entire system’s state. This model is suitable when maximum transparency is desired or acceptable. For example, if a firm wants to prove certain data to the world (say, proving carbon credit issuances or demonstrating fair trade supply chain), publishing those transactions on a public blockchain lets any third party verify authenticity. Some institutions use this in limited ways, such as publishing proof-of-reserves for a crypto custody service on-chain.

Stage 2. Permissioned Blockchains

Here, verifiability is shared among an authorized group rather than the whole public. The ledger is only accessible to participants like the institution and its partners, regulators, and so on. This approach is aimed to balance transparency with confidentiality. All members can verify the data within the network, but the outside world cannot see the data.

Many enterprise blockchain projects adopt this model. For instance, a group of banks might run a shared ledger for interbank settlements: each bank node verifies every transaction, eliminating the need to trust each other’s separate records. The key is that within the group, you get a single-source-of-truth and auditability (It’s worth noting that if the group is small, outsiders must trust that the participants aren’t colluding, so this works best when members have mutual checks or external oversight).

Stage 3. Complete ZK Privacy

ZK (zero-knowledge) proofs let one party prove to another that a certain statement is true (e.g., “This portfolio’s risk metric is under X” or “User meets KYC criteria”) without revealing the data behind it. For institutions, ZKPs and similar proofs can enable selective disclosure. For instance, a bank could prove compliance with regulations or capital requirements by providing a cryptographic proof rather than opening all its books. This way, regulators or partners get mathematical certainty that rules are met, but sensitive details (like individual customer info) stay private.

Another example is proof-of-reserve audits for exchanges: exchanges have used Merkle-tree-based proofs to show users their funds are backed one-to-one by assets, without exposing everyone else’s balance.

It’s already increasingly used in the crypto industry. After the FTX collapse in 2022, many exchanges (Kraken, Binance, and more) implemented proof-of-reserves systems where anyone can verify the exchange’s asset holdings against customer liabilities. Going forward, we expect “verifiable computing” to grow, where even off-chain computations or AI models can produce proofs that they were executed correctly.

In practice, solutions often mix these approaches. A permissioned network might publish periodic zk proofs to regulators, while a public chain might use encryption and zk proofs to hide sensitive data yet allow selective verification. Verifiability lies on a spectrum: from fully transparent ledgers to cryptographically verifiable but opaque ones. Institutions can choose the mix that suits their risk, regulatory, and business needs.

Which institutions implemented verifiability in some way?

Despite the challenges, some institutions have experimented with or implemented different types of verifiability in recent years. We wanted to understand when, why, and how they have done it and how different types of verifiability are applicable for different institutions.

Type 1. Capital Markets (implemented tokenized securities)

Broadridge Financial, Clearstream, and Goldman Sachs have used blockchain-based transaction platforms to eliminate process inefficiencies and increase participants’ trust in markets. These platforms create a shared ledger for trades (such as private stock placements or repo transactions), so all parties can verify the trade details and ownership in real time. Goldman Sachs’ digital asset platform (DAP) has facilitated bond issuances on a blockchain, enabling instant settlement and an auditable record of ownership changes.

JPMorgan’s Onyx network has been settling intraday repo trades on-chain (over $950 billion processed), where the system verifies collateral and ownership instantly, in contrast to the old overnight batch process.

Type 2. Payment Networks (implemented seamless cross-border transfers)

Visa and Mastercard have piloted using stablecoins on public blockchains for settlement between banks. One advantage is that a transaction settled via a stablecoin (e.g., USDC) on Ethereum comes with an open ledger entry; the banks involved can independently verify the payment completed and is final, within minutes, without relying on a SWIFT message confirmation that takes days. This is essentially bringing the verifiability of crypto transactions (which are atomic and transparent) to institutional money movement.

Another example is Ripple’s XRP ledger being used by some remittance providers (American Express, Santander, SBI Holdings): it allows all parties to track a payment’s path in real time, giving senders and receivers cryptographic proof of payment and reducing disputes.

Type 3. Supply Chain and Provenance

Outside of finance, verifiability can also be applied to supply chain tracking. One case is the IBM Food Trust network (with participants like Walmart, Nestlé, etc.), which uses a permissioned blockchain to trace food products from farm to store. Every step (harvest, processing, shipping) is recorded on the ledger. If there’s a recall or question, anyone with access can verify where a particular batch came from and where it went.

Likewise, luxury brands (e.g., LVMH’s Aura consortium) operate on-chain to let customers verify that a handbag or watch is genuine and trace its production journey. The shared ledger ensures data from different companies can be trusted.

Type 4. Public Sector

Government institutions are testing blockchain for transparency. The World Bank’s FundsChain initiative (piloted with certain country partners) is using blockchain to track development project funds. Each disbursement and payment in a project (say, building a school or hospital) is logged on a shared ledger accessible to stakeholders. It tackles corruption and mismanagement by making any “leakage” of funds immediately obvious on the ledger.

Another example is CBDC pilots: projects like those by the European Central Bank or Monetary Authority of Singapore have explored distributed ledger technology for interbank payments. A key motivation is that regulators could gain a verifiable view of all transactions in the system (with privacy protections in place). While most CBDCs are still in the R&D phase, the verifiability aspect is what makes the difference.

Type 5. Enterprise Data & Compliance

Big Four audit firms have been exploring on-chain mechanisms for audit and compliance verifiability. For instance, EY developed a blockchain-based platform for verifying enterprise transactions and even enabling zk proofs for private transaction validation (the EY OpsChain and Nightfall projects).

They have demonstrated how a company’s financial statements could be partially verified by matching against on-chain transactions and providing higher accuracy. Deloitte has also integrated blockchain into some of its audit processes (e.g., confirming the existence of clients’ crypto assets via on-chain verifications rather than paper statements). These efforts show the auditing industry recognizing that real-time verification can replace some laborious sampling and testing. In the future, auditors might check a zk proof for each transaction instead of trusting management records. It’s not widespread yet, but pilot programs suggest that continuous assurance is coming soon.

Each of these examples is early, but they indicate a trend: institutions are slowly starting to adopt verifiability where it adds clear value. They often begin in areas where trust issues or inefficiencies are most glaring, like finance, supply chains, and audits, and run controlled pilots.

When every party sees the same verifiable data, disputes drop and processes accelerate. As Gabe Otte, CEO of Dinari (a firm tokenizing an S&P index), said recently: “Financial systems depend on trusted data and transparent infrastructure… ensuring [an index] operates with integrity and verifiability on-chain.”

Looking Forward

In the first part of our “Institutional series,” we’ve explored the importance of verifiability of the actions of institutions.

As we continue this series, we will dive into other aspects of the Institutions x Crypto intersections, addressing how each part is the core for understanding the future of on-chain capital and the technologies backing it.

Thanks for reading!

Thanks to the zkSecurity team for their paper “Unaligned Incentives: Pricing Attacks Against Blockchain Rollups”, which laid the groundwork for understanding DA mispricing and inspired many of the ideas explored here.

Key Takeaways

• When Ethereum introduced blobs in March 2024 through EIP-4844, it quietly solved one of the biggest problems rollups faced: the cost of putting their data on Ethereum.

• Before blobs, every rollup, Arbitrum, Optimism, Base, Scroll, zkSync, and many others had to post their transaction data as calldata on Ethereum’s main chain. This was expensive. In fact, 90% of a rollup’s costs went just to this data posting step.

• Blobs changed that. Instead of squeezing rollup data into the same expensive space used for smart contracts, Ethereum created a separate lane just for data, cheaper, bigger, and still fully secured by Ethereum’s validators. This lowered costs dramatically and made it viable for rollups to offer cheaper transactions to users.

• Then came Pectra in May 2025, which doubled blob capacity, increasing the target from 3 blobs per block to 6, and raising the maximum to 9.

The introduction of blobs through EIP-4844 didn’t just lower costs for rollups; it created a new fee market inside Ethereum.

The Economics Behind Ethereum’s Data Availability Layer

To understand how this works, it helps to separate the two layers involved when a rollup posts its data: the Consensus Layer and the Execution Layer.

1. Consensus Layer (CL)

Think of this as Ethereum’s data storage layer. When a rollup posts its data, it gets packed into “blobs.” Each blob is a 128 KB chunk of compressed rollup data. These blobs are stored by Ethereum’s consensus nodes for 18 days.

By keeping the data available to everyone, Ethereum makes it possible for anyone to independently verify a rollup’s state.

The cost of using this layer is set by the blob base fee, a special fee introduced by EIP-4844. This fee automatically adjusts depending on how full the blob space is, just like how Ethereum’s base gas fee adjusts based on block usage. When usage rises above the target, the blob base fee goes up; when it’s below, it goes down.

2. Execution Layer (EL)

Posting a blob isn’t done directly. Instead, the rollup sends a type-3 transaction to the Execution Layer. This transaction doesn’t carry the blob data itself, it’s more like a wrapper that references one or more blobs stored in the CL. These transactions are priced just like any normal Ethereum transaction

The key difference

• The Consensus Layer counts how many blobs (data chunks) are being posted.

• The Execution Layer counts how many transactions are sent to post those blobs.

This is why you see a gap between the two: roughly 11.7 million blobs have been posted to the CL so far, but only 4.9 million blob transactions have gone through the EL. On average, each blob transaction carries about 2.4 blobs, because rollups bundle multiple blobs together in one transaction to save gas.

Why Rollup Fee Mechanics are more complex

Once you introduce blobs and split data posting across the Consensus and Execution layers, the economics for rollups change fundamentally.

On Ethereum L1, there’s a single gas price that reflects all the costs involved in executing and storing a transaction. But for rollups, costs are spread across multiple layers and resources, each with its own pricing dynamics. This makes fee design more complicated, and sometimes, exploitable.

Multi-Dimensional Model

For every transaction, a rollup must recover three separate types of costs:

1. L2 Execution Costs – These are the resources spent running the transaction inside the rollup. They cover compute, storage, and bandwidth. For ZK rollups, they also include the cost of generating cryptographic proofs.

2. L1 Data Availability Costs – This is what the rollup pays to post the batch’s compressed transaction data to Ethereum as blobs. It ensures that anyone can later verify the rollup’s state.

3. L1 Settlement and Verification Costs – This is the onchain gas needed to commit batches and, for ZK rollups, to verify validity proofs on Ethereum.

A typical sequencer charges users a transaction fee that covers all three of these cost categories, while leaving some margin to stay profitable.

Most rollups use a first-price auction at the L2 level: users set an L2 gas price, and the sequencer fills the block by including the highest-bidding transactions first. It’s simple, but not always economically efficient.

The total transaction fee is usually calculated with a simple formula:

Total Transaction Fee = L2 Fee + L1 Fee

• L2 Fee = (L2 base fee + priority fee) × L2 gas used

  Pays for off-chain execution, bandwidth, storage, and proof generation (for ZK rollups).

• L1 Fee = (L1 blob base fee × blob scalar × data bytes) + commit cost + proof verification cost.

  Pays for posting data to Ethereum blobs and the transaction’s share of batch commit and verification costs.

L1 DA Fee = L1 blob base fee × blob scalar × data bytes

• L1 blob base fee: Ethereum uses an EIP-1559-style mechanism for blob pricing. Target: 6 blobs per block (post-Pectra).

  • If more than 6 blobs are posted, blob fee increases slightly each block (exponentially, similar to base gas fee).

  • If fewer than 6 blobs are posted, blob fee decreases over time

• Blob scalar: Adjusts blob costs based on how well data compresses, lower if data compresses efficiently, higher if it’s hard to compress (like spam).

• Data bytes: Number of bytes the rollup needs to post for that batch or transaction.

Where Mispricing creeps in

This three-part fee model works in theory, but in practice, the pieces don’t sync up perfectly. Here is a fundamental mismatch.

• L2 blocks are produced every 1-3 seconds, but L1 blob prices update every 12 seconds on Ethereum. Most rollups only refresh their internal blob pricing every 5-64 L1 blocks to avoid using unfinalized data.

• But here’s the deeper issue: Rollup DA pricing is pegged to L1 blob fees, not L2 demand. When L2 gets congested, there’s no immediate price signal because DA costs are set by L1’s external blob market, while L2 blocks happen much faster than L1 can react. L2 gas fees track execution, not data usage.

• This creates a window where attackers can flood the system before economics catch up.

Here is how attackers exploit this:

• They craft transactions that are data-heavy but compute-light. The recipe is simple: execute only the STOP opcode (minimal computation, ~21,000 gas), pack the transaction with 128 KB of random, incompressible calldata, and use about 5.1 million gas to fill one full blob. The total stays under typical L2 block limits of 15M gas.

• Why this works: L2 gas consumption stays low so base fees don’t spike, while L1 blob fees are externally priced and update slowly. Random data with only ~3% zeros compresses poorly, maximizing blob usage. Filling 3 blobs requires only ~15.3M gas—within normal limits and well below what would trigger meaningful fee increases.

There arises 3 possible attack vectors.

Attack 1. DA Saturation: Rollup-Level Denial of Service

Attackers monopolize the rollup’s limited blob capacity, preventing honest transactions from being included in batches posted to Ethereum.

Each rollup batch has a strict DA limit—typically 1-6 blobs depending on configuration. Ethereum targets 6 blobs per block (9 max) after Pectra, but most rollups use only 1-3 blobs per batch to manage costs. Attackers fill this quota faster than honest users by outbidding on priority fees.

Why it’s devastatingly cheap: When blob usage is below Ethereum’s target (common post-Pectra), blob base fees can drop to 1 wei per byte, essentially free. The paper shows periodic DoS costs under 2 ETH for 30 minutes on most rollups. But sustained DoS is even cheaper: 0.87 ETH per hour on Linea, 0.8 ETH/hour on Optimism (throttled), and 2.7 ETH/hour on Base (throttled), indefinitely.

Costs stay low because blob floor pricing makes data nearly free, there’s no L2 feedback loop reflecting DA congestion, and rollups sync blob prices infrequently. Eventually, blob usage exceeding Ethereum’s 6-blob target triggers 1.15× price increases per block, but by then the damage is done.

Real-world impact: Honest users must outbid attackers, which defeats the rollup’s “cheap fees” value proposition. Even short disruptions create opportunities for arbitrage interference, oracle manipulation, and delayed liquidations. For chains securing billions in TVL, this causes massive reputational damage.

Attack 2. Amplified Finality Delay Attack

By flooding the L2 with spam instead of attacking Ethereum directly, attackers can delay when transactions finalize by 1.45×–2.73× longer.

Why this works: Ethereum can handle 9 blobs per block, but most rollups only post 1-3 blobs at a time. When an attacker clogs these few blob slots, they create a massive bottleneck.

Think of it this way: a rollup might produce a new block every 2 seconds, but it can only post to Ethereum every 12 seconds. That’s 6 L2 blocks waiting for each L1 slot. Block one blob, and you’ve delayed 6 L2 blocks worth of transactions. Keep doing this, and the backlog compounds fast.

Real impact with 10 ETH budget:

The consequences are severe: bridges desync with cross-chain messages stuck in limbo, CEX withdrawals delay as exchanges wait for L1 finality, cross-rollup DeFi strategies break, and users are stuck with transactions “executed” on L2 but not finalized on L1 for hours.

Attack 3. Direct Economic Damage Attack

The Direct Economic Damage Attack exploits the lag between when rollups charge users and when they actually pay L1 blob fees.

1. Lock in cheap prices: The attacker sends DA-heavy transactions during a period when blob prices are low. Rollup users are charged this stale low rate.

2. Fee spike: Ethereum blob fees then increase rapidly. But the rollup’s pricing mechanism only updates periodically (e.g., every L1 block), so it continues charging users the outdated, cheaper fee.

3. Rollup pays the difference: When the rollup later posts its batch to L1, it must pay the higher actual blob price but has only collected the lower one from users. The rollup, not the attacker, eats the gap.

OP Stack DA DoS Vector

In late 2024, Conduit engineers discovered a critical DA spam vulnerability in OP Stack rollups (used by Optimism, Base, and others). While testing Base Sepolia Layer-3 networks, they found that an attacker could repeatedly send large, data-heavy transactions to fill the rollup’s limited blob capacity. By doing this over multiple Ethereum L1 blocks, the attacker could delay batch posting long enough to trigger a chain reorganization through OP Stack’s built-in security logic.

This delay opened a serious exploit path. An attacker could bridge funds into the rollup, spam the DA pipeline to force a reorg, then use a fast bridge to withdraw the same funds during the delay window. When the rollup reorganized, the original deposit was restored on the reverted chain, while the fast bridge withdrawal had already executed, effectively creating a double spend. Conduit reported the issue to OP Labs and Base, leading to DA throttling in op-stack v1.9.5 and a full fix in OP Batcher v1.15.0.

Mitigations Against DA Attacks

All three DA-related attacks, saturation, amplified finality delays, and direct economic damage, stem from the same issue: rollups peg their DA price to Ethereum’s blob base fee, which updates slowly and often remains near zero. This creates a cheap, predictable choke point for attackers. The solution is to combine short-term reactive defenses with structural pricing changes.

Short-Term Defenses: Filters and Multipliers

These are quick, reactive measures that rollups can implement immediately to limit spam:

• Transaction size caps: Limit how much blob data a single transaction can consume. Oversized transactions are dropped or delayed, preventing one attacker from monopolizing blobspace.

• Dynamic fee multipliers: Charge progressively higher fees as transactions fill more of a blob. This discourages cheap, high-volume spam that relies on a few large transactions.

• Filtering low-efficiency traffic: Identify and deprioritize transactions with poor compression ratios or suspicious patterns, blocking compression-resistant junk data.

These tactics are easy to deploy, especially for single-sequencer rollups, but attackers can adapt to them. They buy time, not solve the core pricing lag.

Structural Fix: Local Blob Fee Market

The lasting solution is to make DA pricing responsive at the rollup level. Each rollup should maintain its own local blob base fee, updated every L2 block based on local usage.

• If blob usage rises, the local fee increases immediately; if usage drops, it decreases, mirroring Ethereum’s EIP-1559 mechanism but at sub-second cadence.

• A floor equal to Ethereum’s blob base fee ensures the rollup never underprices during L1 congestion.

This closes the delayed feedback loop that attackers exploit, forcing them to pay rising fees in real time instead of abusing 5–64 blocks of underpriced capacity.

My thoughts: After researching deeper into blob economics and attacks, I started looking for designs that offer long-term resilience. I came across two upcoming Ethereum upgrades that tackle this from different angles, one focuses on scaling blob capacity more flexibly, and the other keeps blob fees from collapsing to near-zero. Alongside these, Luban introduces an entirely new idea: a blob futures market, letting rollups lock in data capacity ahead of time instead of competing on the spot.

Exploring the Design Space for Long-Term Resilience

Mitigations can patch current vulnerabilities, but long-term resilience requires rethinking how rollups design their fee mechanisms and interact with Ethereum’s data layer. This involves exploring the broader design space

EIP-7892 — Blob Parameter-Only Hardforks

EIP-7892 introduces a lightweight type of hardfork that changes only Ethereum’s blob capacity settings, without touching other parts of the protocol. Specifically, it lets core developers update three key blob parameters more frequently and easily:

• Target – how many blobs Ethereum aims for per block.

• Max – the absolute cap of blobs per block.

• Base Fee Update Fraction – how quickly blob prices adjust each block.

These values live in a shared “blob schedule” that both the execution layer and consensus layer follow, keeping the network aligned. Until now, changes to blob capacity could only happen during major network upgrades (big hardforks), which typically happen once or twice a year. But rollup demand for data grows much faster than that. With EIP-7892, Ethereum can:

• Ship smaller, focused forks just to update blob parameters

• React faster to real network demand

• Start with conservative blob limits, observe mainnet performance, and scale up gradually

EIP-7918 — Introducing a Dynamic Blob Fee Floor

Ethereum introduced blob transactions with EIP-4844, creating a cheaper data lane for rollups. Blob fees follow an EIP-1559–style mechanism: when usage is low, the blob base fee can fall to 1 wei per byte. This is efficient during quiet periods, but it introduces a critical weakness, blob fees can become so cheap that they stop functioning as a real price signal. When demand spikes again, fees take many blocks to recover. In the meantime, rollups revert to Priority Gas Auctions (PGAs), leading to congestion, unpredictable fees, and exploitable pricing windows for attackers.

Priority Gas Auctions Mechanics

EIP-7918 introduces a dynamic fee floor that ties minimum blob fees to the execution base fee. This sets a reserve price below which blob fees cannot fall:

Reserve Price = BLOB_BASE_COST × execution_base_fee

If blob fees dip below this reserve price, the protocol stops lowering them, while still allowing fees to rise normally when demand increases. This ensures blob fees remain economically meaningful even during periods of low blob usage.

Key Parameters

• GAS_PER_BLOB = 131,072 (128 KB per blob)

• BLOB_BASE_COST = 8,192, exactly 1/16 of GAS_PER_BLOB

This means the minimum blob fee is always 1/16 of the execution gas cost per blob, ensuring pricing stays anchored to network conditions.

Example

Suppose the execution base fee is 16 gwei:

Floor = 8,192 × 16 gwei = 131,072 gwei ≈ 0.000131072 ETH per blob

Even if blob usage collapses, blob fees won’t fall below this value.

By keeping blob fees from collapsing to near-zero, EIP-7918 raises the baseline cost of spamming blobspace, making DA saturation attacks more expensive and less predictable. Attackers can no longer exploit long periods of ultra-cheap blob pricing to flood rollups — the reserve price acts as a built-in economic defense.

Luban: Introducing Blob Futures on Ethereum

Blobs gave rollups a cheaper data lane on Ethereum, but the spot blob market is volatile. Rollups must buy blob space in real time, competing for inclusion against bigger players like Base or Taiko.

Luban changes this by introducing blob futures, a way for rollups to pre-purchase guaranteed blob capacity at fixed prices for future blocks, like booking bandwidth in advance.

Powered by Taiyi (built on restaking layers like EigenLayer and Symbiotic), validators or underwriters commit future blobspace. Rollups can lock in prices for upcoming slots, ensuring inclusion even if gas spikes later.

This creates a new DA market dynamic:

• Rollups get predictable costs and guaranteed inclusion

• Validators unlock new yield by selling blob futures

• Underwriters market-make blob capacity, taking on volatility risk

A high-throughput OP Stack rollup, Rise Chain used Luban futures to secure stable blob capacity, smooth throughput, and avoid fee spikes — even with rotating sequencers.

Looking ahead, Luban aims for Pre-Settlement, letting rollups commit state updates before final settlement, making based rollups faster, more composable, and economically aligned with Ethereum.

Future upgrades

Full Danksharding is Ethereum’s long-term plan to massively scale data availability by increasing the number of blobs per block by orders of magnitude. Unlike proto-danksharding (EIP-4844), which introduces a small, fixed blob capacity, full danksharding will enable dozens or even hundreds of blobs per block.

This is made possible by data availability sampling (DAS), which lets nodes verify only small random portions of blob data instead of downloading everything, keeping verification lightweight even as total capacity explodes.

By making blob space abundant and cheap, full danksharding makes it far harder for attackers to monopolize data availability with fixed budgets, while giving rollups a huge, low-cost lane for publishing their data. This shift turns blobspace from a scarce resource into a high-throughput DA layer for the entire rollup ecosystem, setting the foundation for Ethereum to support thousands of rollups without overwhelming the network.

Conclusion

Ethereum’s DA layer is entering a new phase, one defined not just by cheaper data, but by smarter pricing, protocol agility, and market innovation. From fee floors to blob futures, the design space is expanding to make DA both economically robust and ready for rollup-scale growth.

• Hazeflow is a blockchain & crypto research firm focused on underlying technologies, product approaches, and functions of blockchain products.

• Written by Ishita Rastogi, edited by Pavel Paramonov.

This is Part II of this research.

In Part I, we explained that stablecoin-centric blockchains will achieve mass retail adoption not by directly attracting individual users from existing apps, but by first onboarding institutions such as banks and payment firms to integrate stablecoin rails into traditional finance flows.

In this part, we explain how this can happen. If you haven’t read Part I, read it here.

For stablecoin L1s to succeed in this dual strategy (top-down & bottom-up) and eventually serve billions, the core infrastructure must check several boxes. It’s not enough to issue a token and call it a day, these networks need to solve real-world frictions that currently limit crypto’s reach. Here are the crucial requirements which are being talked about less in front of low-gas fee or stablecoin denominated fee, etc.

FX will be tokenized

End-state, all FX lives on-chain: digital dollars, euros, yen, yuan, value hops currencies like packets. Today, though, the proliferation is mostly “digital dollars,” and it’s splintered across issuers. The way to keep UX simple is a Sanctum-style meta-pool for dollars: branded, GENIUS-compliant coins (e.g. Starbucks USD, McDonald’s USD) all interchangeable via one deep LP (e.g. USA₮/USAT).

Apps quote “USD,” route to the deepest pool, and users never see issuer complexity. Recent experiments (including new U.S.-regulated dollars and big infra players testing branded stables) point to exactly this: multiple issuers at the edge, one common liquidity spine.

MEV: fix the middleman cut and keep the good arbitrage

Bad MEV is like a middleman secretly taking a cut from a transaction for simply being part of the process. Enterprise payments can’t tolerate that. 2 practical fixes:

1. Make “good MEV” public and programmable. Expose chain-run/public arbitrage so anyone can supply to a MEV LP (even from a phone) and split the gains back to users/treasuries, rather than private extractors.

2. Carve lanes (separate blockspace) for payments/CLOB flows. Can be done with native compliance hooks, deterministic sequencing and settlement guarantees where needed (Stable style playbook), while leaving other lanes open for competition.

Agentic payments (lead with x402, then standards).

Coinbase’s progress on the recent Agent-to-Agent infrastructure has led to x402, which essentially is a upgraded HTTP-402 standard so agents can pay in stablecoins over plain HTTP: no accounts, no OAuth, instant settlement per request.

Layer on emerging agent-to-agent (A2A) standards from major cloud/payments players to add mandates, spending rules, and identity. Net effect: machines meter APIs, content, compute, and network services autonomously, paid in tiny stablecoin drips. This is where stable rails shine (sub-second, programmable, 24/7) and why “agentic commerce” becomes a first-class requirement.

Cross-chain

Don’t force a single chain. Accept “USD” at the edge and let the router pick the rail (whatever is cheapest/fastest: USDT on Tron, a U.S. bank-issued coin, a CDN-native dollar, etc.). The receiver auto-settles into their preferred token or fiat. Interop becomes a routing problem, not a user problem.

Stablecoins as Invisible Infrastructure

Most people won’t know or care about what a stablecoin L1 is, but they’ll use it daily.

Think Ethereum as the warehouse/settlement layer and stablecoin networks as the highway + FedEx trucks moving value between apps. Stable rails become the “middleware for the dollar (and other currencies),” handling payments, FX, and settlement so front-ends stay simple.

This aligns with the super-app thesis. Coinbase (and peers) aim to be your primary financial account: they’ll route under the hood across Base, stablecoin rails, Bitcoin, etc., while you just see a balance. The goal: replace 2–3% card tolls with payments that feel virtually free. Stable networks are how that happens.

Meanwhile DeFi gets abstracted. You tap “Earn” or “Swap”, the app chooses the cheapest/safest route (often a stable L1 for fiat-like flows). Identity abstraction replaces seed phrases and RPCs with email/biometric logins. We already saw hints of this with Reddit’s Vaults: millions interacted with crypto without realizing it.

Another likely pattern is assets vs. flows. Long-term assets (stocks, funds) remain anchored on Ethereum-grade security, while everyday flows (purchases, payouts, remittances) zip across specialized stable rails. Software makes the wrap/swap/route invisible: sell a token to stablecoins, route over a stablechain, auto-convert on receipt: users just experience “pay anyone, anywhere, instantly.”

Zoom out and it looks like WeChat or Gojek, but supercharged by crypto features. Your app handles bills, savings, investing, chat, shopping. Behind the scenes, a router picks the optimal rail per action: Lightning for a BTC buy, a stable L1 for a payment, Ethereum for an NFT, and so on. The stablecoin network plays the role of the national/payment backbone.

Net result: apps talk to stable networks, users just get speed, finality, and low cost. Stablecoin L1s fade into the plumbing which is reliable, boring, ubiquitous moving trillions behind the scenes. Getting there isn’t only a tech race: it’s a go-to-market race of distribution, yield design, FX/liquidity routes, and partnerships — which is exactly where we go next.

Yield, Distribution, and the Go-To-Market War

Even if the infrastructure is perfect, stablecoin networks face a final boss: bootstrapping usage and beating out TradFi competitors. In an environment where crypto yields have collapsed (imagine a return to low global interest rates), attracting users and capital requires creative strategies beyond “we pay 5% on stablecoins” – because what happens when T-bill rates drop to 0.5%? The answer: distribution is everything. The stablecoin players know this, and we’re seeing a variety of go-to-market (GTM) approaches emerge.

New Models for Yield

During a high-rate environment, stablecoin issuers like Circle and Tether could offer yields or incentives funded by interest on reserve assets (which was 5%+). In a low-rate scenario, those juicy yields vanish. How, then, to entice users?

Some projects are experimenting with alternative reward models.

• For instance, there are protocols like GENIUS and things like USAT (Tether’s U.S. affiliate coin) which may allow banks to pass through some interest or use other incentives.

• Or a government might subsidize certain stablecoin uses, for example, giving a tax credit or higher FDIC-insurance-like protection for stablecoin accounts to encourage adoption.

• Issuance fees or revenue sharing could also come into play: if a big brand issues a stablecoin on a network, they might get a cut of transaction fees or a portion of the float interest, providing an incentive to push it to their customers.

In short, yield might shift from pure interest to rewards, discounts, and utility. PayPal, for example, could offer cashback in PYUSD for using their stablecoin, retail stablecoins could tie into loyalty programs (imagine earning airline miles for holding a USD stable balance with an airline’s partner bank).

Branded Stablecoins and White-Label Distribution

As mentioned, Walmart and Amazon exploring stablecoins lit a fire under this concept. It’s plausible we’ll see a wave of “bring your own users” stablecoin deals. A chain or issuer might approach a corporation: “We’ll handle the tech, regulation, and reserve management, you slap your brand on a stablecoin that your millions of customers can use in your ecosystem.”

The company gets reduced payment costs and maybe new revenue streams, and the stablecoin network gets an instant user base. It’s analogous to how credit card networks courted retailers to issue co-branded cards (Amazon Visa, Apple Card, etc.), only now it’s co-branded digital cash.

The GENIUS Act makes this legally feasible in the U.S. by explicitly allowing private companies to issue digital dollars under oversight. So don’t be surprised if in a few years you have Starbucks Dollars (usable at Starbucks for extra perks), Walmart Cash (which could even be spendable outside Walmart eventually), or McCryptoCoin (buy a Big Mac, get some coins that can be saved or used elsewhere). Each of these would likely run on one of the stablecoin networks, whether it’s an existing public chain or a purpose-built consortium chain.

The competition among stablecoin L1s will in part be who can sign the biggest brands and banks to launch on their platform. It’s a distribution war reminiscent of the early days of smartphones (iOS vs Android scrambling to get app developers and OEM partnerships).

Cards and Consumer Apps

Ironically, even as stablecoins try to disrupt card networks, many are also embracing cards as a user acquisition tool. For example, Coinbase’s 4% crypto rewards Visa card is basically giving users yield for spending via stablecoin (they convert your crypto to USDC to pay the merchant, and give you 4% back in Bitcoin). This is subsidized by interchange fees, it’s leveraging the old system to grow the new.

We will see stablecoin wallets come with debit cards so people can spend stablecoins at any Visa/MasterCard terminal, while gradually encouraging direct stablecoin acceptance to reduce reliance on those rails. The idea is to offer the best of both worlds in transition: swipe your card, but settle via stablecoins on the backend, and earn rewards. Over time, once enough merchants accept stablecoins natively (or via instant conversion), the card layer could fade, but for now it’s a bridging strategy.

Consumer-facing apps are another battleground: every stablecoin issuer either has or partners on a wallet app. For example, Stable launched Stable Pay wallet, others will try to target emerging markets as well to make using USDT as easy as using Venmo. Circle has its APIs in many fintech apps. The race is on to capture mindshare such that when users think “send money,” they use your interface (with your stablecoin under the hood). Because if you control the front-end, you can switch out the backend as needed. That’s one reason Coinbase and others are pushing to be super-apps – to own the customer interface before banks or Big Tech do.

What to Expect?

Ultimately, expect a “stablecoin chain war” over the next few years that will be as much about distribution, branding, and regulatory capture as it is about blockchains. Each major player will tout some edge: one might have the fastest blocks, another the big brand partners, another the blessing of the Federal Reserve (imagine a Fed-approved stablecoin vs. a crypto-native one).

The winners will be those who secure the most real-world usage, which likely means aligning with institutions that have scale.

To loop back to our thesis: stablecoin L1s that are institution-first will outcompete those that are “user-first” in a vacuum. A cool wallet with 50k crypto users is not going to bank the world. But a stablecoin rail adopted by, say, Amazon for all its marketplace payments just might.

This may be a slightly irreverent pill for crypto purists to swallow, it means much of crypto’s success could ride on old-guard institutions and Web2 platforms playing ball. But if the end result is billions of people enjoying faster, cheaper, more inclusive financial services (even if they don’t know stablecoins are under the hood), that’s a worthy trade-off.

• Hazeflow is a blockchain & crypto research firm focused on underlying technologies, product approaches, and functions of blockchain products.

• Written by Nitin Jakhar, reviewed & edited by Pavel Paramonov.

Solana has become one of the fastest blockchains in the world. Over the past year, the network has processed billions of transactions each month with consistently low fees and sub-second finality.

But there’s a level of adoption Solana hasn’t yet unlocked: institutional capital operating at scale.

Walk into any trading floor at a major financial institution, any regulated payment processor, or any enterprise treasury operation, and you’ll encounter the same non-negotiable requirement: deterministic execution.

For a high-frequency trading desk executing strategies across multiple venues, each transaction in the sequence has to land in the exact slot and in the correct order. If even one transaction arrives late or out of order, the price can move, and a profitable trade can quickly turn into a loss. Similarly, for a protocol’s liquidation system protecting millions in collateral, a single slot’s delay can lead to millions in bad debt.

These operations don’t just need fast transactions or low fees. They need guarantees, cryptographic certainty that a transaction will execute exactly when and where intended, every single time.

Day-to-day, retail flows on Solana are reliable. But at institutional volumes, and especially during bursts of activity, the difference between “very likely” and guaranteed becomes the difference between clean P&L and a post-mortem. Teams need slot-exact, order-aware inclusion that holds even when the tape is hot.

What institutions optimize for is not just speed and low fees, but bounded variance, predictable SLAs, and auditability:

• Bounded variance: Transaction landing times fall within a tight, predictable range, allowing trading strategies to accurately price execution risk and enabling insurers to confidently underwrite that risk.

• Predictable SLAs: commitments that survive congestion, not best-effort targets.

What are the current fixes, and why do they fall short?

Solana’s ecosystem has already tried to patch reliability through upgrades and alternative clients, but neither solves guaranteed inclusion.

Agave is Solana’s validator client, and the v1.18 update was introduced to fix how transactions were scheduled. Before, they were mostly ordered by arrival time, so even if you paid a higher fee your transaction might lose out to spam or random thread ordering.

Agave created a new system to manage transactions more efficiently. Instead of processing transactions randomly, it organizes them into a clear order based on their priority fees (how much someone pays to get their transaction processed faster) and the resources they use. This makes the system fairer, prevents transactions from failing (reverts), and keeps costs stable for regular users, even when the network is very busy.

Big problems remain

Solana lacks strong economic disincentives to stop spam, so bots can still flood the network during peak demand. And even with Agave, users don’t get guaranteed inclusion: paying a higher fee doesn’t ensure their transaction will land. Some transactions never even reach the block leader in the first place, because they get lost at the networking layer, the system that streams transactions over QUIC connections from users to the validator leader. When those connections fail or throttle, the transaction simply disappears with no record at all.

BAM (Block Assembly Marketplace) by Jito was built to make Solana’s block building more structured. Instead of every validator assembling blocks on their own, BAM adds a coordinator layer where transactions are ordered inside Trusted Execution Environments (TEEs) and then sent back to validators to sign. This creates more predictable ordering and helps reduce certain kinds of MEV.

But the trade-offs are heavy. Routing all traffic through TEEs adds latency, transactions are encrypted, processed, and re-encrypted in single-threaded enclaves, which slows things down. That’s a serious problem for DeFi apps where milliseconds matter. Validators also lose autonomy, since they no longer build blocks themselves but just sign what coordinators provide. Power shifts to a small middle layer, developers face friction writing enclave-compatible plugins, and TEEs themselves add new risk surfaces, given their history of exploits.

In short: BAM improves structure, but it centralizes, slows down, and still doesn’t guarantee fast, deterministic inclusion.

Raiku: Enterprise-Grade Certainty

Raiku addresses these problems head-on. Its tech is built to ensure that transactions are processed predictably, quickly, and in a customizable order. Developers can book space for their transactions ahead of time or ensure their transactions are prioritized instantly, with confirmation in under 30 milliseconds. Validators use a simple add-on tool, called the Raiku Sidecar, that enforces these promises and provides new ways to earn money, all while keeping their existing software unchanged.

Raiku introduced guaranteed execution by ensuring that once a transaction is committed, it will land exactly where intended. This is not achieved through retries or congestion management tweaks, but through two new transaction types that fundamentally change how blockspace is consumed: Ahead-of-Time (AOT) and Just-in-Time (JIT).

Ahead-of-Time Transactions

AOT transactions are designed for operations where precision and predictability are critical. They allow users to pre-purchase a guaranteed inclusion slot for a transaction at a specific future time, at least 35 slots (>15 seconds) ahead. This turns blockspace into a resource that can be scheduled with confidence and eliminate the uncertainty that plagues time-sensitive operations on Solana today.

AOT follows a “Put me in this specific future slot” model. Users submit an intent that specifies the action, timing, and maximum fee they’re willing to pay. Raiku then books that transaction into the requested slot, guarantees its inclusion, and issues a pre-confirmation: an early, signed guarantee that the transaction is locked in place.

When to use AOT:

• Repaying loans before hard deadlines (e.g., 14:03 UTC).

• Publishing oracle updates on fixed intervals (e.g., every 30 seconds).

• Institutional settlement windows that must be honored on time.

• Rebalancing large vaults without risk of missed execution.

• Running batch processes at optimal times to reduce costs.

• Claiming staking rewards during low-fee windows.

Just-in-Time Transactions

If AOT transactions are about planning ahead, JIT is about acting in the moment. JIT transactions are built for situations where speed is everything, where being even a few seconds late means losing money, missing an opportunity, or failing to protect a protocol.

With JIT, users can purchase guaranteed top-of-block inclusion in the very next slot. This is especially powerful for latency-sensitive operations like:

• Liquidations: Protocols can’t afford delays when a loan is under-collateralized. If a liquidation transaction doesn’t fire instantly, the system risks bad debt.

• Arbitrage: Price differences between markets can vanish in milliseconds. Being even slightly late can turn profit into loss.

• NFT mints or racing scenarios: When thousands of users rush to mint at once, only those with top priority get through. JIT guarantees your place.

• Emergency rescue transactions: In fast-moving DeFi markets, protocols sometimes need to send a rescue transaction immediately to avoid cascading failures. JIT ensures it gets through without delay.

JIT transactions follow a first-price sealed-bid auction. You submit your bid, and the highest bidder secures the guaranteed slot. To keep the system fair and prevent spam, Raiku sets a minimum bid equal to Solana’s current priority fee plus a 5% premium. This model ensures that only users who truly value immediate execution compete for JIT slots, while keeping costs transparent and predictable.

Once a JIT transaction is submitted, Raiku immediately locks space in the leader’s next block. From that moment, your inclusion is guaranteed: no random drops, no waiting in queues, no hidden mempools. Execution is deterministic, and settlement happens within seconds.

If you win the bid, you’re in, no matter how congested the network gets.

AOT & JIT: Combined

For JIT, Raiku locks space in the next leader slot. For AOT, it books space in the exact future slot requested (e.g. 35+ slots or >15 seconds).

Within that slot, execution is fully deterministic: the highest bid goes first. However, when bids are equal:

• JIT → earlier arrival wins

• AOT → earlier booking wins

There are no hidden queues, no off-chain favoritism, just transparent slot-level ordering.

The Slot Marketplace

Raiku introduces the Slot Marketplace as the mechanism that makes its promises of guaranteed inclusion real. Instead of treating blockspace as a chaotic free-for-all, the marketplace enforces rules that make inclusion predictable and verifiable. How?

At its core, the Slot Marketplace does two things:

1. Ensures that if a slot is reserved, it will actually be honored by the validator running that slot.

2. Distributes responsibility based on validator stake, so stronger validators carry greater accountability for reliability.

There are 2 layers of guarantees: Slot-Inclusion Quality of Service (siQoS) and Stake-Weighted Quality of Service (swQoS).

Slot-Inclusion Quality of Service (siQoS) allows the current leader to provide credible guarantees about transaction inclusion and execution. Once a transaction is scheduled for a specific slot, the validator responsible for that slot must include it, with inclusion enforced at the protocol layer through the Raiku sidecar.

In Stake-Weighted Quality of Service (swQoS), reliability is tied to economic weight. Validators with more stake have higher obligations to deliver consistent service. This prevents small or poorly performing validators from weakening guarantees while ensuring the backbone of the network is secured by the most invested participants.

Primary vs. Secondary Market

• Primary Market: This is where long-term reservations happen. Large institutions or validators can secure blockspace capacity in advance, like buying bandwidth contracts. It gives them predictability and aligns incentives with stability.

• Secondary Market: Not every slot gets used. The secondary market reallocates unused slots in real time so nothing goes to waste. If bandwidth isn’t claimed, it gets reassigned to keep throughput high and fees fair.

Together, the primary and secondary markets ensure that blockspace is fairly allocated and never wasted. But demand isn’t static, sometimes enterprises need to plan ahead, and other times markets move suddenly and demand instant access, which takes us to dynamic balancing.

Dynamic Balancing

Think of slots like hotel rooms: AOT reservations are pre-bookings, JIT are walk-ins.

• If every room is reserved, walk-ins get shut out: if everything is left for walk-ins, planners can’t book ahead.

• Raiku avoids this by shifting capacity in real time, honoring AOT reservations while still leaving space for JIT, and opening more room for JIT when demand spikes without breaking AOT commitments.

• The result is no starvation, fairer pricing, and full slot utilization.

Ackermann Siblings: Node and Sidecar

Just like in the Attack on Titan anime series, where Mikasa and Levi are related and share the Ackermann name, the Raiku series features a similar relationship between node and sidecar.

Ackermann Node acts as the planner. It receives transaction intents from the Ackermann SDK, runs the AOT and JIT auctions, determines which slots each transaction will occupy, and issues pre-confirmations that guarantee inclusion ahead of time. It also continuously monitors validator and Sidecar health to ensure that booked transactions are routed to the correct validator for execution.

Ackermann Sidecar is the enforcer, running directly alongside validators. Once the Node has assigned a transaction to a specific slot, the Sidecar ensures that this commitment is honored at the validator level. It accepts the pre-confirmed transaction, holds it locally until the precise scheduled moment, and then injects it directly into the validator’s block production pipeline, bypassing Solana’s QUIC transport layer and eliminating networking-layer drops that often cause transactions to disappear under congestion.

The Sidecar also applies strict bandwidth allocation and ordering rules. It enforces both siQoS and swQoS, ensuring that reserved transactions take precedence and validators handle their proportional share of network traffic fairly. Beyond enforcement, the Sidecar enhances network reliability by rerouting transactions to another healthy Sidecar if the scheduled validator is overloaded, without breaking the original inclusion guarantee.

• Together, the Node and Sidecar form the coordination and enforcement backbone.

• The Node plans and allocates blockspace, the Sidecar ensures those plans are executed precisely at the validator level.

If you want to learn more about the full technical design, please visit the official documentation.

Takeaways

• Solana has proven it can deliver speed and low costs at scale. Recent improvements have significantly enhanced reliability for everyday users. But the next phase of adoption, bringing institutional traders, payment processors, AI marketplaces, and enterprise DeFi protocols to Solana, requires more than performance. It requires certainty.

• Traditional finance operates on guarantees. When you submit a wire transfer, you know it will settle. When you place an order on a regulated exchange, you know it will execute according to the rules. When you schedule a batch payment, you know it will process on time.

• Raiku brings that same level of certainty to Solana. It doesn’t replace Solana’s existing transaction model, retail users can continue using the network exactly as they do today. Instead, Raiku adds a premium layer for users and institutions who need deterministic outcomes and are willing to pay for that guarantee.

• This is how Solana becomes more than a fast blockchain. This is how it becomes infrastructure that enterprises can build on with confidence.

• Hazeflow is a blockchain & crypto research firm focused on underlying technologies, product approaches, and functions of blockchain products.

• Written by Ishita Rastogi, reviewed & edited by Pavel Paramonov.

Unfortunately, in most projects, tokens are used solely as a fundraising tool with no real utility. Therefore, the team often sells the tokens to fund operational expenses, incentive programs, liquidity mining campaigns, and so on.

That practice greatly influences the token price and raises FUD (fear, uncertainty, and doubt) within communities when the team sells tokens. Take the Ethereum Foundation as an example: when they sell ETH, the community accuses them of dumping.

Instead, the fundraising amount can be reinvested into low-risk strategies, and the yield from it should be enough to cover operational costs until the product starts making revenue.

2. Alternative Flying Tulip Vision

The core idea behind Flying Tulip is to use fundraising as a cash cow instead of simply spending the principal. Rather than directly spending the fundraised money, the team can deposit it to earn yield and use that yield to fund initial protocol operations.

The idea is that a team should have no tokens at all at the beginning. If they haven’t started earning revenue, the company shouldn’t be worth anything. Token ownership should align with real revenue, making it more milestone-based than it is right now.

Investing, and venture investing in particular, is an asymmetric bet: you can gain 1000×, but you can only lose 1×. However, VCs usually “spray and pray” across tens or even hundreds of deals and often lose money; that’s part of the game.

The Flying Tulip idea also comes with a form of downside protection, so at worst, investors can get their original investment back.

Therefore, the core idea of Flying Tulip is to raise a lot of money and not actually spend it, only using the yield from that money to fund operational expenses and buy back its own token.

3. Core Value Flow

1. Investors commit different types of highly liquid tokens.

2. These tokens act as backing capital for FT tokens.

3. FT tokens are issued alongside perpetual put options for every investor’s position.

4. Investors receive their FT tokens and perpetual put options.

5. Invested capital is deployed into multiple DeFi protocols to farm yield.

6. Generated yield is used to buy back and burn FT tokens, increasing token scarcity.

7. Generated yield is also used to fund different protocol expenses.

4. What is a perpetual put option?

First of all, perpetual futures (perps) and perpetual options are not the same thing.

Perpetual futures are ongoing contracts that let traders bet on an asset’s price changes without an end date. Profits or losses increase or decrease steadily with the price, and small fees are paid periodically to keep the contract aligned with the real market price.

Perpetual options give traders the choice (but not the obligation) to buy or sell an asset at a set price forever. They have uneven profits that can limit losses for buyers, including upfront fees and possible changes to the set price over time.

There are two types of options: a put (the right to sell) and a call (the right to buy). In the context of Flying Tulip, a perpetual put option is issued along with FT tokens, which means that investors can sell their tokens at any point in the future for their initial investment.

For example, if an investor buys 1000 FT tokens worth $10, they can sell their 1000 FT tokens at any point in the future, even if those 1000 FT tokens are worth less. It’s worth adding that put options will be tradable on their own and so there will be an open market for them where the price of put options will highly likely correlate with the price of FT tokens.

Having a perpetual put option equals being protected from assets losing their value.

5. If the team has no tokens at TGE, how are they getting them?

At the beginning, investors own 100% of the supply, and the team owns nothing. In fact, the team owns nothing until they start making money, providing an incentive for the team to make their protocol profitable.

Let’s assume the suite of different DeFi products is generating revenue. 100% of this revenue is used to buy back and burn FT tokens. At the same time, the same amount of tokens is unlocked for the team and distributed among the foundation, incentive programs, ecosystem growth, and the team itself. You can see the exact proportions in the diagram below. Revenue and fees should eventually contribute to the buy pressure of FT.

6. Why are only stablecoins, BTC, ETH, SOL, and AVAX can be a backing capital?

The put option is a core feature of the protocol. If assets are tied up in illiquid positions, the protocol risks being unable to meet redemption demands, especially in stress scenarios and when faced with the risks outlined below. The PUT is asset-specific. For example, if investors contributed USDC, they must be paid in USDC, not in other currencies. Therefore, high liquidity must be maintained for each type of asset. Funds cannot be reallocated to higher-yield opportunities because the received yield from those opportunities could be in other types of assets.

First, this is why only highly liquid assets can be backing capital. Second, that is why highly liquid assets are deployed in highly liquid strategies (stablecoins in Aave, ETH in stETH, SOL in jupSOL, and so on).

7. What happens when I sell / transfer my FT tokens?

If investors transfer or sell tokens, their put options become invalid or void.

Let’s say an investor spent 100 USDT to buy 1,000 FT tokens. When they sell their tokens (or a portion of them), they receive 100+ USDT (assuming the investor has an incentive to sell and not exercise their option).

Those initial 100 USDT (the backing capital of 1,000 FT) are released and used to buy back the FT tokens and burn them, reducing the total token supply.

• An investor purchases 1,000 FT tokens by paying 100 USDT (1 FT = 0.1 USDT).

• Investors selling 1,000 FT tokens receive 110 USDT (1 FT = 0.11 USDT).

• 100 USDT of the initial backing capital is released.

• 100 USDT are used to buy back 909 FT (1 FT = 0.11 USDT).

• Those 909 FT are burned, the supply is reduced, and token scarcity is increased.

When investors sell, they always make some profit; otherwise, there is no reason to sell (you can always get back your investment without losses). When tokens are sold, it influences the price, depending on how many tokens are sold. Buying back and burning tokens is the action used to compensate for the price drop and decrease the volatility from selling by buying tokens and burning them, thus reducing the supply.

8. What happens when I exercise my put option?

The investor can exercise their option at any point because it is perpetual. Investors only have an incentive to exercise their option if the current cost of their tokens is lower than or equal to their initial investment amount.

Obviously, when investors want to sell for profit, they would not exercise their option because it makes no sense. Thus, put options are only exercised when investors want to sell their tokens for their original investment without incurring any losses.

In this case, the initial capital is returned to investors, and the tokens are burned. In terms of value flow, exercising an option and selling for profit are similar: in the first scenario, tokens are burned, and in the second scenario, they are bought back and burned. In fact, no matter what investors do, their actions contribute to reducing the supply.

9. What are the risks of this model?

I want to divide types of risks into two categories: general risks and model-specific risks.

Among general risks are those that are present in most DeFi products. We must take into consideration the stability of the stablecoins and pegged assets used as backing, because most assets will receive yield from staking. Assuming that USDe is one of the core assets of backing capital, putting it into staking with sUSDe presents even more risks, as these are sensitive to market funding rates. Yield could become negative or insufficient to cover perpetual put option redemptions.

In this case, the protocol will take the losses, and the downside protection promised by the PUT mechanism could be undermined.

Obviously, with the majority of backing capital being stablecoins (mostly USDT and USDC), there are regulatory and legal risks. However, it is fair to say that if that occurs, it will affect the industry in general, not just Flying Tulip.

The model-specific risks are more interesting, especially with Flying Tulip’s demand for “immediate liquidity” and delays in the transaction supply chain. The problem is that staking positions involve unbonding periods or withdrawal queues. On Ethereum, there could be delays due to the network’s validator exit queue for stETH. Withdrawal queues are more dangerous than the ETH unstaking queue because the capital has underlying risks for many different protocols which are being used for yield.

If there is a large number of correlated PUT exercises, delays will be an issue when redemptions require same-day liquidity. This could cause investors to panic and exercise their options, covering potential losses and adding even more instability to the system.

10. Opportunity costs

If the price of FT remains close to the initial $0.1 for a long period of time, the FT value stagnates. Holders do not realize capital gains, and their investment is locked in a low-volatility asset without momentum, so it does not make sense for them to participate at all. They could have simply deposited it somewhere else, as depositing USDC on Aave could yield similar returns.

In Flying Tulip, the backing assets could earn similar yields on their own. These yields indirectly support FT holders by funding buybacks, which could stabilize or modestly increase the token’s value over time, but it is not that simple.

However, if the price remains the same, the return for holders mirrors what they might earn from holding and yielding stablecoins directly without the added benefit of significant appreciation. This is because buybacks at these levels primarily maintain the floor value rather than generate outsized gains.

11. So what’s the product? Is it only a raise mechanism?

This is a very interesting part. If you have read this far, you might be wondering that the whole article has been about the fundraising mechanism, but what about the actual product? It seems this model can be implemented everywhere, but what is the actual product besides the fundraising mechanism? How is revenue going to be generated?

There are no clear details at the moment about the specific product, but the team wants to build an entire DeFi super app from it, featuring its own stablecoin (ftUSD), delta-neutral lending markets, delta-neutral derivatives, insurance, an on-chain CLOB (Central Limit Order Book), a permissionless AMM), lending, and permissionless derivatives. The FT token will be integrated natively, and revenue from those products will be used to buy back and distribute yield to users (in addition to funding its own operations, obviously).

12. Where does the Flying Tulip name come from?

This is the question that I was particularly interested in because “Flying Tulip” by itself made no sense, so I asked the team about it.

• Flying refers to the Flying Dutchman.

• Tulip refers to the Tulip Mania.

The Flying Dutchman (the ship doomed to sail forever) contributes to volatile crypto markets that are doomed to be volatile yet remain open and permissionless (like the seas). Moreover, Andre Cronje is Dutch himself (technically South-African, but if you know history, you know about Dutch in South Africa).

Tulip Mania represents a speculative bubble in the Dutch Republic where the prices of rare tulip bulbs soared due to intense trading and then crashed dramatically. This is one of the greatest financial lessons and one of the world’s financial heritages.

Flying Tulip equals Andre’s heritage plus the world’s financial heritage.

• Hazeflow is a blockchain & crypto research firm focused on underlying technologies, product approaches, and functions of blockchain products.

• Written by Pavel Paramonov.

Contrarian Stablecoin Thesis

Stablecoin-centric blockchains (stablecoin L1s) won’t achieve mass retail adoption by luring users away from their favorite apps. Instead, they’ll grow by onboarding institutions that already own the payment lanes now.

In other words, the path to everyday users is through banks, payment firms, and big institutions first and through crypto wallets at the last. Current crypto networks are fighting over the same small pool of DeFi users while ignoring the much larger financial world outside.

The ∼$28 trillion annual flows of DeFi are still just 0.12% of the ∼$24 quadrillion coursing through traditional finance.

• To put that in perspective, traditional finance flows are about 857 times larger than DeFi’s current annual flows.

• For every $1 in DeFi, there are about $857 in traditional finance.

Crypto may and will one day hold all the world’s liquidity, but getting from 0.12% to 100% will require stepping stones that bridge the gap between today’s tiny crypto ecosystem and the real economy.

Stablecoin L1s are in best position to build those bridges via practical interim steps, think tokenized FX markets, “agentic” commerce (AI-driven transactions), and DePIN (decentralized physical infrastructure), rather than expecting billions of new users to self-onboard to MetaMask tomorrow.

The recent much-anticipated launch of Plasma is a good case in point. It debuted with over 2 billion in DeFi liquidity with Day-0 integration with all of the major DeFi protocols, but at the same time it is ignoring the simple fact of onboarding outside users to crypto or especially DeFi and, like most crypto-native projects, is focused on recycling liquidity inside DeFi. And while DeFi may indeed become the backbone of global liquidity someday, that day isn’t today. The harder problem and the bigger opportunity is bringing new flows on-chain.

Many would try to frame this article as “institutions vs. users,” but rather it’s more useful to see it as a sequencing challenge. DeFi is a great proving ground, but scale comes from new flow, not deeper farms. The next step is to make more of the world liquid by taking FX pairs, tokenized assets, and even resource markets (uranium, silicon, compute) and plug those rails into the banks, PSPs, and apps billions already use.

That’s the bridge between today’s DeFi sandbox and tomorrow’s real economy.

The Stablecoin Supercycle Flywheel

The stablecoin “supercycle” flywheel is what ultimately leads to retail adoption through institutional integrations, as depicted below:

Each turn of this cycle reinforces the next. For example, recent U.S. legislation (the GENIUS Act) established clear rules for stablecoin issuers to make major banks and payment companies start leaning in. And once “very trusted institutions” begin using stablecoins, that starts to move the flywheel.

To see how these “very trusted institutions” move the flywheel, let’s take a real-world example.

SWIFT is the standard for sending money through international wires. When a person in New York sends money to someone in Singapore, they don’t directly use SWIFT. Their bank/fintech intermediates everything (KYC/AML, FX, correspondent accounts) and uses SWIFT as the interbank messaging layer. Retail never touches SWIFT; institutions do. So if those same banks and processors start swapping parts of their back-end messaging/settlement to stablecoin rails, the retail experience (your bank app, your payroll, your checkout button) stays familiar; only the pipes get faster, cheaper, 24/7, and programmable.

Historical Analogies: Rails First, Users Later

It turns out crypto is no different from prior tech revolutions where a single pattern is visible i.e. the big winners built the rails first and worried about direct consumer adoption later.

Amazon Web Services (AWS) didn’t become a huge business by convincing millions of individual consumers to configure servers. Instead, AWS won over startups and enterprises as the backend infrastructure behind consumer apps. Users enjoyed faster, smarter apps without knowing (or caring) that AWS was under the hood.

Same goes with Visa Network, consumers didn’t spontaneously demand credit cards in the mid-20th century. Banks and merchants brought the technology to them. Visa started as a Bank of America initiative, signing up merchants to accept the card and other banks to issue it. Credit cards became widely used by consumers only after the necessary institutional framework was established.

Today’s stablecoins threaten to bypass Visa’s own rails, but the dynamic is similar: retailers like Walmart and Amazon are exploring issuing their own stablecoins to cut out card fees, potentially saving billions in interchange. Shoppers won’t adopt a WalmartCoin out of thin air, they’ll use it if Walmart slips it into their app for cheaper, smoother payments. The stablecoin L1 facilitating that (be it a public chain or a consortium chain) might never be explicitly advertised to shoppers as much as customers don’t think about the VisaNet data centers when tapping their card.

The similar analogy can be applied to Apple, the iPhone’s explosive growth after 2008 was driven not just by Apple’s shiny hardware, but by Apple courting developers (and eventually big companies) to build apps for everything. The App Store provided the rails (distribution, payments, toolkits) for third-party developers, whose apps then attracted billions of users. Apple focused on enabling an ecosystem, consumers flocked because of the experience (apps!) was compelling, not because they cared how the plumbing worked.

In crypto, the best user experience will similarly come from hiding the blockchain “plumbing”. Users don’t care about which chain or token powers their transaction, they care that it’s fast, cheap, and easy.

Users don’t care about rails, they care about the service

People are loyal to experiences, not infrastructures. Nobody outside crypto wakes up and says “I wish I could use more blockchains today.” They just want to pay rent, buy coffee, or send money overseas in the most convenient way.

If that means their existing bank or wallet app starts using a stablecoin L1 under the hood, they’ll happily benefit without ever hearing the word “stablecoin.” In fact, the best integration is one where the user doesn’t even realize blockchain is involved.

So, let’s see how these stablechains are making this “Whatsapp Moment for Crypto” a reality.

Two-Pronged Strategy: Infrastructure Top-Down and Bottom-Up

If stablecoin L1s are to reach billions of users, they need to attack the problem from both ends: Top-Down via institutions, and Bottom-Up via grassroots adoption. These approaches might seem opposite, but they are highly complementary and will eventually converge into a unified user payment experience. Let’s break down each strategy:

Bottom-Up (Grassroots via Tether’s Efforts and Others)

Long before U.S. tech bros noticed stablecoins, people in emerging markets like Argentina, Nigeria, Turkey, and Venezuela were using USDT as a lifeline (to deal with hyperinflation and national banking failures).

Tether who is responsible for more than 90% of the above volume has leaned into this organic adoption by investing in on-the-ground infrastructure.

• It’s funding energy production and Bitcoin mining in places like Latin America (El Salvador, Uruguay) to bolster local economies (a stable financial system needs reliable power, after all).

• It acquired a 70% stake in a renewable energy/agriculture firm (Adecoagro) to integrate blockchain with real-world industries.

• Tether is also partnering with local startups and exchanges (e.g. funding a remittance-focused exchange in Chile) to improve stablecoin on/off-ramps in underserved regions.

• There’s even talk of “tribal economy” integration, finding ways for remote or indigenous communities to use stablecoins where traditional finance has failed them.

All these efforts represent a bottom-up strategy: meet people where they are suffering from broken fiat systems, provide them dollar stability via stablecoins, and build physical and digital rails to embed crypto into daily commerce. And it’s working in many emerging markets, USDT is already the de facto dollar for remittances, savings, and commerce. And unsurprisingly, these users often have no idea what chain they’re on.

Top-Down (Institutions and Platforms Adopting Stable Rails)

In parallel to the grassroots push, stablecoin L1s pursue a top-down approach by integrating with institutions and enterprises. This includes fintech platforms, banks, payment processors, large corporations, even governments. The simple reason is that these players have massive user bases and transaction volumes and by convincing them to use stablecoin networks for things like foreign exchange, cross-border transfers, payroll, B2B settlements, etc., a stablecoin L1 can onboard millions at a stroke.

We’re seeing early signs of this. Tether backed chain Stable is explicitly built for USDT and positioned as backbone for banks and enterprises post-GENIUS Act which shows the fact that even U.S. legislators have warmed to this idea.

Those companies are exploring stablecoins not because they love crypto, but to save on the 2-3% card fees eating their margins. If they proceed, they’ll likely partner with an established stablecoin operator or infrastructure provider rather than build from scratch, which is exactly the distribution opportunity stablecoin L1s are vying for.

A prime example is Tether launching “USA₮”, a fully regulated US-dollar stablecoin for the American market. This gives institutions a compliant avenue to use Tether’s stablecoin within U.S. banking rails.

We can also imagine branded stablecoins as a service: e.g. “Starbucks Dollar” or “McDonald’s Dollar” issued on a stablecoin network, where the brand gets some incentives (like a share of interest revenue or reduced payment costs) and the stablecoin network gains millions of users transacting through a trusted brand’s app by making interop between them and USDT feel invincible.

Bottom-Up & Top-Down Combined Together

The dual-motion strategy is to push from both ends until they meet in the middle. Bottom-up adoption creates pockets of real users and volume (proving the tech and providing human stories of utility), while top-down integration brings scale and legitimacy. Eventually, they meet: maybe your autonomous AI shopping agent (a top-down tech integration) is paying a farmer in rural Nigeria (a bottom-up user) for some service, and it all happens via stablecoin rails without either party realizing it.

When that day comes, stablecoin L1s will truly have sewn together the quilt of global finance. Importantly, the end-user won’t “feel” any distinction, they’ll use their app or platform as always. Retail won’t even know they’re on a stablechain, just like most don’t know (or care) that much of USDT runs on Tron. And speaking of Tron, it’s a perfect example of how invisible infrastructure can quietly achieve massive scale.

Magic of TRX

Tron is a general L1 that effectively turned into a stablecoin rail by focusing on low fees and fast transfers. As a result, Tether heavily utilized Tron’s network for USDT.

Tron now processes over $21 billion in USDT transfers per day, 3x times more than Ethereum’s stablecoin volume, and even surpasses PayPal’s and Stripe’s daily volumes. It has 318 million+ accounts on-chain, largely thanks to exchanges, wallets, and P2P markets integrating USDT for users that just want cheap transactions.

Yet if you ask the average user sending USDT on Binance or a wallet, they might not know what Tron is – they just pick the network with the lowest fee. Tron’s story foreshadows how a purpose-built stablecoin L1 could capture huge volumes behind the scenes.

The users are not Tron fans: they’re Binance or Huobi or CashApp users who unknowingly ride Tron rails because it’s the path of least resistance. Stablecoin L1s want to replicate this dynamic across even broader domains (commerce, remittances, finance) to be the invisible highway underneath the apps.

Failure of XRP

Ripple was among the first crypto companies to align with regulators and even secured a seat on the ISO 20022 standards body. On paper, it looked perfectly positioned to become the institutional settlement ledger. Yet despite that head start, XRP failed to capture meaningful institutional liquidity. Why?

• Because it pushed XRP as a currency rather than neutral infrastructure, forcing banks to take balance-sheet risk on a volatile token.

• Its validator set remained relatively centralized, offering little beyond serving as a proprietary payments rail.

• Ripple often promoted its own standards in opposition to SWIFT, rather than integrating with it, and even paid intermediaries like MoneyGram to simulate adoption instead of driving organic use.

The result: despite early compliance and a strong narrative, XRP’s strategy alienated both banks and developers, showing that regulation alone isn’t enough, real institutional rails require openness, interoperability, and neutrality.

Extension

This is Part I of this research. In Part II, we will cover how exactly stablecoin chains (stablechains) can succeed and how a stablecoin network can become a super-app.

• Hazeflow is a blockchain & crypto research firm focused on underlying technologies, product approaches, and functions of blockchain products.

• Written by Nitin Jakhar, reviewed & edited by Pavel Paramonov.

1. SP1 Turbo: adoption + cost efficiency.

2. SP1 Hypercube: next-gen cost leader.

3. R0VM: smaller proofs + quantum safety, but more expensive.

Most people view proof generation as some kind of dark forest and rarely see any differences between different zk projects. However, key questions that we should answer are:

• how much does it cost?

• how much time does it take? • what are hardware requirements?

• what are the proof sizes?

• what are the next steps for proof generation?

1. zkVMs are competing with each others.

We will take 3 core zkVMs (virtual machines that can create zk proofs):

• SP1 Turbo (by Succinct)

• SP1 Hypercube (by Succinct)

• R0VM (by RISC Zero)

Let’s take a look at high level overview at the moment:

Looking at the sheet, we can already define multiple interesting outcomes:

• ISA stands for Instruction Set Architecture, every zkVM is using the same RISC-V (not to be confused with RISC Zero, that’s different).

• Every zkVM has the same verification time a.k.a. time needed to verify the proof.

• Every system has small amount of active clusters.

• However, proof sizes for Succinct zkVMs are 3x larger than what RISC Zero generates.

What does the proof size mean? Well, it actually means how much proof takes data. Larger proofs are not necessarily more difficult to generate, but it enquires higher costs to do so. Proofs by R0VM are lighter (smaller) and they’re more efficient for L1 verification. However, it wouldn’t be that obvious without more data backed to it.

Let’s take a look at the sheet that outlines what does it take to generate a proof (within different clusters).

2. What it takes to generate some proofs?

Here the situation varies a lot from prover to prover.

ZkCloud can be considered as a prover for rich people. It is obviously the fastest (only 43.3s), however you have to be rich to afford it.

• ZkCloud has the highest cost per proof: $0.4 on average (20x more than SP1 Hypercube).

• You need 48 GPUs with 1152 GB of VRAM (most modern PC builds have around 8-16 GB of VRAM).

• You need 2352 CPU cores (most modern CPUs have around 6-8 cores).

• You need 9216 GB of RAM (most modern PC builds have around 16-64 GB of RAM).

But, you get the fastest proving time for most spent money. With Marlin Protocol, Cysic, and Snarkify - it’s different.

• You still need to use really good hardware (because proof generation is complex process), but it’s significantly less compared to ZkCloud.

• All 3 provers have similar proof generation time and simlilar costs to do so, however, Snarkify required less hardware, generates proofs faster for cheaper price.

Hypercube is current leading the field in price to quality ratio.

• It’s the cheapest way to generate proofs (only 2 cents).

• You only need 1 GPU and 32 cores CPU.

• The only downside is that you need 1 TB of RAM. Hypercube generates proof twice as fast as provers from SP1 Turbo Cluster while it costs significantly less.

Fermah is currently showing the worst time with almost 19 minutes.

3. Direct comparison (Succinct vs. RISC Zero)

We can confidently say that Succinct’s zkVM has broader ecosystem traction (at present). 4 out of 10 clusters are using Succinct according to ethproofs.org.

• SP1 Turbo is the workhorse: most widely deployed, open source, dual license, with 3 active clusters. Proofs take ~3–4 minutes and cost ~$0.04–0.10.

• SP1 Hypercube is the newer generation. It delivers significant gains: proofs as low as $0.02 and ~2 minutes latency. However, it’s closed source and only 1 cluster is active.

• R0VM shines in proof size and quantum resistance. ZkCloud’s cluster can deliver sub-minute proofs, but at very high infra costs.

Succinct is used in: Katana, Celestia (Blobstream), Sophon, Plume Network, +15 more, mainly seen across new zk infrastructure and L2 ecosystems with a TVS (Total Value Secured) of : $3.14B (6.62%).

RISC Zero is used in: Bob Network and Taiko Alethia, there are fewer integrations but R0 is particularly strong in Ethereum zk rollup ecosystem with TVS of: $239M (3.57%).

Summary

We are considering whether burning or redistributing assets is better for a system to remain healthy with aligned incentives.

• When slashing is the initial stage of punishing malicious behavior, redistributing the assets is usually a more efficient option than simply burning them.

• When burning is a core feature of the design and slashing is not involved (such as with deflationary economics), there is no reason to implement redistribution.

• When redistribution is a core feature of the design but seems more like a bug, there is no reason to replace it with burning, changes must be made at the foundational level.

Definitions

A lot of people seem confused and assume that when something gets slashed, the slashed stake is automatically burned and the supply is reduced. That’s not true.

Slashing describes that assets are “taken away” from someone who is acting maliciously, while burning and redistribution describe what happens with the assets themselves after the assets have been taken away.

As we said before, they can either get burned or be redistributed: one action reduces the total supply, while the other one redirects value to another party (not always a hurt one). Burning can also happen without slashing due to the in-built mechanism design of the protocol.

Redistribution Contributing to Economic Security

Let’s take one of the most well-known protocols in crypto today—EigenCloud. Here, operators get slashed for failing to fulfill their obligations, which is a good thing: bad guys receive bad treatment. However, before the introduction of redistribution of slashed funds, those funds were permanently burned (and can still be burned today).

We believe that burning slashed funds in such a system is like shooting yourself in both legs. When an operator’s stake is slashed, the operator gets punished (which happens for a reason), but:

• Affected parties receive no compensation after they’re hurt (imagine you were hit by a car, the driver was imprisoned and punished, but you received no assistance).

• The system becomes less secure (because now there are fewer assets securing the system).

So why should we burn the value and shoot ourselves in both legs when we can keep this value and route it to harmed parties? Reliable parties can increase the amount of rewards they receive, harmed users can be compensated, and value stays in the ecosystem; it’s just redirected. It can unlock a bunch of use cases for apps.

• New types of on-chain insurance protocols that may work correctly in a permissionless way.

• Faster, guaranteed DEX trades compensating traders if their request failed, expired, or wasn’t filled on time. More incentives for operators to operate honestly and transparently.

• Protect lenders with guaranteed APR, more transparency, and a potential for native fixed rates.

Economic security can directly contribute to safeguarding users after an incident, not only before it as with a burning mechanism. Redistribution is already implemented in protocols like Cap, where slashed operators’ funds are redistributed to affected holders of cUSD.

It does not come without its downsides.

Burning assets is easier than redistributing because you don’t have to care what happens with the assets afterward; they’re simply burned, benefiting no one. There are fewer upsides and significantly fewer risks as well. With redistribution, the game changes drastically, and implementation (slashed from a bad guy → redistributed to a harmed party) is not as straightforward as it seems.

Malicious operators can now join forces with a malicious AVS. Currently, an AVS can implement any custom slashing logic it wants, even if it’s not fair or objective. With slashing, it doesn’t make much sense for an AVS to act maliciously, because operators won’t commit their stake if they know they may be slashed for no objective reason.

With redistribution, an AVS can drain one operator’s stake to a malicious one (they work together) to basically extract value from the system. The same thing happens if AVS keys are compromised, which can also affect the overall “attractiveness” of operators or AVSs.

Here, an additional evaluation of mechanism design is needed. Operators shouldn’t have a “switch type” option after they’re created. Instead, there should be a method to identify compromised (malicious) operators and re-redistribute value if it ended up in their hands, as well as constant monitoring, etc.

While burning funds would be much easier, redistribution is more fair, but it requires an additional level of complexity.

Fixing Bad Redistribution

Maximal Extractable Value (MEV) can be seen from a perspective where harmless users and LPs get slashed for no reason. When users want to swap assets, they can be either front-run or sandwiched, resulting in a worse output (prices).

We can confidently say that they’re getting slashed because they commit a stake (assets to swap) to the system (DEX), hold it for a certain period of time (swapping time), and end up receiving significantly less than they should.

There are two core problems here:

• LPs get slashed for no reason (they didn’t act maliciously).

• Users get slashed for no reason; they didn’t act maliciously and weren’t even intending to earn something or act well for the system, they just wanted their action to be performed.

Here, value is extracted and redistributed in a way that exploiters are rewarded, while parties that have done nothing wrong get slashed.

• This problem is easier to fix for users by having certain sequencing rules (like Arbitrum Boost).

• This problem is more complex for LPs, because they’re usually victims of LVR (loss-versus-rebalancing).

Can this be fixed with burning?

Burning can provide diffuse benefits to all token holders without specifically compensating those LPs who incurred direct losses from arbitrage activities. It could technically be fixed by burning, which would leave no incentive for arbitrage once the profit is burned.

However, once arbitrage profit is extracted, it’s significantly more difficult to identify such arbitrage: while on-chain trades are visible, CEX data doesn’t show the exact addresses of traders.

Poor redistribution design in this case can be fixed with app-specific sequencing, where LPs can capture value that would otherwise be lost to exploiters. This is one of the solutions implemented by Angstrom, and it is performing quite well.

In this particular MEV case, neither redistribution nor burning is a viable option; they only treat the symptoms, not the cause. Changes must be made at the foundational level.

Where Burning Might Be Better Than Redistribution

We want to outline that redistribution isn’t a magical pill that can always replace burning. When slashing (the first stage) isn’t involved, in most cases, burning funds is a key feature of a mechanism’s design.

We can take BNB as an example, where BNB tokens are burned quarterly, and it’s a core feature of this deflationary tokenomics model. Here, redistribution cannot be implemented because this is a process where neither exploiters nor harmed users are involved.

A similar process occurs in ETH’s design (EIP-1559), where base fees are burned, creating a deflationary effect. Considering Ethereum’s mechanism design, the fees can become very high during network congestion, and someone might argue that instead of burning, base fees could be redirected to a treasury fund that compensates for a portion of the fees during network congestion. However, there are more downsides than potential upsides:

• Redistributing fees may dilute the deflationary effect and lead to higher inflation and potentially depressing token value over time.

• Misallocation of funding and less revenue (how should the fund prioritize which transactions to sponsor? Does it make sense for a user to pay a priority fee when it can be compensated by funding? etc.).

• It might be easier to spam and create even more congestion if you know your fees will be sponsored.

• Hypothetical redistribution of Ethereum’s base fees to stakers could incentivize validators to prioritize high-fee transactions and ignore those that weren’t sponsored or paid in advance.

There are a bunch of other cases out there, but the main point is that redistribution is not a panacea. If burning happens on its own (without prior slashing), there is almost no reason to replace it with redistribution.

So?

Ultimately, we want to point out that redistribution usually performs worse than burning in cases where prior slashing isn’t involved, while in scenarios where slashing is involved, redistribution usually plays a better role than burning.

The problem of incentive alignment is a persistent issue in crypto and typically changes from one protocol to another. If the economic value directly contributes to the security or another crucial factor of the system, it would be better not to destroy this value, but to find a way to correctly redistribute it to those who act honestly, which incentivizes fairness and honest behavior.

• Hazeflow is a blockchain research firm with experience in research, analytics, and the creation of technical, product, and educational materials.

• We work with blockchain teams (especially complex-tech ones) who struggle to clearly and meaningfully explain their complex product.

1. What is SP1?

• SP1 zkVM stands for "Succinct Processor 1 Zero-Knowledge Virtual Machine."

• Think of it as a special computer that not only runs your program but also creates mathematical proof that it ran correctly.

2. Before SP1:

• Want a ZK proof? Write complex cryptographic circuits manually (like doing calculus by hand)

• Want to verify someone's computation? Re-run their entire program yourself (slow & expensive)

• No trust without verification: either trust blindly or waste resources re-computing

3. After SP1:

• Just write normal code, SP1 handles the cryptography

• Get mathematical proof of correctness, no need for others to re-run anything

• Verify proofs in milliseconds instead of re-running hours/days of computation

• Enables any developer to create real-world ZKP applications by writing code in Rust

• Makes ZK accessible to regular developers, not just cryptography PhDs

4. How SP1 Works

• Write code in Rust → compiles it into RISC-V instructions

• Program Table is created → a fixed recipe of all instructions

• Execution Phase → CPU runs the program step by step, checking each instruction with special tables (ADD, MUL, memory, etc.)

• Proof Generation → all tables are turned into math constraints to build a STARK proof that the execution was valid.

• Final Compression → for long programs, proofs are combined and compressed into a tiny SNARK proof that blockchains can verify.

5. Key Innovations

• Lookup-centric architecture: Tables specialize and cross-verify each other

• Precompiles: 10-50x speedup for crypto operations (Ethereum blocks: 10B cycles → 200M cycles)

• Efficient recursion: Combines multiple proofs into one final proof

• STARK to SNARK: Compresses large proofs (STARK) into tiny ones (SNARK) Ethereum can verify

6. Use Cases

• ZK Rollups: Turn optimistic rollups into zk rollups with faster withdrawals (~1 hour vs 7 days).

• ZK Light Clients: Build blockchain bridges that rely on proofs of consensus, not multisigs.

• DeFi Solvency Proofs: Exchanges prove assets ≥ liabilities without revealing balances.

• Identity Proofs: Prove properties like “over 18” without sharing private data.

• General Compute: Off-chain tasks, machine learning inference, or data validation with zk proofs.

7. Live Use Cases

• OP Succinct, built on SP1 zkVM, cuts Optimistic Rollup finality from 7 days to ~1 hour.

• Mantle is the first OP Stack L2 to launch as a ZK Validity Rollup with 1-hour finality, 12-hour withdrawals.

Part II. Difference between SP1 and SPN.

1. What is Succinct Prover Network (SPN)?

• A decentralized network that proves software using zk proofs.

• Think of it as a marketplace: apps (like rollups, bridges, AI agents) need proofs — Provers (people with GPUs, data centers, or even home hardware) generate those proofs.

2. What's the actualy difference between SP1 and SPN?

• SP1 solves the software side of proving: you write normal Rust code, it compiles to RISC-V, and SP1 produces the ZK proof.

• Running SP1 on your laptop would be slow and costly.

• For that, there is Succinct Prover Network solves this by coordinating a global cluster of provers, datacenters, GPU farms, and even home GPUs, to deliver proofs faster and cheaper.

3. Actors Involved

• Requesters: rollups, blockchains, bridges, AI agents, games

• Provers: teams with GPUs, servers, or specialized hardware to generate proofs

• Delegators: Regular users who don’t run hardware but can stake their $PROVE

• Auctioneer: service that coordinates requests and provers

• Ethereum settlement contracts: hold all funds, check the Auctioneer’s proofs, pay out provers and delegators, and slash provers if they fail.

4. System Workflow

• A requester deposits $PROVE on Ethereum and submits a proof request.

• The Auctioneer runs an auction among provers.

• Provers place bids.

• The winning prover runs SP1 zkVM and generates the proof.

• The proof is sent to the Auctioneer, which records it in its database.

• The Auctioneer proves its database state with SP1 and posts that proof to Ethereum.

• Ethereum verifies the update and pays the prover (and any delegators who backed them).

Status today (Stage 2.5 testnet): reverse auction system (the lowest bid wins).

5. What Changes at Mainnet

• PROVE goes live → payments, staking, and slashing have real economic weight.

• Proof contests (probabilistic inclusion) → instead of one winner, several provers can submit.

• Delegation opens fully → anyone can back a prover, helping them qualify for jobs and earning part of the rewards.

• Bigger scale → Data centers, ASIC/FPGA teams, and proving pools of home GPUs join, making SPN the largest proving cluster in the world.

To illustrate this concept, we'll consider Boundless as a global courier company.

Boundless can be best understood as a global delivery marketplace, just instead of shipping boxes, it handles any type of zk computations.

• Customers are developers or applications that need jobs completed.

• Couriers are provers with the hardware to do the heavy lifting.

• Central hub is a smart contract system that makes sure every package (computation) is delivered on time, couriers are paid fairly, and cheaters are punished.

1. The Marketplace Floor

Think of a busy market square:

1. Customers (Users/Requestors) walk in with jobs: "I need this package delivered, here’s the destination, here’s my budget, and I’ll lock some money up front."

2. They post these requests on the Marketplace Board (Marketplace Contract).

3. Couriers (Provers) gather around the board. A job is announced through a Dutch Reverse Auction: instead of prices going down like eBay, they go up over time.

4. Early birds can grab it cheap, but wait too long and the price gets more attractive, drawing in competition.

5. When a courier accepts, they also leave a security deposit at the counter(staking ZKC). This proves they’re serious. If they flake, they lose that deposit.

6. Once locked, the courier takes the package (the zk program + inputs) back to their truck (hardware).

7. They run the delivery route (zkVM computation or a mathematical calculator that can’t lie) and return with a sealed envelope (proof) that shows the package was delivered exactly as requested, no tampering.

Back at the hub:

• Verifier (RISC Zero, instant double-check machine) double-checks the seal in seconds.

• If it’s valid, the courier gets paid, their deposit is returned, and the customer receives their verified delivery.

2. What if the courier fails?

Now, imagine one courier grabbed a package but never delivered it. The hub can’t let customers down. Here’s what happens:

• The courier’s loses their security bond (slashing): part goes to the hub’s treasury, and part is set aside as a bonus for whoever rescues the job.

• The job is reposted on the board, but this time no exclusive reservations, any courier can race to deliver it.

This retry mode creates urgency. Other couriers see not just the original payment but also a chunk of the failed courier’s deposit. Suddenly the job is extra rewarding, so someone quickly picks it up and delivers.

This ensures the market keeps moving. Even bad actors can’t jam it up: at worst, they just pay a fine.

3. How can we support the market long-term?

Behind the bustling square is a vault where investors and couriers can deposit the marketplace’s token (ZKC). Here’s how it works:

1. When you lock ZKC in the vault, you earn non-transferable points, like loyalty stamps.

2. Over time, as the market collects fees from every delivery, vault participants can burn their points to withdraw a proportional share of the earnings or unlock their tokens.

3. Couriers can also stake here. Their locked tokens not only earn points but can also double as the security deposits needed when they accept jobs.

This system makes sure both workers (couriers) and supporters (investors) share in the success of the marketplace. The busier the market, the more rewards flow back.

4. Boundless as a global courier company.

Through this analogy, Boundless becomes easier to picture:

• Marketplace Contract is the town square’s job board.

• Reverse auctions are the way jobs are priced fairly.

• Couriers (Provers) do the heavy lifting, backed by deposits.

• Proofs are sealed envelopes: easy to check, impossible to fake.

• Slashing and retry keep deliveries reliable.

• Vault + Points system keeps long-term supporters and couriers invested.

All of this is powered by cryptography under the hood, but to users and developers, it feels like a self-regulating, always-on gig economy. The only difference is that instead of moving boxes, it’s providing computations for blockchains.

5. Applications on Boundless.

Boundless converts light clients into zk stateless clients to become more secure and trustless by outsourcing their verification work to the network of provers. These clients can verify multiple chain states in parallel and broadcast the results globally through the Boundless Signal, effectively acting as a universal light client for all chains.

This architecture unlocks new kinds of deliveries across the blockchain world.

• For cross-chain communication, the Signal works like a global noticeboard where every delivery is stamped and posted.

• Instead of sending messengers you have to trust (bridges, multisigs, custodians), any chain can simply check the board and see a certified receipt that another chain’s package arrived.

• For developers, Steel is like renting a private workshop inside the courier network. You hand over raw materials, it builds the product off-site, and what comes back is a sealed report (zk proof) that anyone can trust without re-doing the work.

In this way, Boundless transforms computation into a shared courier economy, packages move faster, receipts can be trusted by anyone, and every stop in the network becomes part of a verifiable delivery system.

1. However, interoperability has remained an unsolved challenge.

As more rollups launch, more users, apps, and liquidity are split across isolated environments. Instead of one big Ethereum network, we get dozens of small islands. Bridges connect them, but they add latency, risk, and friction.

This fragmentation is made worse by the fact that every rollup today runs its own centralized sequencer, the system that decides the order of transactions in a block, who gets in first, and also who captures profits from MEV.

Because each sequencer operates independently, rollups run on different timelines. Apps on separate rollups can’t interact atomically, in the same block at the same time, which fractures liquidity and weakens composability.

2. Centralized sequencers made sense early on.

They allowed teams to launch quickly by spinning up a server, reduced front-running through private orderflow, provided near-instant pre-confirmations for smooth UX, and offered operational flexibility. But these benefits came with trade-offs.

• Sequencer downtime has taken entire rollups offline for hours.

• A compromised sequencer could reorder transactions and drain millions.

• They can’t scale in a neutral, decentralized way and causes a fragmentation problem.

When you add it all up, centralized sequencers were a useful starting point, but they can’t take rollups where they need to go.

3. The next step is based rollups.

Instead of operating its own sequencer, a based rollup uses Layer 1 (Ethereum, Celestia) validators for sequencing (ordering transactions). That’s why it’s called "based": its sequencing is tied directly to the base layer.

This shift restores neutrality. No individual rollup team controls the flow of transactions. All rollups that are “based” share the same Ethereum-wide sequencing layer, meaning they can interact in the same block at the same time.

The result is a unified network:

• Liquidity stays concentrated rather than split across silos.

• Composability is synchronous, so apps on different rollups can interact atomically.

• Control is neutral, secured by Ethereum’s validators rather than a centralized server.

4. Which other problems do based rollups solve?

• DeFi: Liquidity stays unified under Ethereum’s sequencing layer.

  • Trades, loans, and liquidations happen on L2s but share the same base ordering, keeping markets deep and concentrated instead of splintered or lost to Solana.

• Users: Rollup boundaries fade away.

  • With shared deposit contracts and native L2-to-L2 transfers, assets move seamlessly across rollups — no need to route back through L1 or worry about “which chain” you’re on.

• Developers: Composability returns.

  • Apps on different rollups can interact atomically in the same block, enabling cross-rollup lending, trading, and complex strategies that centralized sequencers can’t support.

5. Aren't shared sequencers doing the same?

Those 2 approaches solve fragmentation at very different scales.

Rollup stacks like Arbitrum Orbit, Optimism Superchain, and zkSync Elastic Chain are experimenting with shared sequencers that act as mini-hubs. So liquidity and users remain trapped inside that ecosystem cluster, rather than being shared across Ethereum as a whole.

Based rollups go further. Instead of ecosystem-level hubs, they use Ethereum itself as the universal sequencer. That means, liquidity pools merge across all rollups. Shared sequencers reduce fragmentation locally, while based rollups solve it globally across the entire Ethereum network.

6. Ethereum basically became a sequencer, but how?

For most of its history, Ethereum could only sequence its own transactions. Validators gathered transactions from the mempool, ordered them, and built blocks. If every rollup had dumped its transactions directly into that process, the result would have been chaos: conflicts, wasted blockspace, and failed transactions.

The breakthrough came with Proposer–Builder Separation (PBS).

Before PBS: Validators had to do everything, collect transactions, order them, and build the block. Adding rollup traffic would have been overwhelming.

With PBS: The work is split.

• Validators (proposers) simply sign blocks, while specialized builders do the heavy lifting.

• Builders gather transactions (from Ethereum and based rollups), order them, and produce complete blocks.

• Validators only sign the header of the most valuable block, without even needing to see its contents.

From the validator’s perspective, nothing changed, but in practice, Ethereum became the neutral sequencer for every based rollup.

7. But who captures MEV in "based world"?

MEV, the profit from ordering transactions, that once flowed to a centralized sequencer now goes into Ethereum’s PBS pipeline. Builders assemble profitable blocks, validators sign them, and the MEV is captured there, not by the rollup team.

However, MEV doesn’t always stay with validators and builders. Other parts of the stack can capture it directly:

• MEV-aware DEXs like CoWSwap or Uniswap v4 auction off arbitrage opportunities and return profits to liquidity providers.

• Tools like MetaMask Protect or Rabby route transactions privately to builders, shielding users from front-running and sometimes redistributing part of the MEV.

These mechanisms reduce harmful arbitrage, but MEV doesn’t disappear, it simply changes hands and form.

8. With new type of rollup, comes a new type of economics.

This shift reframes the economics for rollups. Many hesitate to go “based” today because they capture MEV revenue through their centralized sequencers, front-running swaps or arbitraging prices across venues. But in the long run, the more durable revenue stream is execution fees, the toll users pay to run transactions on the rollup’s virtual machine. Let's show a hypothetical example:

Rollup with its own sequencer (today):

• Execution fees = $2M/month

• MEV = $1M/month

• Total = $3M/month

Same rollup as a based rollup (future):

• MEV → Ethereum validators = $0

• Execution fees (from unified network effects) = $10M/month

• Total = $10M/month

That’s the MEV Gambit: sacrifice the pawn (sequencer MEV) to win the bigger prize (much higher execution revenue). Based rollups avoid fighting over MEV and instead focus on scaling their execution layer.

9. Can Ethereum handle this capacity?

The obvious question is: if every rollup plugs into Ethereum as its sequencer, can Ethereum L1 actually handle it?

Right now, Ethereum runs on 12-second slots. Slot time is the real constraint. With 12-second slots, the UX feels slow. Research shows Ethereum could likely cut this to ~4 seconds without sacrificing decentralization, validators can still run on home internet or even Raspberry Pi.

Trustless pre-confirmations are key for Ethereum to compete with centralized sequencers on speed. This system uses proposers who stake collateral and sign guarantees to include transactions, which can result in ~100 ms confirmations.

This is significantly faster than the current block times and even faster than some "superchain" setups, providing speeds similar to internet latency.

10. However, this heavy workload is too much for home validators.

APS (Attester Proposer Separation) splits the work to solve this: attesters verify and publish valid transactions, while proposers/builders construct blocks and manage pre-confirmations.

Initially, this is done through gateways, but eventually, APS and enshrined PBS will enable Ethereum to natively provide fast, trustless pre-confirmations and shared sequencing.

11. Fabric: Building the Standards.

Even with APS and PBS in place, there’s still the question of plumbing. Every based rollup team today has to reinvent APIs for pre-confs, tweak PBS pipelines, set up registries, and handle blob sharing. Left unchecked, this risks fragmenting into incompatible “mini standards.”

Fabric Ethereum is the coordination effort to prevent that. It doesn’t launch a rollup or token. Instead, it delivers minimal open-source components, including:

• Commitments API for pre-confs

• Universal Registry Contract for sequencer accountability

• Shared blob and bridging infrastructure

Backed by teams like Taiko, Scroll, Optimism, Arbitrum, Base, Spire Labs, and more, Fabric is emerging as the schelling point for based rollup infrastructure — aligning teams on shared standards so the ecosystem scales together, not apart.

• Hazeflow is a blockchain research firm with experience in research, analytics, and the creation of technical, product, and educational materials.

• We work with blockchain teams (especially complex-tech ones) who struggle to clearly and meaningfully explain their complex product.

A lot of people keep asking us how exactly we work with blockchain protocols to properly explain their complex product and value proposition, so we decided to release one of our key studies to the public.

We’ve been partnering with Phala Network for multiple months and have achieved some great results. Of course, that wouldn’t be possible without the transparency that we are always aiming for and the openness from the Phala team to work together.

Beginning

At the beginning of our collaboration, we identified several things:

• Phala is a complex protocol with many features and a well-thought-out mechanism design.

• It has interesting features that most people, even those who are crypto-native, have never heard of.

• Phala also has multiple strong value propositions for developers outside of web3.

• As the most advanced protocol using Trusted Execution Environments (TEEs), some of its benefits are not widely known.

• And many other things.

First and foremost, we are researchers, not marketers, so we always take a research-driven approach. The main goal is not to get a lot of general views, but to get views from people who might actually find what Phala is doing useful and helpful for their work.

Strategy

We’re obsessed with execution and getting things done. But first, we created a strategy that aligns with the main roadmap and vision of the Phala team, where the aim is not to take the spotlight, but to act in accordance with a global roadmap. The key things we wanted to do are:

• Differentiate Phala from other TEE-based solutions and position it as a main competitor to AWS.

• Maintain a user-friendly style while delving deeply into the technology, highlighting how specific technical details benefit the product and its users.

• Position Phala as a thought leader in the TEE space. Currently, almost no one in the TEE space discusses the broader space in depth; they focus solely on their own solutions.

• Phala Network is not a single solution but an ecosystem; the discussion should cover TEEs and their nuances with a deep understanding of various scenarios.

• The primary goal is to establish Phala as the leader in the TEE space, not only by delivering an excellent product but also by explaining the key decisions behind its design and how the broader ecosystem will benefit from it.

• Keep the discussion deep yet accessible. TEEs should appeal not only to high-profile individuals but also to a broader audience.

• Besides the main points to keep in mind, we created a plan of precise topics and ideas (explained later in this writing) to ensure smooth transitions between our pieces of deep content.

Let’s go into what we created and why in more depth.

1. Phala as an improved version of AWS

We have researched and found that there is a very fast-growing demand for secure and private computing solutions, mainly because of the approximately 402 million terabytes of sensitive data generated daily.

Despite AWS holding 30% of the global cloud compute market, it still faces many challenges due to its centralized architecture, complex setup, lack of memory encryption, and limited support for decentralized applications.

We found that Phala's features directly address the downsides of AWS, so we proposed a unique approach: positioning Phala as an improved, decentralized TEE cloud that serves as a great alternative to AWS.

Therefore, we researched, wrote an article on this, and designed a few diagrams to complement it.

This piece allowed Phala to take a new, strong position and provide value to the global community by explaining the state of cloud computing.

The article is available here.

2. TEE is not competing with other encryption technologies.

There have been countless articles written comparing TEE, MPC, FHE, and ZKPs. All of these are encryption techniques, and 100% of people who have written about them have compared them, saying that TEE is better than MPC, MPC is better than FHE, and vice versa.

However, together with the Phala team, we wanted to push the narrative that these solutions are not mutually exclusive. This means you can use multiple solutions together at once: your foundation could be MPC, but you could still leverage TEE’s strengths; or your foundation could be FHE, but you could still leverage TEE, etc.

We created a long-form article that allowed Phala to take a collaborative approach with other technologies instead of competing with them. Rather than claiming to be the best, we took the approach of saying, “Everyone has their strengths that can work seamlessly together.”

There hadn't been a single article on this topic before. The article itself is available here.

3. Deep dive into GPU TEEs

Most users and ecosystem stakeholders are only aware of CPU TEEs, where computations happen inside a processor. Phala has had GPU TEEs for a long time; however, it seemed like they were hiding them. We were really shocked at how cool they are and why this hadn't been covered yet.

So, it was a no-brainer to let people know not only that GPU TEEs exist, but also to explain how they function and why they're needed. With that article, we started a shift more towards a crypto-AI theme, highlighting another of Phala’s products — Redpill.

The article is available here.

4. What Does It Take to Build Safe AGI?

Here, we discuss the need for a safe Artificial General Intelligence (AGI), emphasizing the engineering, governance, and safety infrastructure required to deploy AGI systems securely. AGI is defined as an AI capable of human-expert performance across diverse cognitive domains, with the potential to evolve into Artificial Superintelligence (ASI) through recursive self-improvement.

As we shift into AI and AGI, Phala is presented as a decentralized confidential computing platform that supports Safe AGI through its Phala Cloud, Dstack SDK, Private ML SDK, and Redpill Gateway. All of these tools enable secure, verifiable AI execution in GPU TEEs, ensuring confidentiality, integrity, and attestation for workloads like LLMs.

The article itself is available here.

5. The State of Confidential AI in 2025: Who Wins and Who Loses

We decided to release this article on our research blog, where we discuss the current landscape of confidential AI in depth, highlighting Phala’s improvements.

The article discusses the critical need for Confidential AI to secure sensitive data during processing, particularly when AI decrypts data for inference, making it vulnerable to malware, hackers, or exposure on public blockchains.

This vulnerability is especially pronounced in decentralized systems where data is replicated across nodes. We highlighted Phala as a GPU TEE cloud that combines runtime privacy with ZK/MPC proofs and was actually the first to benchmark LLM inference in secure enclaves of TEE.

The article is available here.

Moving Forward

That’s just one of the examples of how we help protocols explain their true value proposition and complex products.

We deeply believe that most things in this industry need to be simplified or properly explained. There have been countless examples of users visiting a protocol's website, blog, or technical documentation and, after 15–20 minutes of reading, still having no idea what the protocol does.

That is one of the issues we are working on, and we are proud to be doing so with Phala Network.

We are always looking to work with talented teams and long-term builders who share our research-driven approach. We are big fans of execution and always make sure that our efforts contribute to the global goal of a particular company.

• Hazeflow is a blockchain research firm with experience in research, analytics, and the creation of technical, product, and educational materials.

• We work with blockchain teams (especially complex-tech ones) who struggle to clearly and meaningfully explain their complex product.

Thanks to L2Beat team for the valuable data; all figures and insights referenced in this blog post are sourced from their platform.

Ethereum’s growth over the past decade has been shaped by a simple promise: scale the network without compromising decentralization. The answer, according to its roadmap, is a rollup-centric future, where Layer 2 networks (L2s or “rollups”) execute transactions off-chain to achieve lower costs and higher throughput, while still deriving core security guarantees from Ethereum as the base layer (Layer 1).

Nearly every major rollup, Arbitrum, Optimism, Base, zkSync, and Scroll, brands itself as “secured by Ethereum.” The phrase is powerful and the centerpiece of their marketing narrative, but does it match reality? Once you look closely at how rollups actually work and how assets flow into them, the claim becomes blurry.

This article unpacks the gap between slogan and reality, beginning with bridges (where users’ money sits), moving to sequencers (who orders transactions), and ending with governance (who sets the rules).

The Rollup Bridge Reality

The claim that rollups are “secured by Ethereum” glosses over how users actually interact with these systems.

To use a rollup, whether for DeFi, payments, or apps, you first need your assets to exist on it. Ethereum has no built-in way to move assets directly in or out; you cannot simply teleport ETH into a rollup. That requires a bridge. Bridges are the entry and exit points between Ethereum and rollups, and they define the security users actually experience.

How Bridges Work

Deposits

When you deposit ETH into a rollup, you send it to a bridge contract on Ethereum. That contract locks your ETH and tells the rollup to create the same amount in your L2 wallet. For example, if you deposit 1 ETH, the bridge holds your 1 ETH safely on Ethereum, and your rollup account shows 1 ETH. Because Ethereum keeps the locked ETH, the deposit is trust-minimized.

Withdrawals

Withdrawals are where things get complicated. To exit, the process reverses:

1. You burn (or lock) tokens on the rollup.

2. You send a message to the Ethereum bridge contract: I burned tokens on L2, release my locked ETH.

3. Here’s the catch: Ethereum cannot see what happened inside the rollup. It is blind to L2 computation.

So Ethereum will only release your funds if the bridge provides proof that the withdrawal is legitimate. That proof could be:

• Fraud proofs (optimistic): Assume valid unless challenged within a dispute window.

• Validity proofs (zk): A cryptographic proof shows up front that all transactions followed the rules, so Ethereum can trust the result immediately.

• Multisigs or committees: Rely on trusted parties to attest.

The bridge defines how you access the rollup. Think of it like a window into a house. The house (the rollup) keeps standing even if the window (the bridge) breaks. But if the window shatters, you can’t safely get in or out anymore. In the same way, a broken bridge cuts users off, even though the rollup machine itself continues running.

This is why the bridge layer is the true lens of rollup security. Whether assets are really “secured by Ethereum” comes down not to the rollup itself, but to which bridge you use and what trust model it relies on.

Bridge Models and Their Assumptions

• Canonical bridges (the “official” per-rollup bridges). These are tied into Ethereum. When you lock assets here, Ethereum validators guarantee you can eventually withdraw back to L1, even if the L2 halts. Canonical bridges are the only bridges that directly inherit Ethereum’s security properties.

• External bridges (e.g., Wormhole, LayerZero, Axelar). These accelerate UX with fast, chain-to-chain transfers, but depend on their own validator committees or multisigs. They are not enforced by Ethereum consensus. If those off-chain operators are hacked or collude, users can lose funds even while Ethereum works perfectly.

• Native issuance (tokens minted directly on the rollup). Examples include USDC on Base or OP on Optimism. These assets never pass through a canonical bridge and cannot be redeemed on L1. Their guarantees come from the rollup’s governance and infrastructure, not from Ethereum.

Where Do Rollup Assets Actually Live?

As of August 29, 2025, Ethereum rollups collectively secure about $43.96 billion in assets. The breakdown is:

• Externally bridged: $16.95B (39%) - Largest category

• Canonically bridged: $14.81B (34%) - Ethereum-secured assets

• Natively minted: $12.20B (27%) - Rollup-native assets

Trends Over Time

Looking back to 2019–2022, canonical bridging was the overwhelming driver of rollup adoption. Almost all early growth came through official bridges that kept Ethereum at the center.

From late 2023 onward, however, the picture began to change:

• Canonical continued to grow in absolute terms, peaking during 2024, but its share started to shrink.

• Native issuance expanded steadily, especially in 2024–2025.

• External bridges accelerated the most sharply from late 2023 onward, and by early 2025, they overtook canonical bridges, the crossover point when Ethereum lost the majority share of rollup assets.

• Today, two-thirds of rollup assets (external + native) sit outside Ethereum’s direct security perimeter.

Rollup-Level Breakdown

The market is highly concentrated: the top six rollups account for 93.3% of total rollup TVL. Within these ecosystems, the split looks like this:

• Canonical bridges: 32.0%

• Native issuance: 28.8%

• External bridges: 39.2%

Pie-Chart Aggregate Patterns

• External-heavy: Arbitrum and Unichain, users chase fast exits/liquidity via third-party bridges.

• Canonical-leaning: Linea (and to a lesser extent OP Mainnet), more L1-sourced collateral routed through the official bridge.

• Native-leaning: zkSync Era and Base, lots of on-L2 issuance (e.g., native USDC on Base) and direct on-ramps.

Why it matters: Most value in the biggest rollups sits outside Ethereum’s direct guarantees. The security users actually get depends on the bridge model behind each slice.

Beyond Bridges: Other Risks

Bridges explain where assets reside, but even if every asset were canonical, users would still face other trust and safety gaps. Three areas matter most: how transactions are sequenced, who governs the stack, and how composability affects user experience.

1. Sequencers: The Central Point of Control

Sequencing is the process of deciding the order in which transactions are included. Almost the vast majority of the rollups use centralized sequencers. This setup is fast and profitable.

But a centralized sequencer can:

• Censor transactions by simply refusing to include them.

• Block withdrawals indefinitely, since it decides when exits are batched to Ethereum.

• Go offline entirely, halting activity until it returns. (e.g., Arbitrum’s 78-minute downtime)

Ethereum includes “force inclusion” mechanisms that let users submit transactions directly to L1 to bypass the sequencer. But these don’t guarantee fairness. The sequencer still controls block ordering, which is often enough to undermine users.

Here is an example of how a transaction can be included but still fail:

• Imagine you try to withdraw funds from Aave on an L2.

• You submit a force-inclusion withdrawal request on Ethereum, meaning the sequencer cannot ignore it.

• But the sequencer can slip in its own transaction just before yours—for instance, borrowing additional funds from the same pool.

• By the time your withdrawal runs, the pool no longer has enough liquidity, and your withdrawal fails.

• Your transaction was “included,” but its outcome was sabotaged.

Force inclusion also comes with practical nuisances: waiting periods that can stretch for many hours (sometimes 12+), limited throughput, and the risk of reordering even after submission. It acts more like a slow safety valve than a guarantee of fair execution.

Meanwhile, momentum is building for decentralization. Projects like Espresso and Astria are building shared sequencer networks to improve resilience and interoperability.

A key idea here is pre-confirmations: early promises from a sequencer or shared network that a transaction will be included, even before it is finalized on Ethereum. This helps reduce the latency penalties of decentralization, giving users faster assurance without sacrificing neutrality.

Still, centralized sequencers remain dominant because they are simple, profitable, and attractive to institutions—at least until competition or user demand forces change.

2. Governance & Incentive Risks (Corporate L2s)

Who runs the L2 does really matter. Many leading rollups are operated by companies or VC-backed teams (e.g. Base by Coinbase, Arbitrum by Offchain Labs, Optimism by OP Labs).

Their obligations are to shareholders/investors first, not to Ethereum’s social contract.

• Shareholder duty → monetization pressure: Fees start low to attract users, then rise once liquidity and apps are locked in (the classic “platform tax” arc). Expect higher sequencer fees, preferential integrations, or rules that advantage the operator’s broader business.

• Lock-in → leverage: After billions in TVL and users accumulate, switching costs make exit hard. Operators can change economics or policy with limited fear of mass migration.

• Culture mismatch: Ethereum relies on public dev calls, multi-client diversity, and open governance (EIPs). Corporate rollups are more top-down, often with admin keys/multisigs that can pause, upgrade, or freeze—prioritizing compliance or profitability over neutrality. Over time, a rollup can look less like Ethereum and more like a walled garden.

The result is a growing gap between Ethereum’s open ethos and the incentives shaping corporate rollups. And that gap doesn’t just affect governance, it spills over into how applications interact and how users experience the system.

3. Composability & UX

Ethereum’s “magic” is atomic composability: contracts can synchronously read/write in a single transaction (think: a Uniswap swap repaying Aave and triggering a Maker action atomically). L2s fracture this:

• Asynchrony: Cross-rollup messages are delayed, canonical exits can take days, third-party bridges add trust assumptions.

• Silos: Liquidity and state fragment across L2s, degrading the seamless DeFi UX that made Ethereum compelling.

What would fix it?

Ethereum-native rollups (designed and governed to L1 standards) could enable sync reads L2→L1, sync writes L1→L2, and atomic cross-rollup writes, recovering much of L1’s composability while scaling blockspace. Without this, UX keeps drifting toward convenience layers that aren’t Ethereum-secured.

The Future of Rollups

If “secured by Ethereum” is going to mean more than a slogan, the core guarantees need to live on L1, not in off-chain committees or one-company sequencers. Three designs point in that direction.

Native rollups move validity all the way onto Ethereum.

• Instead of asking users to trust a separate fraud-proof system, a zk prover they can’t audit, or a security council, the rollup provides a transaction trace that Ethereum itself can re-execute.

• In practice, this turns withdrawals and state correctness into L1 rights rather than promises: if the rollup says your balance is X, Ethereum can check that claim directly.

• That shrinks the attack surface at the bridge, reduces the need for pause keys, and keeps the rollup aligned with future Ethereum upgrades.

• The trade-off is higher cost on L1, but the payoff is simple: when there’s a dispute, L1 decides.

• There are no native rollups live today.

Based rollups anchor transaction ordering to Ethereum’s validator set.

• Today, a single sequencer can reorder or delay transactions, which is enough to sabotage “force inclusion” in practice.

• With based sequencing, the canonical order comes from L1 consensus, so censorship and last-second reordering get much harder.

• Force inclusion becomes a normal pathway, not a slow safety valve. Projects add “pre-confirmations” to keep UX snappy while still letting L1 be the final arbiter of order.

• You give up some L2 revenue and flexibility, but you remove the biggest single point of control in the current stack.

• Core teams working on based rollup design include Taiko, Spire, and Puffer.

Keystore rollups tackle a quieter but constant source of risk: keys and upgrades.

• Instead of each rollup (and app) handling account recovery, session keys, and rotations on its own, a minimal “keystore” rollup standardizes that logic once and syncs it everywhere.

• Users rotate or recover keys in one place; the change propagates across L2s. Operators need fewer emergency keys; admins need fewer “god-mode” switches.

• The result is fewer compromised wallets, fewer rushed upgrades after an incident, and a much cleaner separation between account security and application logic.

• Keystore rollup design is only theoretical and isn’t live yet.

Together, these approaches line up with the problems users actually face: exits that depend on trust, ordering controlled by one company, and fragile key/upgrade paths.

Moving validity, ordering, and account security under Ethereum’s umbrella is how rollups will earn the phrase “secured by Ethereum,” not just advertise it.

• Hazeflow is a blockchain research firm with experience in research, analytics, and the creation of technical, product, and educational materials.

• We work with blockchain teams (especially complex-tech ones) who struggle to clearly and meaningfully explain their complex product.