In this interview, Espresso co-founder and CEO Ben Fisch elaborated on the project's technological innovations aimed at addressing the fragmentation issues in the Web3 blockchain ecosystem. Espresso aims to facilitate efficient communication between different blockchains by providing high-speed finality and supporting Layer 2 technologies. Ben detailed how the project leverages improvements in consensus mechanisms and innovative technologies, such as erasure coding and zero-knowledge proofs, to reduce cross-chain latency and enhance inter-chain interactions. He also discussed the reasons why Espresso attracts top developers and investors, as well as its future market positioning and token economic model.
The content represents the personal views of the guest and does not reflect the views of Wu Shuo. The audio transcription is done by GPT and may contain errors. Please listen to the full podcast on platforms like Xiaoyuzhou or YT.
Xiaoyuzhou
https://www.xiaoyuzhoufm.com/episodes/693c49472a383da167cdc0db
YouTube:
https://youtu.be/mQ55VBQKwM4
The origin and initial goals of Espresso
Colin: First, can you tell us how Espresso got started and what key projects you saw in the Web3 space? Who are your main investors currently supporting you?
Ben: When we started working on Espresso, we were actually initially focused on solving a different problem than the one we ultimately addressed— privacy. We were trying to create a privacy-preserving protocol specifically for compliant yet private stablecoin payments. In the process of building this new protocol, we realized that it was incredibly challenging to create a system that was both high-performing and could effectively integrate with other parts of the Web3 ecosystem. If we created a new payment chain, for example, as a Layer 2 chain to boost performance, it would be completely isolated from other activities in Web3 where people were using stablecoins and DeFi protocols, making it nearly impossible for our new ecosystem to have liquidity. Thus, during the attempt to build this system, we realized that it was actually a larger problem. So, we decided to address the fundamental issues currently faced by Web3— the existing fragmentation that makes innovation and building new chains difficult. We thought, how can we solve this problem? That was the motivation behind our initial development of Espresso. Of course, we can discuss further how Espresso addresses the fragmentation issues in Web3. The original goal of Web3 was to fix the fragmentation issues within the existing financial system, but it has not actually achieved that, which is precisely the problem we aim to solve with Espresso.
The main investors supporting this project come from multiple funding rounds. We received seed round financing from Polychain, followed by Series A financing led by Sequoia, Electric Capital, and Greylock. Recently, at the beginning of 2024, we completed Series B financing, with a16z being the lead investor for this round.
The impact of talent competition between the AI and crypto industries
Colin: In fact, over the past two years, the crypto industry and the AI industry have been competing for funding, talent, and attention. I believe that, especially in the United States, most developers are trying to start AI-related projects. Has this put pressure on your team in terms of talent recruitment?
Ben: I don't think so. I haven't felt that pressure directly. We have always been able to recruit talented people to join Espresso. I believe there will indeed be some impact, but many other factors are also at play. Currently, there are still many people interested in and needing crypto companies. Of course, the combination of crypto and AI is also full of potential. So, while I haven't felt that impact directly, there might be some underlying issues that I'm not aware of.
The causes of fragmentation in Web3
Colin: You previously mentioned the issue of fragmentation. So, after more than ten years of development in Web3, why is digital finance still so fragmented? What prevents liquidity from being shared on a large-scale unified platform?
Ben: This is a very good question. In fact, this was also the original vision behind creating projects like Ethereum: to build a single world computer where all financial programs could run and fully compose with each other. If you look at today's virtual machine ecosystem, such as the Ethereum mainnet, the liquidity here is not too fragmented because smart contracts can interact with each other. Therefore, the liquidity between different smart contracts can be composed. If the performance of a single chain is not restricted, you can even imagine having a global order book that unifies the trading of all digital assets, where anyone can place a sell order and match it with any buyer. In that case, liquidity would be unified, at least in the context of digital asset trading.
Of course, liquidity can have different meanings in different contexts, but when it comes to digital asset trading, you can indeed achieve unified liquidity in a single-chain environment, and we can see some of this today.
However, the problem is that no single chain can scale to support the entire application world. For scalability and customization, there will inevitably be many different chains. It is like today's world, where we have thousands of web and mobile applications, and any developer can customize their architecture and run it according to their needs. We need that flexibility in the Web3 space as well. Over the past five years, we have seen the rise of the Layer 2 paradigm to address the needs for scalability and customization. In this model, anyone who wants to run a chain can build it according to their needs, and that chain only needs to record its transactions on a single underlying blockchain, like Ethereum, using it as a database rather than a world computer.
While this approach has achieved scalability and customization, it has also brought more fragmentation issues. Moreover, the problem is not just that there are many different Layer 2s. Due to the scalability bottleneck of Ethereum itself, other blockchains like Solana and Avalanche have also been created one after another. Now, all these blockchains exist as independent, isolated systems. To some extent, this brings us back to the starting point of traditional finance, filled with isolated exchanges and payment systems that cannot interoperate well. This is why, even after ten years of development in Web3, we still live in a highly fragmented world.
Why digital finance in Web3 remains fragmented
Colin: We know that your project has top-notch developers and a strong technical foundation. Can you describe Espresso's technology in simple terms and how it differs from other blockchain or infrastructure projects?
Ben: Espresso is a Layer 1 blockchain, a decentralized protocol that operates as Layer 1. But what sets it apart from other projects is that it is specifically designed to support Layer 2. Ethereum scales through Layer 2, but Ethereum was not originally designed for Layer 2.
The capabilities required for Layer 1 to support Layer 2 are very different from those needed to support smart contracts and other functionalities. Espresso has no smart contracts; we have completely eliminated smart contracts. We focus on being the best, highest-performing, low-latency database that allows Layer 2 to write transactions on top of it. The key is that validators in the Espresso network do not need to receive all the data; they only need to collectively ensure the availability and retrievability of the data. At the same time, they also need to ensure that any users reading that database as Layer 1 can read the data in the same way.
This technical term is called 'finality'. As Layer 1, Espresso achieves very fast finality, significantly faster than Ethereum. Ethereum takes about 15 minutes to finalize transactions, while Espresso can complete confirmation in just a few seconds. Soon, we will reduce this time to half a second.
Why is this important today? Returning to the issue of fragmentation across different blockchains, when you have many different blockchains, the reason liquidity becomes difficult to unify is that applications or smart contracts on different chains cannot interact as easily as smart contracts on the same chain. The key is the speed of communication. On a single chain like Ethereum, even if Ethereum's confirmation speed is slow— taking 15 minutes to confirm transactions— smart contracts on the same chain can still communicate in real-time, which is why they can compose. You can have multiple different automated market makers or lending protocols that all have liquidity, but they can interact with each other in real-time.
Once you put them on different blockchains, they cannot interact in real-time unless the blockchain they are on is extremely fast. If all blockchains are very fast, they can communicate in real-time. This would allow for new features, such as universal order books, where orders placed on one chain can match with orders on another chain, or lending protocols on one chain can be used to fund operations on another chain.
You can see this in decentralized exchanges, which create custodial asset pools across different chains to enable smooth trading of digital assets between different chains. Therefore, when you trade ETH and BTC on an exchange like Binance, there is almost no delay between the two assets because Binance manages two asset pools on two different chains, achieving a 'no-delay' trading experience. If you want to achieve this operation without centralized, trusted intermediaries, the chains themselves need to be extremely fast. That is the key difference of Espresso as a Layer 1 that supports Layer 2 chains.
Espresso's consensus mechanism and cross-chain communication
Colin: I think you explained it very clearly, so even community members with less technical knowledge can easily understand. So, the next question is: Layer 2 blockchains do make things faster, but they also make everything more isolated. Vitalik has mentioned this point as well. What specific problems does Espresso solve in terms of finality and cross-chain communication?
Ben: Espresso achieves very fast finality while ensuring support for multiple chains. Therefore, it addresses the key issue of how to support multiple chains— multiple Layer 2s and parallel chains— simultaneously and ensure that they can all achieve finality very quickly. This is a key issue for interoperability. Once the chains are fast enough, applications on one chain can send messages to applications on other chains and effectively receive messages in real-time. This allows applications or smart contracts on different chains to interact and compose just like smart contracts on the same chain.
This will enable us to build new cross-chain exchanges, cross-chain DeFi protocols, and other potential cross-chain applications that behave just like all operations on a single chain, even though these chains have many differences in customization and construction.
The consensus design of Espresso and fast finality
Colin: I think the next two questions can be answered together. The question is: What are the main components of Espresso's consensus system? How do you plan to achieve sub-second finality? How does cross-chain communication work in Espresso? Do you use zero-knowledge proofs, trusted execution hardware, or other technologies? What roles do they play?
Ben: Let's start with the key aspects of Espresso's consensus design. Since Espresso does not have smart contracts, it can make very different design choices compared to other Layer 1 protocols. The different validators participating in Espresso do not receive complete copies of every transaction block. They do not need every block because they do not need to execute those transactions to determine the state of the blockchain. Espresso simply operates as a Layer 1 chain that supports Layer 2 chains. Therefore, they treat the data in the blocks as raw data— they do not need to understand that data. This means we can use a technique called erasure coding, where each block is split into multiple different parts that are distributed across the network. Each validator only receives a portion of the data. As long as enough validators are not compromised, they can collectively recover the data. This can significantly speed up the communication between validators, thus achieving data block ordering consistency, which is finality.
There are other innovations in consensus as well. Our consensus design is based on the HotStuff protocol and has multiple versions. HotStuff 1 is the latest version currently used by the Espresso protocol. Espresso's two research scientists, Dahlia Malki and Kartik Nayak, are pioneers in consensus research. Dahlia wrote the paper on HotStuff, while Kartik recently wrote a paper called Hydrangea which eliminates a voting round in consensus. You may have heard of other consensus models, such as AlpenGlow, Minimmit, or MonadBFT. Espresso's design is based on cutting-edge research and competes with these other models. It can reach consensus quickly because, unlike systems like Solana, it does not need to wait for all validators to execute transactions. It does not need to understand the data in the transactions at all. This is how consensus protocols work— after two rounds of voting, finality is achieved. In an optimistic scenario, this can even be completed within one voting round.
Then, you asked how cross-chain communication works. One thing to understand is that even if each Layer 2 chain obtains fast finality from Espresso Layer 1, you can still read transactions and compute the state of that chain if you run a node on the Layer 2 chain. This way, you can confirm the status of transactions. Different exchanges may do this, or bridging services like CCTP provided by Circle and CCIP provided by Chainlink also work this way. If you run a node on the chain, that is enough for you to confirm what is happening on that chain.
However, when it comes to cross-chain communication, having fast finality alone is not enough if you need a smart contract on one chain to receive messages from another chain. The smart contract on the other chain does not have a node running on the chain you want to communicate with, so it cannot verify the messages on its own. What it needs is technology similar to zero-knowledge proofs that can prove the results of a list of transactions that have been final confirmed. Alternatively, you can use a trusted execution environment (TEE), which is more practical than zero-knowledge proofs, especially for real-time verification of computations. By using zero-knowledge proofs or trusted execution environments, you can achieve real-time cross-chain communication between Espresso chains.
These technologies are critical because they enable fast cross-chain communication. For example, zero-knowledge proofs and trusted execution environments are not sufficient to enable fast cross-chain communication between Ethereum rollups because Ethereum is too slow to achieve fast finality. However, Espresso can achieve fast finality, so these technologies can facilitate rapid cross-chain communication.
How Espresso supports multi-chain ecosystems and bridges to other chains
Colin: We know that over 20 rollups have integrated with Espresso. What common characteristics do they typically have, and why do they choose Espresso? How does Espresso help them? I think you've mentioned some of this before, but could you elaborate further?
Ben: All the rollups we work with focus on achieving fast finality. Many of them focus on payments or DeFi, although we also have projects like Ape Chain that focus on NFTs. Thus, these different use cases can all benefit from faster finality and better interoperability with the broader ecosystem.
One point to note is that all the rollups we currently support are also Ethereum rollups. While they use Espresso to achieve fast finality, they still have the capability to bridge to Ethereum. What excites me is that we are starting to collaborate with some rollups to explore multi-bridging, so they can bridge not only Ethereum but also Solana. For instance, when a rollup runs on Espresso, it needs to be able to receive ETH deposits as well as Solana deposits or deposits from Avalanche. This is a key advantage of Espresso as a fast finality layer. Espresso ensures that all these bridges to other chains will remain in sync.
Another point is that currently, we mainly collaborate with rollups or Layer 2 chains, but Layer 1 chains can also collaborate with us. Although we have not seen this yet, we are in negotiations with some Layer 1 chains. Layer 1 chains can implement Espresso as a modular part of their infrastructure for better speed.
The demand and application scenarios for rollups on Espresso
Colin: In the real projects you see, what do their teams care most about— faster finality, lower data costs, or better cross-chain communication?
Ben: I believe all three are important. Faster finality is definitely the primary focus and also our unique differentiating advantage compared to other projects. We also provide data availability, but that is not as unique because there are other solutions like Avail, Eigenlayer, and Celestia, which also provide data availability. The benefit of using Espresso is that if you use us, we will also make your data available. Therefore, if you use other data availability systems, you do not need to use them separately; you can use both us and them simultaneously. This gives you more options to make data available, but I wouldn't say data availability is the main reason people choose Espresso, as it is not a unique differentiating advantage.
The unique differentiating advantage is fast finality. Improved cross-chain collaboration is a second-order effect of faster finality. But this will become more apparent as more chains adopt Espresso and become faster, as well as when they adopt new fast cross-chain communication standards. This will enable us to create applications that can truly leverage this. If you only make the chains faster, it won't immediately bring significant changes in cross-chain collaboration. You need the development of applications to fully utilize this. That is why we are not only collaborating with chains but also working on cross-chain applications. We are collaborating with cross-chain application developers to develop applications like cross-chain order books, which will facilitate new forms of trading in multi-chain environments.
The reasons for launching the token and future value drivers
Colin: Why did your team decide to launch a native token? After the Token Generation Event (TGE), what gives the token value? Is it staking, MEV sharing, cross-chain opportunities, or other factors that make community members or traders perceive the token as valuable?
Ben: The reason we launched a native token is that, like all other Layer 1 protocols that adopt Proof of Stake, the network is run by stakers or validators delegated by token holders. Therefore, the token plays an important role in securing and operating the protocol itself.
I believe that in all Layer 1 protocols, the fundamental source of value for tokens is cash flow. Specifically, it is the income generated by token holders participating in protocol operations using their tokens.
I think this is a common situation for all Layer 1 protocols. Some believe that the tokens of Ethereum or Solana have intrinsic monetary properties, but I do not agree with that statement. I think this theory has not been validated, especially after the rise of stablecoins. You can always exchange tokens for stablecoins, which serve as a base trading pair or payment. So, all Layer 1 tokens have only one source of intrinsic value, which is cash flow.
Now, I want to talk more generally about why the Espresso network as a whole will capture value. It's important to note that if our vision is successful, Espresso is expected to create a massive network effect. Every platform that hosts digital assets or payments will be incentivized to integrate with Espresso to connect as much as possible with other parts of the Web3 ecosystem and access the deepest liquidity. If this happens, all transactions, payments, and the biggest use cases for cryptocurrencies will naturally flow through the network, as every chain connected to Espresso will eventually send its transactions to Espresso.
For example, projects like Monad have to start from scratch— building applications and onboarding developers, while when we collaborate with chains like Celo, that chain already has millions of wallets connected, or projects like Arbitrum, whose transactions immediately become Espresso transactions. Therefore, we are prepared for rapid growth. Of course, individual chains will still capture a portion of revenue, but in the long run, Espresso will capture a portion of the revenue from transactions occurring across networks.