SVM vs EVM

Uncommon Core・2 minutes read

Uncommon Core discusses innovations in crypto like Eclipse and Solana to address scalability issues in Ethereum, focusing on performance improvements, fast transactions, and user experience enhancements in L2 architectures. The text also delves into parallel execution, state growth challenges, and optimizations to manage state size efficiently for optimal scalability in blockchains like Solana and Ethereum.

Insights

  • Solana and Eclipse address Ethereum's scalability issues by utilizing the Solana Virtual Machine (SVM) for fast, cheap transactions, contrasting with Ethereum's limitations, showcasing the importance of innovative L2 solutions in blockchain ecosystems.
  • Managing state size growth is a critical bottleneck for scaling blockchains like Ethereum, requiring efficient resource usage, client-level optimizations, and potential solutions like state expiration models or weak statelessness to reduce the burden on validators and enhance overall system efficiency.

Get key ideas from YouTube videos. It’s free

Recent questions

  • What are some key differences between Solana and Ethereum?

    Solana offers fast and cheap transactions with parallel execution, contrasting with Ethereum's limitations in scalability and transaction speed. Solana's architecture, including the Solana Virtual Machine (SVM), enhances scalability and execution efficiency, addressing Ethereum's bandwidth constraints and execution bottlenecks. Additionally, Solana mandates upfront declaration of state access for transactions, enabling non-conflicting transactions to run in parallel, unlike Ethereum's lack of this upfront declaration leading to sequential execution.

  • How do L2 architectures like Eclipse benefit Ethereum users?

    L2 architectures like Eclipse, which aim to bring Solana's innovations to Ethereum's Layer 2, provide instant confirmations with less trust, enhancing the user experience on Ethereum. Users benefit from L2 designs like Eclipse by simplifying gas token usage and network effects, ultimately improving scalability and transaction efficiency on the Ethereum network.

  • What challenges do developers face in Solana transactions?

    Developers in Solana transactions may face challenges related to complexity due to the requirement of upfront declaration of state access for transactions. While this upfront declaration enables parallel execution of non-conflicting transactions, it may pose challenges for developers in terms of managing state access lists and optimizing transaction efficiency. Better resource pricing mechanisms and strategies to prevent intentional state locking are needed to address these challenges and optimize efficiency in Solana transactions.

  • How does Solana address the issue of high demand for specific state pieces?

    Solana addresses the issue of high demand for specific state pieces, such as NFT mints, by implementing local fee markets to prioritize access to hot pieces of state. Users can pay higher priority fees for access to these hot state pieces, ensuring fair access and maintaining normal fees for other non-conflicting state pieces. While Solana's implementation of local fee markets is still rudimentary and not fully fleshed out, it aims to optimize transaction efficiency and prioritize access to high-demand state pieces.

  • What is the proposed solution to Ethereum's state size growth bottleneck?

    Weak statelessness is a proposed solution to Ethereum's state size growth bottleneck, shifting the burden of storing state from validators to builders. This approach involves sending witnesses with blocks to update relevant state pieces, reducing the need for local state storage and improving efficiency in accessing and updating data. Transitioning from Merkel trees to viral trees is also essential for efficient state storage and transmission, while state expiration or rent models could further address resource mispricing by pruning older state data or charging fees for maintaining active state.

Related videos

Summary

00:00

"Uncommon Core: Solana's Scalability Solutions Explored"

  • Uncommon Core explores crypto Big Ideas from first principles, hosted by John Shabono and Hu.
  • DBA, co-founded by John, focuses on performance improvements around VMS in the Solana ecosystem.
  • Investments in Eclipse and Solana were made due to scalability issues in Ethereum during bull markets.
  • Eclipse aims to bring Solana's innovations to Ethereum's L2, addressing scalability bottlenecks.
  • Solana's architecture offers fast and cheap transactions, contrasting with Ethereum's limitations.
  • Eclipse and Solana utilize the Solana Virtual Machine (SVM) to enhance scalability and execution.
  • Rollups like Eclipse and Solana address Ethereum's bandwidth constraints and execution bottlenecks.
  • Eclipse's focus on data availability, sampling, and proofs differentiates it from Solana's L2 approach.
  • L2 architectures like Eclipse provide instant confirmations with less trust, enhancing user experience.
  • Ethereum users benefit from L2 designs like Eclipse, simplifying gas token usage and network effects.

12:38

Trustless Validation on Ethereum and Solana Efficiency

  • The text discusses the concept of trustless validation on Ethereum, particularly in the absence of Layer 2 solutions.
  • Successful apps and funds can provide projects with a significant reputation boost, allowing them leeway in their actions.
  • A monthly research club is hosted by DBA, covering various technical topics with a technically inclined audience.
  • The latest meeting focused on VM optimizations, comparing EVM and SVM, with experts from Mona and EF contributing.
  • A virtual machine (VM) in the blockchain context executes code and updates the chain's state, akin to a software-based computer.
  • The SVM in Solana supports parallel execution, utilizing multiple cores efficiently for faster transaction processing.
  • Solana mandates upfront declaration of state access for transactions, enabling non-conflicting transactions to run in parallel.
  • EVM lacks this upfront declaration, leading to sequential execution of transactions due to potential conflicts.
  • Parallel execution is crucial for efficiency, but requiring state access lists may pose challenges for developers in terms of complexity.
  • Better resource pricing and mechanisms to prevent intentional state locking are needed to optimize efficiency in Solana transactions.

25:47

"Solana's Local Fee Markets and Scalability Challenges"

  • In a competitive environment like the men pool, high demand for a specific piece of state, such as an NFT mint, can drive up prices for the entire chain.
  • Solana addresses this issue by implementing local fee markets to prioritize access to hot pieces of state, allowing users to pay higher priority fees for access.
  • Local fee markets aim to ensure fair access by charging higher fees for hot state pieces while maintaining normal fees for other non-conflicting state pieces.
  • Solana's implementation of local fee markets is still rudimentary and not fully fleshed out, operating at the scheduler level and lacking determinism.
  • While priority fees can help, there is still a high incentive for latency race due to the continuous block production and propagation in Solana.
  • Ideas for improving the system include implementing a 1559-like mechanism for different pieces of state to adjust fees based on demand.
  • Parallel execution in Solana's SVM offers deterministic parallel execution, while other projects like Monad use speculative parallel execution with heuristics for transaction pipelining.
  • However, parallel execution alone does not solve all scalability issues, as nodes have various resource bottlenecks that need to be addressed holistically.
  • The key bottleneck for scaling blockchains is state growth, which refers to the snapshot of all current important data in the chain, leading to increased complexity and size.
  • Ethereum's primary bottleneck is state size growth, which poses a resource pricing problem as every transaction increases the state size permanently, impacting future node computations.

38:33

Efficient State Storage in Ethereum Validators

  • Validators update balance from 0 ETH to 1 ETH by accessing the Merkel tree, a data structure storing Ethereum state.
  • Accessing the Merkel tree in real-time is crucial during blocks, requiring quick access, not just on a hard drive.
  • Storing the entire state in RAM provides instant access but is resource-intensive and not feasible for all.
  • SSDs are practical for storing state in Ethereum clients due to the bottleneck of disk size and I/O costs.
  • I/O refers to reading from disk to RAM and vice versa, with RAM offering quicker access than SSDs.
  • The increasing state size in Ethereum poses challenges in efficiently accessing and updating data.
  • Weak statelessness is a proposed solution to shift the burden of storing state from validators to builders.
  • Weak statelessness involves sending witnesses with blocks to update relevant state pieces, reducing local state storage.
  • Transitioning from Merkel trees to viral trees is essential for efficient state storage and transmission.
  • State expiration or rent models could address resource mispricing by pruning older state data after a set period or charging fees for maintaining active state.

51:30

Efficient Client Management for Scalable Blockchains

  • Validators update the Merkel tree actively with all stats, but only merge it infrequently, making it easier to manage.
  • Different models exist for managing clients and proving certain aspects, leading to trade-offs.
  • Client-level optimizations, like storing frequently used state in RAM, can enhance efficiency.
  • Monad is rebuilding the client from scratch with a new database optimized for quick data retrieval.
  • Parallel execution is crucial for scaling blockchains, but managing state size is the current bottleneck.
  • Monet focuses on performance-related client optimizations and efficient database storage.
  • The goal is to efficiently use resources, solve bottlenecks, and execute transactions in parallel for optimal scalability.
Channel avatarChannel avatarChannel avatarChannel avatarChannel avatar

Try it yourself — It’s free.