Solana Changelog: Faster getProgramAccounts, SIMD-96 Approved, and Anchor Types in Kinobi

In the ever-evolving landscape of blockchain technology, Solana continues to make significant strides in improving its ecosystem. The latest episode of the Solana Changelog, featuring Nick and special guest Brianna from the DevRel team at the Solana Foundation, brings us up to speed on the most recent developments, optimizations, and community contributions. From performance enhancements to governance decisions and developer tools, this changelog covers a wide range of topics that are shaping the future of Solana.

Optimizing Transaction Fee Calculations

One of the key optimizations highlighted in this changelog is the improvement in transaction fee calculations. A recent commit has addressed the issue of redundant fee recalculations, which were occurring multiple times during transaction processing. This optimization allows for the reuse of calculated fees, streamlining the process and potentially improving overall network efficiency.

The commit in question is a refactor that aims to reuse calculated fees, as seen in the pull request: refactor: reuse calculated fees. This change is expected to reduce computational overhead and contribute to the overall performance of the Solana network.

Enabling CPI Tracking by Default

Another significant update comes in the form of enabling Cross-Program Invocation (CPI) tracking by default. This change, implemented through the pull request Enable CPI tracking by default, has been fully integrated into the current codebase.

The primary benefit of this update is the simplification of test cases. Developers will now find it easier to simulate transactions, serialize them, and associate events within their testing environments. This is particularly valuable for those working with compression-related features, as it resolves previous limitations in testing compressed data structures using Solana program tests.

Dramatic Speed Improvements for getProgramAccounts

Perhaps the most exciting optimization in this changelog is the substantial speed increase for the getProgramAccounts (GPA) RPC call. This improvement addresses a long-standing pain point for Solana developers, as GPA has historically been one of the slowest operations in the Solana ecosystem.

The optimization comes from a commit that adds a variable sort_results to the RPC config when performing getProgramAccounts operations. This change allows for bypassing the default sorting behavior, resulting in significantly faster query times.

To illustrate the impact of this optimization, benchmark results were shared:

• For stake accounts:

  • Before: Total time of approximately 8 minutes
  • After: Reduced to about 2 minutes
  • Speed improvement: 430%

• For Serum accounts:

  • Before: Total time of approximately 11 minutes
  • After: Reduced to about 3 minutes
  • Speed improvement: 240%

These improvements represent a massive leap forward in query performance, which will greatly enhance the developer experience and potentially enable more efficient dApp operations on the Solana network.

SIMD-96: Full Priority Fees to Validators

A significant governance decision has been made with the approval of SIMD-96 (Solana Improvement Document 96). This proposal, which has now passed with a majority vote from validators, will change how priority fees are distributed within the Solana network.

Currently, when users pay priority fees to have their transactions processed faster, 50% of these fees are burned (removed from circulation), while the other 50% goes to validators. With the implementation of SIMD-96, 100% of priority fees will be awarded to validators.

This change is expected to provide additional incentives for validators, potentially strengthening the network's security and performance by making validation more rewarding. The proposal can be viewed in detail at the SIMD-96 GitHub page.

The voting process for SIMD-96 was conducted using a stake-weighted system, ensuring that the decision reflected the consensus of the network's major stakeholders. With the proposal now approved, it will go through the standard feature gate activation process before being implemented on the mainnet.

Updated Fee Documentation

In light of the changes to fee structures and the approval of SIMD-96, the Solana documentation team has updated the official fee documentation. The revised documentation, available at solana.com/docs/core/fees, now provides more comprehensive information on all aspects of fees and compute costs within the Solana ecosystem.

This update is crucial for developers and users alike to understand the economic model of Solana and how transactions are priced. The documentation covers various types of fees, including base fees, priority fees, and compute unit consumption. It also explains how these fees are calculated and distributed within the network.

The Solana team encourages community feedback on the documentation. Users can easily contribute by using the "Edit page" button, which directs them to the GitHub repository where they can suggest improvements or report any inaccuracies.

New Guide for Rust Developers

To further support the growing developer community, Solana has released a new guide specifically tailored for experienced Rust engineers looking to transition into Solana development. This guide, titled "Getting started on Solana with Rust experience," bridges the gap between traditional Rust programming and Solana's unique architecture.

The guide covers essential Solana core concepts and draws parallels with familiar Rust paradigms. It's designed to help Rust developers quickly understand how their existing skills can be applied to building Solana programs. Topics covered include:

• Solana's account model and how it differs from traditional state management in Rust
• The concept of programs in Solana and how they compare to Rust libraries
• Handling of transactions and instructions in the Solana context
• Best practices for writing efficient and secure Solana programs

This resource is invaluable for expanding the Solana developer ecosystem and lowering the barrier to entry for skilled Rust programmers.

Fibonacci in eBPF Assembly: A Compute Efficiency Showcase

One of the most intriguing community contributions highlighted in this changelog is a Fibonacci sequence implementation written in eBPF assembly for Solana. Created by Dean from WBA and Turbine, this project serves as an impressive demonstration of low-level optimization on the Solana platform.

The implementation, available on GitHub, showcases the potential for extreme compute efficiency when working directly with eBPF assembly. By bypassing higher-level language abstractions, this Fibonacci calculator achieves remarkably low compute unit consumption.

While writing entire programs in assembly is not a practical approach for most developers, this example illustrates the performance ceiling of Solana's virtual machine and serves as an educational tool for understanding the underlying mechanics of program execution on the platform.

The project includes a comparison table demonstrating the compute efficiency of the assembly implementation against other methods:

| Language   | Compute Units |
|------------|---------------|
| Assembly   | 150           |
| Rust       | 254           |
| TypeScript | 373           |

These results underscore the potential for optimization at the lowest levels of Solana program development, which could be crucial for applications requiring maximum efficiency.

Kinobi: Now Supporting Anchor Types Generation

Metaplex, a key player in the Solana NFT ecosystem, has announced an important update to their Kinobi tool. Kinobi, which is used for generating client libraries for Solana programs, now supports the generation of Anchor IDL (Interface Description Language) types for native Solana programs.

This update, announced via Metaplex's Twitter, is a significant step forward for developers working with both native Solana programs and those using the Anchor framework. The ability to generate Anchor types for native programs bridges the gap between these two development approaches, potentially simplifying integration and improving code reusability.

Key benefits of this update include:

• Easier interoperability between native Solana programs and Anchor-based projects
• Improved type safety when working with native program interfaces
• Streamlined development process for projects that utilize both native and Anchor programs

This enhancement to Kinobi demonstrates the ongoing efforts within the Solana ecosystem to improve developer tools and reduce friction in the development process.

Stack Exchange Community Engagement

The changelog also highlights the active Solana community on Stack Exchange, recognizing top contributors for their efforts in sharing knowledge and helping fellow developers. The current week's top contributors were mentioned:

1. Jimmy (leading the week)
2. Chalda (ranked third)
3. Mitchell Dennis
4. Joey (from Stockpile, now with Squads)

This acknowledgment underscores the importance of community-driven support and knowledge sharing in the Solana ecosystem. The Stack Exchange platform serves as a valuable resource for developers seeking answers to technical questions and fostering collaborative problem-solving.

Conclusion

This edition of the Solana Changelog showcases the platform's commitment to continuous improvement and community engagement. From significant performance optimizations like the faster getProgramAccounts to governance decisions such as SIMD-96, Solana is addressing both technical and economic aspects of its ecosystem.

The updates to developer tools and documentation, including the new Rust developer guide and Kinobi's Anchor type support, demonstrate a focus on improving the developer experience and lowering barriers to entry. Meanwhile, community contributions like the eBPF assembly Fibonacci implementation highlight the innovative spirit within the Solana community.

As Solana continues to evolve, these changes and improvements are likely to contribute to its growing adoption and solidify its position as a leading blockchain platform for high-performance decentralized applications.

Facts + Figures

• getProgramAccounts (GPA) speed improvements:

  • Stake accounts: 430% faster (from ~8 minutes to ~2 minutes)
  • Serum accounts: 240% faster (from ~11 minutes to ~3 minutes)

• SIMD-96 approved: 100% of priority fees will now go to validators, up from 50% previously

• Fibonacci sequence implementation in eBPF assembly uses only 150 compute units, compared to 254 for Rust and 373 for TypeScript

• Solana documentation for fees updated at solana.com/docs/core/fees

• New guide released for Rust developers transitioning to Solana development

• Metaplex's Kinobi tool now supports generating Anchor IDL types for native Solana programs

• Three significant commits highlighted:

  1. Optimization of transaction fee calculations
  2. Enabling CPI tracking by default
  3. Adding a variable sort_results to RPC config for getProgramAccounts

• Stack Exchange weekly rankings feature Jimmy as the top contributor

Questions Answered

What improvements have been made to getProgramAccounts (GPA) in Solana?

The getProgramAccounts RPC call in Solana has received a significant speed boost. By adding a variable sort_results to the RPC config, developers can now bypass the default sorting behavior, resulting in dramatically faster query times. Benchmark results show improvements of 430% for stake accounts (from ~8 minutes to ~2 minutes) and 240% for Serum accounts (from ~11 minutes to ~3 minutes). This optimization addresses a long-standing performance bottleneck in Solana development.

What is SIMD-96 and how does it affect Solana validators?

SIMD-96 is a Solana Improvement Document that has been approved by a majority vote of validators. It changes how priority fees are distributed within the Solana network. Previously, 50% of priority fees were burned and 50% went to validators. With SIMD-96, 100% of priority fees will now be awarded to validators. This change is expected to provide stronger incentives for validators, potentially enhancing network security and performance by making validation more rewarding.

How has Metaplex's Kinobi tool been updated?

Metaplex has updated their Kinobi tool to now support generating Anchor IDL (Interface Description Language) types for native Solana programs. This enhancement bridges the gap between native Solana program development and projects using the Anchor framework. It allows for easier interoperability, improved type safety, and a more streamlined development process for projects that utilize both native and Anchor programs within the Solana ecosystem.

What new resources are available for Rust developers interested in Solana?

Solana has released a new guide titled "Getting started on Solana with Rust experience." This guide is specifically designed for experienced Rust engineers looking to transition into Solana development. It covers essential Solana core concepts, drawing parallels with familiar Rust paradigms, and explains how existing Rust skills can be applied to building Solana programs. The guide addresses topics such as Solana's account model, program concepts, transaction handling, and best practices for efficient and secure Solana program development.

What does the eBPF assembly implementation of the Fibonacci sequence demonstrate about Solana?

The eBPF assembly implementation of the Fibonacci sequence, created by Dean from WBA and Turbine, showcases the potential for extreme compute efficiency on the Solana platform. This implementation uses only 150 compute units, compared to 254 for Rust and 373 for TypeScript. While not practical for most developers to write entire programs in assembly, this example illustrates the performance ceiling of Solana's virtual machine and serves as an educational tool for understanding low-level program execution on the platform.

How has the documentation for Solana fees been updated?

The official Solana fee documentation at solana.com/docs/core/fees has been comprehensively updated. It now provides more detailed information on all aspects of fees and compute costs within the Solana ecosystem. The revised documentation covers various types of fees, including base fees, priority fees, and compute unit consumption. It also explains how these fees are calculated and distributed within the network. This update is crucial for both developers and users to understand Solana's economic model and transaction pricing.

What changes have been made to CPI tracking in Solana?

Cross-Program Invocation (CPI) tracking has been enabled by default in the Solana codebase. This update simplifies test cases for developers, making it easier to simulate transactions, serialize them, and associate events within testing environments. The change is particularly beneficial for those working with compression-related features, as it resolves previous limitations in testing compressed data structures using Solana program tests.

How is the Solana community contributing to knowledge sharing?

The Solana community is actively engaged in knowledge sharing through platforms like Stack Exchange. The changelog highlights top contributors on Stack Exchange, recognizing their efforts in answering questions and helping fellow developers. This community-driven support system is crucial for fostering collaborative problem-solving and serves as a valuable resource for developers seeking answers to technical questions about Solana development.