Making sense of some niche modular infrastructure

An explanation of Everclear (formerly Connext) and Nuffle

Disclaimer: I am not financially incentivized to write *any* of this - I am here for fun. These views do not represent that of my employer(s).

Before I continue working on my coming restaking post, it’s best that I clear off my to-do list as much as I can. I read about Everclear (formerly Connext) on a recent plane ride - I had no idea chain abstraction was such a massive ecosystem, but now I’m more aware. Its name might confuse you, but it isn’t liquor.

Everclear is a coordinator and global settlement layer for liquidity across all chains, aiming to solve the issue of fragmented liquidity occurring on pretty much every modular L1 or L2. Everclear wants to power optimal liquidity for intent protocols and solvers - these are the individuals/parties that enable cross-chain interactions.

Everclear describes intents as a function of three actions: auctions, execution, and settlement. Auctions occur when a user broadcasts their intent to do something on-chain. Execution is the act of a solver’s facilitating and fulfillment of this request. Settlement happens once an intent protocol has repaid solvers with the user’s original funds on the source chain.

You’re most likely familiar with liquidity fragmentation, but I’ll write a short example to provide some context. If a user deposits assets on Ethereum mainnet and provides liquidity to a USDC/WETH pool, this same liquidity isn’t available on Optimism (an Ethereum L2).

This frustrates our hypothetical user. They want low transaction costs and their assets on another chain and they want them now.

Let’s say this same user then decides to migrate their assets to Optimism a week later; they remove their assets from the liquidity pool and, for simplicity’s sake, let’s say they swap back to USDC. To move their assets across chains, they might use a native bridge provided by Optimism or utilize a third party bridging protocol like Stargate.

A user puts in a request (transaction) to move their assets and a solver on the destination chain fulfills this by essentially fronting the money. Our hypothetical solver provides x amount of USDC on Optimism and an intent protocol eventually settles the trade on the source chain, making the solver whole again. In this scenario the solver is agreeing to migrate their assets because there’s something in it for them, usually a small spread to be made on the transaction. But as I’m sure you can imagine, doing this 10-100 times (or more) everyday would require a lot of capital, time and micromanagement. Is it really worth it to be a solver? I’m not quite sure, as this feels like a very small reward for the actual work being done.

Here’s where Everclear comes in.

The act I’ve just described can be referred to as rebalancing, and Everclear says they’ve made this 10x cheaper. Their blog post says rebalancing has been an issue for quite some time now and the cross-chain solver market consists of either bridges themselves or large market makers. Even worse, they discovered some extreme capital inefficiencies: for every $1 sent to a chain, $0.80 was sent back in rebalancing processes. In simpler words, over 5x the required volume was being sent through bridges than necessary.

Instead of reinventing bridges or cross-chain interoperability standards, Everclear has opted for an approach that makes it easier for these players to interact and communicate with each other. To me, this makes the most sense. A good analogy for this could be comparing the telephone game to a text message interaction. It’s a lot easier to get the correct information when you improve the process of delivering a message.

Everclear introduces a new layer of the chain abstraction stack that they’re calling clearing layers. To me, this actually seems pretty useful. I know that infrastructure projects can attract negative attention, but I don’t see any issues with this. Their website lists off some other parts of the chain abstraction tech stack like orderflow auctions, settlement layers, solvers, and accounts.

Clearing layers make sense as a necessary next step for improving cross-chain interactions, especially when you consider just how many rollups are releasing. Liquidity on these rollups is siloed, which is an issue on its own, but the act of transmuting this liquidity between rollups is far more relevant to our current level of infrastructure.

Everyone agrees it would be great to utilize liquidity from Arbitrum on Mode (no one has said this) but it’s probably not going to happen for quite some time. Until then, we can at least make liquidity transmission a lot smoother and more capital efficient.

When it comes to Everclear’s tech stack, I’m probably not the one to give you an explanation on how it works. Here’s what their blog says:

“Everclear is designed as an Arbitrum Orbit rollup using EigenDA in partnership with Gelato RaaS. It acts as a shared “computer” for optimally clearing settlements for the ecosystem of protocols and solvers building on top of it.”

Here’s what I say: that’s a lot of words just to tell us that you’re a rollup. Regardless of where they’re sourcing their data availability or which RaaS provider was utilized, they’re an L2, or maybe an L3 - it’s not entirely clear.

I think most applications that become L2s don’t need to do it, but in this case I don’t really have any major complaints. Why shouldn’t Everclear become a rollup? If they’re able to facilitate even a fraction of the rebalancing market’s daily volume, I’m sure they’ll make some revenues. They’ll probably make more money than a lot of apps and rollups, which is always a good thing.

When it comes to modular infrastructure, I support it as long as it’s useful and solves a tangible problem. Everclear seems like it’s doing both, so I’ll say that I support it. The blog post is a good source of info so here’s a link. It discusses a bunch of protocols I’ve never heard of, like Particle, Avocado, Khalani and a few more; it’s probably a good idea to dig into these if your interest in chain abstraction has been piqued.

I found another protocol that’s even more confusing. This would be Nuffle, who just raised $13 million in a round led by Electric Capital. Nuffle is, well, it’s a.. it’s uhhh.. it’s easier to just give you the description from their website:

“Nuffle was born from a shard and raised by a black dragon. We are former core contributors to the NEAR Protocol and builders on Ethereum. We build next-generation modular infrastructure for all layers. There’s NUFF for everyone.”

That didn’t explain much, so I looked a little harder and figured out Nuffle is essentially a two-in-one modular infrastructure project that consists of Near DA and the Nuffle Fast Finality Layer (NFFL). Sidenote: I know that Near is always capitalized, but I don’t feel like formatting it like that.

To be honest, I didn’t look much into Near DA when it was first announced. The market was kind of dull then and it didn’t seem like the best use of time, so I put it off. Here’s how Near DA stacks up to EigenDA:

Looks to me like it’s cheap and has higher throughput than its competitors. Near DA is also available on a few RaaS providers which is cool to see.

Nuffle’s docs are a little confusing because they refer to NFFL as SFFL (short for Super Fast Finality Layer) but I take it these are probably the same thing. The goal of NFFL/SFFL is to provide an obviously fast settlement layer for participating networks to more easily gather info. NFFL/SFFL leverages Near and Eigenlayer for this; their protocol architecture revolves around two off-chain actors, these being operators and the aggregator, along with on-chain components like AVS nodes and smart contracts.

Their docs have a pretty good walkthrough of how the system works, but I’ll break it down a bit more. And here’s a graphic to help you follow along:

Nuffle describes a situation where someone wants to send HelloProtocol (a primitive protocol) from network A to network B - think of this as a user sending tokens from one chain to another via a bridge. To ensure this has been done correctly, it might be reasonable to want fast finality, this being the cryptographic guarantee that a transaction has been appended to a blockchain’s state.

NFFL/SFFL achieves this super fast finality by leveraging Eigenlayer’s AVS set. Users restake their staked ETH, delegate to an operator, and operators register a set of AVSs (or a single AVS). This is the topic known as shared security, or the main draw of Eigenlayer. NFFL/SFFL takes advantage of this by leveraging the economic security to offer super fast finality.

It was said in their announcement post that NFFL/SFFL is built on top of Near DA; their docs have a short blurb on how Near DA works. Rollups must post block data to Near and Near DA hosts the rollup block data. This data is indexed by AVS nodes, which is then cross tested against their own nodes’ data and network state is hopefully agreed on. If I remember correctly, this is pretty much just how data availability works in the wild, without all the DAS schemes and fancy terms from 2022 that none of us remember. There’s some other stuff that happens after this with sequencers and relayers, but I hope to finish writing this soon and don’t want to spend all day here.

Anyways, NFFL/SFFL nodes attest to a rollup’s state root after executing a block that’s been sent in. “An SFFL Operator, runs a full node for each of the participant networks (including Ethereum), as well as a NEAR full node and a NEAR DA indexer.” Putting this together, NFFL/SFFL is able to kind of collect these attestations and messages so users can provide them back to their destination chain in a simple transaction.

I’m not sure if what I’ve described is pretty simple to all of you, maybe this is just a generalized overview of how settlement and finality work, though I don’t think this is true. Most blog posts that I read are rarely informative and only give basic summaries with almost zero critique. If I wanted to compare Nuffle to something, the truth is that I wouldn’t even know where to start. Regardless of what’s just been describe, I feel like one thing is true: this honestly seems like the first realworld example of an AVS being practical.

I won’t go into details yet, but I have an exciting post on the horizon that will clear my system of restaking lingo once and for all. Instead of analyzing every AVS there (it would take forever), I’ll write about them in one-off posts like this whenever I feel like it. It doesn’t seem like Nuffle is a state-sponsored AVS on Eigenlayer, or maybe my dashboards just aren’t updated yet. Oh well.

I hope this was helpful to some of you, it was useful for me and clears out a few chrome tabs. Talk to you all later.