0/ The modular thesis will change how we build blockchains! 🧱

It will also shape the the scalable & secure execution layers that will lead us into the bullrun! 🚀

Find part 1 of an extensive 🧵-Series on modular building blocks below!

Today's topic: Execution (VMs)

🧵 (0/60)

The 🧵-Series will cover:

🔹 Execution (VMs)
🔹 DA Layers
🔹 Sequencers
🔹 MEV-aware Block Builders
🔹 RaaS / SDKs / Infrastructure
🔹 Interoperability

Today, we kick off the series with "Execution" 👇

Before we dive into the world of execution layers or more specifically virtual machines, let's have a quick look at what modular blockchain architecture actually is. 🧱

In monolithic networks (e.g. Ethereum) execution, settlement & consensus/DA are unified in one layer.

But what do all these terms mean? Let's have a quick look! 👇

🧱 Data Availability:

The concept that data that is published to a network that is accessible and from where data retrievable by all network participants (at least for a certain time).

🧱 Execution:

Defines how nodes on the blockchain process transactions to transition the blockchain between states.

🧱 Settlement:

Finality (probabilistic or deterministic) is a guarantee that a tx commited to the chain is irreversible. This only happens when the chain is convinced of tx validity. Hence, settlement means to validate txs, verify proofs & arbitrate disputes.

🧱 Consensus:

The mechanism by which nodes come to an agreement about what data on the blockchain can be verified as true & accurate.

But while this monolithic design approach has some advantages of its own (e.g. with regards to reduced complexity & composability), it doesn't necessarily scale well.

That's why modularists strip these things apart and have them done by separate, specialized layers. 🧱

The modular design space hence consists of:

🔹 Execution layers (the rollup, e.g. @Arbitrum)
🔹 Settlement layers (e.g. $ETH)
🔹 Consensus/DA layer (e.g. @CelestiaOrg)

Interesting, right? So, let's dive into the world of execution layers a bit more.

Execution layers built on top of Ethereum (that acts as a settlement layer) are also called rollups.

Strictly speaking, "true" rollups also use Ethereum for data availability. But we will use the term rollups more generally here and use it to refer to modular execution layer configurations more broadly.

For an introduction to rollup-based scaling, have a look at my thread below. 👇

https://twitter.com/expctchaos/status/1527419709616013313

Rollups are complex systems that can have different state validation mechanisms (optimistic rollups vs. validity rollups), can have varying sequencer (and prover) designs, DA solutions and so on.

But since the execution itself is where the smart contract magic is taking place, what really defines how execution looks like, this thread will focus on the different virtual machines that these rollups could run.

In this thread we will cover:

🔹 EVM
🔹 zkEVM
🔹 CairoVM
🔹 CosmWasm VM
🔹 Sealevel VM
🔹 Move VM

So let's dive in! 👇

⚙️ Ethereum Virtual Machine (EVM)

The EVM is a piece of software that executes smart contracts & computes the state of the $ETH network after a new block is added to the chain.

The EVM sits on top of the Ethereum hardware & node layer.

Its main purpose is computing the network's state & compiling various types of smart contract code (written in human-readable languages) into a machine-readable format called bytecode to run the smart contracts.

The EVM hence powers smart contract execution and is one of the core features of Ethereum.

Instead of a classic distributed ledger of transactions, the EVM basically transforms Ethereum into a distributed state machine.

Ethereum's state is a large data structure which holds not only all accounts & balances, but also an overall network or machine state which can change from block to block according to a pre-defined set of rules.

The specific rules of changing state from block to block are defined by the EVM. At any given block in the chain, Ethereum has one & only one canonical state with the rules for valid state transition being defined by the EVM spec.

The EVM is not only what defines how execution works on Ethereum L1, it is also a very popular choice of execution environment for many rollups.

This makes sense, as the largest dev pool by far in Web3 is the EVM/Solidity community.

While optimistic rollups running the EVM have been around for a while, zk-rollups with EVM support are rather nascent.

⚙️ zkEVM

With the emergence of zk (a.k.a validity) rollups, the term zkEVM became popular quickly.

But what is it? 🤔

A zkEVM is a virtual machine that executes smart contracts in a way that is compatible with zero-knowledge-proof computation and the programming languages supported by the originial EVM.

However, this can be quite difficult to build.

A zkEVM rollup's main goal is to run EVM bytecode.

Unfortunately though, zk proofs require all the computational statements they are proving to be converted into a very specific format to then be compiled down into a STARK/SNARK.

Luckily, there are a few ways to do it though:

1️⃣ Prove the EVM execution trace directly by converting it into the verifiable format (e.g. @Scroll_ZKP)



2️⃣ Create a custom VM, map EVM opcodes to opcodes for that VM & prove correctness of the trace in that custom environment (e.g. @0xPolygon)



3️⃣ Create a custom VM, transpile Solidity into the custom VM’s bytecode (directly, or via a custom high level language) & prove in a custom environment (@zkSync & @StarkWareLtd)

For more on the different types of zkEVMs have a look at the below thread I wrote a while back. 👇

Note: Starknet is also included in the below thread, which is not strictly correct as it runs CairoVM, rather than a zkEVM.

https://twitter.com/expctchaos/status/1569717615282782209

⚙️ CairoVM

One such custom environment is the CairoVM, developed by @StarkWareLtd, which is building @Starknet.

Starknet is based on the Cairo programming language, which is optimized for zk-proofs.

To enable smart contracts & composability, StarkNet takes a language-level compatibility approach & transpiles EVM-friendly languages (e.g. Solidity) down to a STARK-friendly VM (in Cairo).

because @jinglingcookies has already done a great job explaining what the CairoVM is, I will not cover it in-depth here. Just check the below thread! 👇

https://twitter.com/jinglingcookies/status/1665357785759109121

One of many cool features that CairoVM execution layers have, is the native support for account abstraction (something that does is not natively supported by the EVM).

If you need a refresher on why AA is so exciting, have a look here! 👇

https://twitter.com/expctchaos/status/1642889752839077888

⚙️ CosmWasm VM

CosmWasm is a smart contracting platform built for the Cosmos ecosystem. Simply put, it's the Cosmos (Cosm) way of using WebAssembly (Wasm) hence the name.

CosmWasm is written as a module that can plug into the Cosmos SDK.

This means that anyone currently building a blockchain using the Cosmos SDK can quickly and easily add CosmWasm smart contracting support to their chain, without adjusting existing logic.

The CosmWasm VM can also be used in modular rollups, which is heavily simplified by Rollup-as-a-Service (RaaS) providers like @vistaralabs.

For more on @vistaralabs, make sure to check my thread below! 👇

https://twitter.com/expctchaos/status/1690002134933069826

What makes the CosmWasm VM powerful, are WebAssembly (WASM) smart contracts.

They offer a multitude of benefits over Solidity contracts, making them a robust choice for a wide array of applications.

The benefits include:

- Superior performance
- Broad language support
- Better Security
+++

As the tech continues to evolve and gain adoption, WASM is set to become an indispensable tool for blockchain developers!

For more on WASM smart contracts have a look here. 👇

https://twitter.com/expctchaos/status/1681680429215264771

⚙️ Solana's Sealevel VM (SVM)

Solana is a high-performance blockchain known for its fast transaction times and low fees.

One of the key innovations of the Solana platform is its unique architecture, designed to handle a high throughput of transactions with minimal latency.

A core innovation enabling this is the parallel smart contracts runtime engine Sealevel.

It is an engine that allows smart contracts to execute in parallel, thereby maximizing efficiency and throughput.

In traditional blockchain systems like Ethereum, smart contracts are processed in a sequential manner, one after another.

In contrast, Sealevel is designed to execute multiple smart contracts at the same time, taking full advantage of modern hardware architectures.

By enabling parallel execution, Sealevel makes it possible for Solana to process tens of thousands of transactions per second (TPS), making it one of the fastest blockchains out there.

However, the Sealevel VM does not have to be exclusively on Solana.

Like the EVM (in the case of Optimism or Arbitrum), the zkEVM (in the case of Scroll or zkSync) or CosmWasm, the Sealevel VM can be used as an execution environment in modular network configurations

A leading project in enabling this is @EclipseFND. Make sure to check out the below thread to learn more! 👇

https://twitter.com/expctchaos/status/1692242397957349807

⚙️ MoveVM

A modular rollup opting for a Move VM execution environment gets some interesting functionality, including parallelism, massive storage in accounts & decoupled fine-grained storage.

As the name suggests, the MoveVM is powered by Move, an open-source programming language developed by @Meta's Diem Association team (when that was still a thing).

It's designed to create customizable transaction logic & smart contracts and is based on Rust.

Move boasts a high level of security & expressivity, using resources drawn from the mathematical idea of linear logic.

It allows devs to avoid mistakes that could lead to exploits, while minimizing gas fees compared to other smart contract chains like Ethereum.

Move introduces formal verification tools, greatly reducing the cost of manual code security audits. It also aims to enable parallel processing, improving system operation efficiency.

Move's executable format is “bytecode that is higher-level than assembly yet lower-level than a source language. The bytecode is checked on-chain for resource, type & memory safety by a bytecode verifier & then executed directly by a bytecode interpreter”.

(from whitepaper)

Move is developer-friendly, lowering the security threshold for development so that developers can focus on business logic.

The switching cost for developers experienced in #Rust and #Solidity is relatively low.

The most famous examples of chains running a Move VM are @Aptos_Network and @SuiNetwork.

However, I'm sure we will see Move-based execution layers running on top of Ethereum (Move rollups) rather soon!

This is it for today, I hope you liked this overview!

Stay tuned for the upcoming parts of this XX-series to learn more about the modular building blocks that will power the execution layers of tomorrow.

Don't forget to smash that follow button! 🫡

Like & RT also greatly appreciated frens! 🫶


Tagging some chads to follow 🫡👇

@Hercules_Defi
@splinter0n
@Louround_
@TheDeFISaint
@0xSalazar
@poopmandefi
@ShivanshuMadan
@0xShivani
@0xDinoEggs
@jinglingcookies
@modularmedia_
@CJCJCJCJ_

1/2

.@VelvetMilkman
@MTorygreen
@wacy_time1
@hmalviya9
@splinter0n
@vaibhavchellani
@DOLAK1NG
@kunalgoel
@Haylesdefi
@redvelvetzip
@bitsplaining
@daddysether

2/2

The Modular Thesis: Building Blockchains

0/ decentralized rollup sequencers are a key step towards mature L2 infrastructure 🧱

@radius_xyz is building a decentralized, shared sequencer network that is fully censorship & MEV-resistant and comes with interoperability benefits too🚀

a 🧵 on why @radius_xyz matters (0/28)

1/ If you’re not familiar yet with the risks that centralized rollup sequencers pose, I recommend to have a look here first 👇

https://twitter.com/expctchaos/status/1682359858119741443?s=46

2/ but let’s dive into @radius_xyz and start with a definition

so basically, @radius_xyz is a trustless shared sequencing layer, aiming to eradicate detrimental #MEV and censorship risks, whilst simultaneously generating economic value for rollups

3/ since rollup sequencers define the order of #L2 transactions, one of the main risks of centralized sequencers arises from #MEV exploitation

@radius_xyz will change the game 🚀

4/ but how? 🤔

it employs a mechanism called Practical Verifiable Delay Encryption (PVDE), enabling an encrypted mempool

5/ I will break this down a bit more in this thread on a high level, but if you want to get into the weeds, read more about PVDE here 👇

https://ethresear.ch/t/mev-resistant-zk-rollups-with-practical-vde-pvde/12677

6/ what is PVDE?

PVDE is a zero knowledge (ZK) cryptography scheme and instrumental in ensuring trustless sequencing of transactions. It's crucial in keeping centralized sequencers from engaging in malicous actions such as frontrunning, sandwiching or censoring user transactions

7/ this kind of #MEV-resistance is achieved as the contents of the transaction are only revealed after the transaction order is determined by the sequencer

8/ more specifically, @radius_xyz encrypts the transactions temporarily based on a time-lock puzzle, which adds a time delay for the operator to find the symmetric key used to decrypt the transaction data

9/ this method generates zk proofs within 5 seconds, which are needed to prove that solving the time-lock puzzles will lead to the correct decryption of valid transactions

10/ ok, so radius provides an #MEV-resistant sequencer layer, that’s cool? But didn’t I say something about interoperability as well? 🤔

11/ you’re right, I did! And this is especially exciting too as interoperability between rollups is generally recognized as a complex challenge

12/ but how does @Radius_xyz help here? 🧐

13/ basically, the @radius_xyz sequencer network acts as a pivotal communication tool, synchronizing rollup data, and thus improving interoperability

14/ this makes sense if we think about why we call it a « shared » sequencer. If multiple rollups send their transactions to @radius_xyz and subsequently ordered within one cross-rollup block, rollups using the same sequencer become atomically composable 🤯

15/ and because the operator that orders the transactions will be chosen randomly out of an entire set, rollups using @radius_xyz will get « Decentralization as a Service », completely abstracting the complexity of spinning up the hardware themselves

16/ pretty sick, right? 🤯

and @radius_xyz is not the only team out there working on shared sequencing layers. @EspressoSys and @AstriaOrg are both working on similar solutions, shich I sill explore early next week 👀

17/ alternatively, #rollups can leverage @eigenlayer’s restaking network to perform this transaction ordering function. An example of this is @altlayer 👇

https://twitter.com/expctchaos/status/1680997392370536448?s=46

18/ or, #rollups can choose to become « based » and rely on the L1 that they’re based on for sequencing 👇

https://twitter.com/expctchaos/status/1682855989106601989?s=46

19/ but to conclude this thread, let’s have a quick look at the transaction flow on a rollup using @radius_xyz 👇

20/

1️⃣ Users dispatch their transactions to the sequencing layer

21/

2️⃣ The sequencing layer arranges the transactions and constructs a block

22/

3️⃣ The composed block is then submitted to the #rollup

23/

4️⃣ The #rollup proceeds to execute the transactions following the order provided by the sequencing layer

24/

5️⃣ Finally, the rollup submits the executed transactions to the settlement layer or data availability (DA) for finalization

25/ so will we see shared sequencers everywhere in the future? 🔮

26/ probably not, as big general-purpose L2s will likely build out own decentralization mechanisms

27/ but as the modular design space matures and we see more (app-specific) rollups emerge, shared sequencer networks like @radius_xyz will be well positioned to provide «Decentralization-as-a-Service» to these smaller rollups, tackling both MEV & interop challenges in the process

28/ follow me (@expctchaos) for more content like this 🫶

tagging a few chads to follow 🫡👇

@0xchadnik
@splinter0n
@Only1temmy
@Louround_
@TheDeFISaint
@0xSalazar
@poopmandefi
@ShivanshuMadan
@0xShivani
@hmalviya9
@wacy_time1
@ThorHartvigsen
@poopmandefi
@0xDinoEggs
@jinglingcookies
@DOLAK1NG

Radius

0/ only few are aware that rollups aren't real (yet)

a 🧵 on the centralization issues rollups face, the current state of rollup sequencers & the role of shared sequencers in taking the training wheels off rollups (0/19)

as rollups scale and grow, one risk attracting significant attention is the potential failure of sequencers and validators. And rightly so

@optimismFND, the 6th largest network by TVL, could see users' funds locked if a whitelisted validator goes offline and @zkSync Era currently lacks a mechanism to deal with offline sequencers and validators

but the main problem is, that most rollup networks run a centralized sequencer. But let's have a look at the current state of the leading rollups 👇

@optimismFND

in Optimism, both sequencer and validator are centralized and run by the foundation. If the sequencer goes offline, users can still force transactions to the #L2 network via L1

what not many are aware of either, is that #Optimism fraud proof system is still under development. So users need to trust the block proposer to submit correct L1 state roots

additionally, an offline validator in Optimism's case actually means that users can't withdraw from L2 to L1. However, #Optimism plans to decentralize the sequencer in the future using economic game theory and governance mechanisms

@arbitrum

#Arbitrum operates a centralized sequencer, run by the Foundation, with 13 whitelisted validators. Similar to #Optimism, users can still force transactions on #L2 through L1 if the sequencer goes offline

unlike #Optimism though, Arbitrum has a fraud-proof system in place, albeit only accessible to whitelisted validators. #Arbitrum also has plans for future sequencer decentralization (and permissionless fraud proving)

@zkSync #Era

in #zkSync Era, a centralized operator serves as both the sequencer and validator. Given the project's early stage, it lacks a contingency plan for operator issues. Future plans include decentralizing the operators by establishing roles of Validators & Guardians

@0xPolygon #zkEVM

#Polygon #zkEVM features a centralized sequencer operated by the Foundation. The Validator (or Aggregator) that submits ZKP is also centralized

if the sequencer fails, user funds are frozen; however, if the aggregator fails, any user can still submit a ZKP to withdraw from #L2 to L1. Polygon #zkEVM plans to decentralize the sequencer and aggregator using a PoE consensus algorithm

so centralized sequencers pose a risk to rollup users as they have the power to censor transactions or maliciously exploit #MEV and they pose a risk as they are a single-point-of-failure

given the risks inherent to centralized sequencers and validators, various projects like @AstriaOrg, @EspressoSys, @radius_xyz, OP Stack, and Flashbots' #SUAVE are striving to decentralize rollup network sequencing

they provide rollups with a sequencer network, determining the transaction order and passing them to the rollup network

shared sequencers offer several benefits over the current design:

🔹 Censorship resistance
🔹 Atomic cross-rollup composability
🔹 Liveness (low/no downtime) guarantees
🔹 Plug-and-play solution for existing & new rollups

so, instead of the rollup bootstrapping new hardware for an entirely new set of sequencers, shared sequencer networks basically provide "Decentralization as a Service"

shared sequencer projects have found a cozy little niche by relying on teams to be lax about "low-priority" project milestones

recently, Ethereum Foundation researcher Justin Drake proposed a different approach: Based Rollups

I'll drop a thread on this over the weekend, so stay tuned 👀

sequencer decentalization will definitely be a key issue for rollups to tackle as they enter the next stage of maturity 🚀

some modular & rollup chads to follow🫡 👇

@splinter0n
@Only1temmy
@Slappjakke
@Louround_
@TheDeFISaint
@0xSalazar
@CryptoShiro_
@jake_pahor
@0xTindorr
@poopmandefi
@ShivanshuMadan
@0xShivani
@hmalviya9
@wacy_time1
@crypthoem
@poopmandefi
@0xDinoEggs
@jinglingcookies
@DOLAK1NG

Sequencers

0/ modular execution layer @alt_layer & #Ethereum-based restaking service @eigenlayer are two of the biggest upcoming airdrops 🪂 💸

and now you can farm both at once, thanks to @eigenlayer-based decentralized sequencing for #FlashLayers in the new testnet 🚀

a 🧵 (0/22)

this 🧵 provides a comprehensive update on the newest iteration of the @alt_layer testnet & how @eigenlayer’s restaking service can secure @alt_layer execution layers

we will look at

⚡️ Altitude Phases I & II:
⚡️ Altitude Phase III:
⚡️ EigenLayer's Role:
⚡️ Flash Layers meet EigenLayer’s Restaking:
⚡️ The Final Vision
⚡️ Launching Phase III
⚡️ How can I farm potential airdrops?

but let’s dive in 👇

⚡️ Altitude Phases I & II:

@alt_layer has seen incredible success with the initial phases of #AltLayer's #Altitude testnet, where participants experienced the thrill of multi-sequencing, the beacon Layer, and rollup staking

⚡️ Altitude Phase III:

now, @alt_layer is rolling out Phase III of Altitude, in collaboration with @eigenlayer. This phase allows everyone, regardless of experience, to launch a #FlashLayer and safeguard it with #EigenLayer's unique restaking mechanism

⚡️ EigenLayer's Role:

but first, let's unpack what #EigenLayer aims to achieve, why it's crucial, and how we're looking to harness their pioneering tech at #AltLayer 👇

so basically, @eigenlayer let's stakers expose their staked $ETH (e.g. $stETH or $rETH) to additional slashing conditions through re-staking in exchange for securing middleware, thereby leveraging the existing $ETH validator for security/trust of important middleware services

these services can basically be anything (a DA layer like EigenDA, a fast finality settlement layer, etc). But in this specific case, the service that the re-staking nodes would opt-in to provide is rollup sequencing (tx ordering), on which I will elaborate more later

for more info on @eigenlayer, check here 👇

https://twitter.com/expctchaos/status/1601921935662731265

⚡️ Flash Layers meet EigenLayer’s Restaking:

so, the past months, the @alt_layer team has been working hard to incorporate @eigenlayer into the @alt_layer protocol

for @alt_layer execution layers, @eigenlayer is a fantastic tool to promote decentralization, while capitalizing on the security of #Ethereum’s robust trust network

⚡️ The Final Vision

so as mentioned before, @alt_layer will use the network of restaking @eigenlayer nodes to increase  the decentralization of sequencers that maintain the #FlashLayer

upon completion of the integration, a user can launch a Flash Layer via the @alt_layer rollup launchpad and simply define the number of sequencers required to operate the rollup in the process

these sequencers can then be sourced from the pool of validators that have chosen to serve Flash Layers through @eigenlayer’s restaking mechanism

this is important as centralized sequencers are one key issues rollups are currently facing

https://twitter.com/expctchaos/status/1641440190647656448

#Arbitrum & #Optimism sequencers for example are run/endorsed by the official teams to make up for the imperfection of the current system

same holds true for @zksync or @0xPolygon zkEVM

this will change in the future as rollups become more mature

@0xPolygon for example will decentralize sequencing through the introduction of a staking layer with multiple roles validators can take for Polygon-based networks (including sequencing)

https://twitter.com/expctchaos/status/1679777381198991361

@zkSync also has plans to build a decentralized sequencer set & @MetisDAO has basically pioneered the concept, announcing a pool of sequencer nodes already over a year ago

https://twitter.com/expctchaos/status/1537857673546215424

however, many smaller (app-specific) rollups will likely opt for an out-of-the-box "decentralization-as-a-service" provided by shared sequencers like @EspressoSys, @Sagaxyz__ or @radius_xyz instead of building their own solution

by using @eigenlayer to sequence @alt_layer's flashlayers, #AltLayer goes down a similar path, abstracting the complexity of sipinning up a sequencer set of their own

⚡️ Launching Phase III

however, the integration process is still ongoing. But the Altitude III testnet does give a first glimpse at the combined power of #FlashLayers and @eigenlayer...

...showcasing how #restaking middleware can supercharge #FlashLayers, enhancing their decentralization and resilience

⚡️ How can I farm potential airdrops?

users can get a taste of this by restaking $stETH or $rETH on the @eigenlayer testnet and then using the same restaking account to launch a Flash Layer through @alt_layer’s rollup launchpad, a process designed to be swift & user-friendly

tagging a few modular chads to follow 🫡👇

@splinter0n
@Only1temmy
@Slappjakke
@Louround_
@TheDeFISaint
@0xSalazar
@CryptoShiro_
@jake_pahor
@0xTindorr
@poopmandefi
@Flowslikeosmo
@ShivanshuMadan
@0xShivani
@hmalviya9
@wacy_time1
@kunalgoel
@crypthoem
@poopmandefi
@0xDinoEggs

Altlayer x Eigenlayer

0/ 🚨 PURE ALPHA WARNING 🚨

how to find the next 1000x token? 💰🚀

DYOR & use all the great FREE tools available to make your life as a web3 investor easier! 📊🔍

this is the most comprehensive overview you'll find on CT! 🤯

mega-🧵 on tools for crypto investors (0/41)👇

1/ @coingecko

go-to place for the basics. If you need high level information on a token (e.g. price, market cap, exchanges, etc.)

https://www.coingecko.com/

2/ @CryptoPanicCom:

it's important to stay on top of all the news in this dynamic space. the crypto panic news aggregator helps you with that

https://cryptopanic.com/

3/ Chainlist:

chainlist is a great tool that simplifies adding new chains to your @MetaMask wallet

https://chainlist.org/

4/ @DefiLlama

the llama has got you covered on all things DeFi. Prime source for TVL data across all chains. One of my all-time favourites

https://defillama.com/

5/ @defipulse

DeFi data aggregator and great place if you're looking for TVL numbers in the $ETH ecosystem

https://www.defipulse.com/

6/ @0xCoindix

looking for the pools with the best APYs to put your crypto to work? Coindix got you covered across a wide range of chains

https://coindix.com/

7/ @tokenterminal

one of my absolute favourites! The go-to place for data on protocol revenue

https://tokenterminal.com/

8/ @DuneAnalytics

Dune is great. Platform that allows users to build dashboards & make SQL queries, thereby extracting a wide variety of blockchain information. Many great dashboards freely available. Thread on my favs will follow

https://dune.com/browse/dashboards

9/ @l2beat

Searching for TVL data on $ETH L2? Look no further, L2 Beat has got you covered

https://l2beat.com/scaling/tvl/

10/ L2 Fees:

great overview on tx fees on $ETH layer 2

https://l2fees.info/

11/ Crypto Fees:

wanna know how much total fees applications and L1s/L2s generate? Check out the website below

https://cryptofees.info/

12/ Money Printer:

provides an overview of the cost of emission (new tokens issued as incentives) of various L1 protocols & dApps

https://moneyprinter.info/

13/ OpenOrgs:

information on DAO treasuries

https://openorgs.info/

14/ Stakers Info:

looking for the best staking rates?

https://stakers.info/

15/ @Coinglass_com:

data on long/short volume & funding rates

https://www.coinglass.com/

16/ Bitcoin Treasuries:

How much $BTC does Tesla hold? How big is Saylor's bag? Find the answers on Bitcoin Treasuries

https://bitcointreasuries.net/

17/ @Artemis__xyz (formerly GokuStats):

one important aspect to consider is developer activity. This is the best place to look on development stats

https://www.gokustats.xyz/dashboard

18/ Chainalysis Dashboard:

@chainalysis has a nice dashboard summarizing some on-chain data on $BTC, $ETH, $BCH, $LTC & $USDT

https://markets.chainalysis.com/

19/ @glassnode:

great tool for on-chain data analysis. Has a paid plan but offers a lot of functionality for free as well. Supports a large number of assets & has dozens of metrics to choose from

https://glassnode.com/

20/ @nansen_ai:

one of the most advanced on-chain data providers out there. Very useful wallet tracking features (whales, influencers, etc) as well. Unfortunately only available for free on trial

https://www.nansen.ai/

21/ @ultrasoundmoney:

keep track of how the #ETHmerge has changed $ETH monetary policy & how that impacts $ETH supply

https://ultrasound.money/

22/ Beacon Chain:

more $ETH PoS data with some great charts

https://beaconcha.in/

23/ @etherscan

while this one is rather obvious, can't be excluded when we talk about $ETH data. Ethereum's main block explorer

https://etherscan.io/

24/ @santimentfeed:

powerful analysis tool that provides a lot of information for free. Personally especially use it for the social trends/data

https://santiment.net/

25/ @LunarCrush:

social intelligence platform that helps you track the hype around a shitload of tokens

https://lunarcrush.com/

26/ @dexscreener:

if you're a shitcoin degen you might be looking for charting tools. My fav one is DEXScreener. Basically supports every chain and lets you find the newest listings before anyone else

https://dexscreener.com/

27/ @DEXToolsApp:

alternative charting tool for decentralized exchanges

https://www.dextools.io/app/

28/ @parachains:

most comprehensive database on all things DotSama. Get infos on crowdloans, auctions & projects

https://parachains.info/#

29/ @DotMarketCap:

overview of $DOT ecosystem projects

https://www.dotmarketcap.com/

30/ @dtmb_xyz:

if you're into the @MoonbeamNetwork ecosystem, Downtown Moonbeam is a must to check out

https://www.dtmb.xyz/

31/ @MapOfZones:

if you're a #Cosmonaut, you have to check out Map of Zones for data on IBC volumes

https://tinyurl.com/mapofzones

32/ @DappRadar:

it's key to keep an eye on the activity on the protocols you're looking to invest in. DappRadar is the leading dApp explorer and provides user stats across multiple chains

https://dappradar.com/

33/ @StateOfTheDapps:

alternative dApp explorer that provides user data on your favourite decentralized applications

https://www.stateofthedapps.com/stats

34/ @flipsfinance:

if you're looking for NFT data, make sure to check out flips

https://www.flips.finance/

35/ @Token_Unlocks:

one of the most useful tools imo. Enables you to keep an eye on release schedules & token unlocks in order to avoid being dumped on by early investors

https://token.unlocks.app/
Look into Bitcoin: https://www.lookintobitcoin.com/charts/

36/ @apyvision:

if you're looking for the best liquidity pools or for an efficient way to track your LP positions, APY vision can be of great help

https://apy.vision/

37/ @revertfinance:

another great tool for LPs that provides you with actionable data on your positions

https://revert.finance/

38/ @zerion_io:

smart wallet that automatically keeps track of all your DeFi positions, token holdings & NFTs

https://zerion.io/

39/ @zapper_fi:

wallet tracker with similar functionality as Zerion

https://zapper.fi/

40/ @CoinTracker:

great tool that helps you manage your taxes

https://www.cointracker.io/

41/ @accointing:

portfolio tracker with advanced functionality to help you get your taxes done with ease

https://www.accointing.com/de-CH

The Best Crypto Research Tools

0/ with the #ETHmerge set to happen in <24h & marking $ETH's transition to PoS, let's have a closer look at the two largest liquid staking protocols on #Ethereum 📊🔍

🧵 on @LidoFinance & @Rocket_Pool (0/30)👇

$LDO $RPL

1/ there is roughly 14m $ETH staked right now

source: beaconcha.in

2/ the beacon chain is secured by over 425k validators

source: beaconcha.in

3/ however, @LidoFinance runs 128k validators and dominates the pool distribution with a share of 30%, while @Rocket_Pool sits at 1.4% with >6k validators

source: beaconcha.in

4/ $LDO has sucked in a total of 4% of ETH supply & is by far the largest liquid staking protocol

source: stakingrewards.com

5/ but lets dive into the comparison of the two protocols

6/ in terms of market cap, $LDO is ∼2x bigger than $RPL with a market cap of $1.1bn (vs. $560m)

source: @coingecko

7/ @LidoFinance's $stETH on the other hand has a market cap of $6.9bn compared to @Rocket_Pool's $rETH's roughly $360m (at 222k $ETH staked)

source: @coingecko

8/ but what exactly is the service that the $LDO & $RPL provide and how do they earn money?

9/ both are liquid staking protocols that allow users to stake $ETH (or in the case of $LDO also other PoS assets) and get a derivative in return ($stETH & $rETH) that is usable as collateral in DeFi & tradable, enabling stakers to stay liquid 

10/ however, there are differences in how the protocols work. While in @LidoFinance its the DAO ($LDO hodlers) that operates the nodes, @Rocket_Pool is a decentralized network of #Ethereum nodes

11/ as opposed to $LDO, where decentralization starts at the DAO-level, with $RPL it starts at the node-level and anyone can run a node by staking >16 $ETH and spinning up a minipool, earning boosted rewards & comissions from stakers (see tweet 19)

source: @MessariCrypto

12/ this reduces centralization risks by design and introduces novel income opportunities for stakers ($RPL rewards & commission)

13/ but back to the data-driven part of the comparison

14/ in terms of TVL, @LidoFinance is the giant of the game with a total value locked of >$7.1bn

@Rocket_Pool's total value locked sits at $556m

source: @DefiLlama 