Bridging the gap between Ethereum and Solana: Neon EVM and Solang

Interoperability of Solana and Ethereum

Ethereum has established itself as the dominant blockchain protocol to execute smart contracts. Some may argue that it offers the most advanced infrastructure for dApp developers and end users. However, Ethereum suffers from significant technical constraints (specifically concerning its TPS and TTF: transactions per second and time to finality, respectively). Furthermore, transactions within Ethereum are also relatively expensive. An Ethereum-native solution to such problems is L2 scaling; however, even L2s and sidechains fail to address such issues meaningfully.

In contrast to Ethereum, Solana was designed to support high-speed and lower-cost transactions. This makes Solana a viable solution for high-throughput, low-value transactions while providing transparency and immutability. As of Q2 2023, Solana handles more transactions than any other L1 blockchain.

This division in the L1 landscape, while a natural outcome of a global free market and the blockchains’ technical strengths, negatively impacts the builders in the blockchain space. Until 2023, dApps were tied to one or other of these major blockchains, unable to access users on the neighboring ecosystem. With the rise of decentralized applications (dApps) and the increasing demand for blockchain scalability, interoperability offers huge potential.

In July 2023, two prominent solutions that aim to bridge the Ethereum and Solana ecosystems have entered the arena as game changers, Neon EVM and Solang. Specifically, both extend the reach of the popular programming language, Solidity, to the Solana ecosystem. However, how they do this differs significantly. This article discusses the functionalities of Neon EVM and Solang, highlighting their different, yet synergistic, relationship and how they both contribute to cross-chain development.

Neon EVM and Solang: a high-level overview

What is Neon EVM?

Neon EVM is an Ethereum-compatible ecosystem deployed on Solana that enables Ethereum applications to run on the Solana network as native EVM applications, extending the capabilities of Ethereum dApps by leveraging Solana’s high-speed and lower-cost environment.

The experience of sending transactions to applications running on the Neon EVM is indistinguishable from any EVM. Ethereum-like transactions received at public RPC endpoints are repackaged as Solana-compatible by the Neon Proxy. This allows Ethereum-native developers to create dApps in any Ethereum-compatible language, of which Solidity is just one example.

Neon EVM enables developers to use Ethereum-native toolchains on Solana. This includes popular wallets such as MetaMask and the wallet protocol, WalletConnect. Similarly, frameworks familiar to Ethereum-natives, such as Truffle, Hardhat, and more, are supported. Furthermore, it is possible to integrate Ethereum-native explorers such as Blockscout. What makes Neon EVM unique among EVMs is that those transactions are recorded on Solana.

Neon EVM enables dApps to deploy as they would to any EVM while transacting at lower costs. Importantly, it does this while abstracting away the differences between Solana and Ethereum’s program, storage, and compute models. The Ethereum-native developer can remain Ethereum-native and does not need to become an expert in the significant differences between Ethereum and Solana.

Neon EVM abstracts away the differences between Solana and Ethereum’s program, storage, and compute models so that Ethereum-native developers can simply deploy their dApp to an EVM that uses Solana as the settlement layer without any deep knowledge of Solana.

 

What is Solang?

Solang is a Solidity compiler — compiling smart contracts written in Solidity for the Solana Virtual Machine. It compiles to produce SBF (Solana Bytecode Format) contract code. Until the launch of Solang, developers required fluency in Rust or other Solana-compatible languages, such as C or C++, to create dApps on Solana.

Neon EVM vs. Solang

Let’s use an analogy to help clarify the difference between Neon EVM’s service and the Solang compiler. In the mobile app space, tools such as Xamarin provide cross-platform mobile app development. Developers create their app in C# and then compile it to Android and iOS. Xamarin abstracts away the need for mobile app developers to specialize in both mobile operating systems.

Neon EVM provides a similar abstraction layer to Xamarin: it provides a platform via which developers can code in an EVM-compatible language such as Solidity and deploy a dApp developed for one operating system, in this case, the EVM, on another operating system, i.e. Solana. Neon EVM abstracts away the differences between the two L1s — by executing EVM code on Solana. From a developer’s perspective, the main difference between using Neon EVM and any other EVM is simply changing the RPC endpoint that the transaction request is sent to. The same opcodes are supported, and transactions are processed as per any EVM. This applies to the majority of dApps (with the delta described in the Neon EVM docs).

Solang does something very different. Solang provides dApp developers with the ability to code in Solidity rather than Rust or C/C++ to develop dApps for Solana. Just as Xamarin makes C# a more versatile language, Solang gives Solidity a wider reach. However, what Solang doesn’t do is abstract away the very different memory, compute, and execution models of Solana and Ethereum. To settle to both Ethereum and Solana, it will be necessary for developers to understand the limitations of the interoperability of the two systems and make accommodations for these in the design and development of their dApps. Similarly, the dApp’s front and backend services must interact with Solana’s APIs according to Solana’s rules. In short, a dApp developed for Solana using Solidity remains native to Solana.

By using Neon EVM, the complexities of the differences between Solana’s base layer and Ethereum’s do not need to be accommodated by developers. Instead, the Neon Proxy repackages the Ethereum-like transaction into a Solana-compatible transaction. This allows developers to bring their dApps from Ethereum to Solana with minimal reconfiguration of the codebase.

What do Solang and Neon EVM share in common?

In the Solana ecosystem, Neon EVM and Solang serve different yet essential roles. What both Solang and Neon EVM do is enable Solidity developers to develop Solana-compatible dApps. Solang enables developers to use Solidity, a language they are familiar with from the Ethereum ecosystem, to write Solana-executable programs. Neon EVM enables Solidity developers to quickly migrate existing EVM-compatible projects to Solana.

Token Access and Interoperability

Both Neon EVM and Solang provide access to Solana-native tokens, SPL tokens. Solang-developed dApps deployed to Solana will provide direct access to SPL tokens. In contrast, Neon EVM contains a precompiled contract that provides an ERC-20 interface to access SPL tokens from Ethereum-compatible wallets.

Migrating Ethereum Projects to Solana

For Ethereum developers looking to migrate their projects to Solana, Neon EVM provides an indispensable tool. Developers can continue using the Ethereum toolchain, such as MetaMask for transaction signing and BlockScout for network exploration. On the other hand, Solang offers the necessary tooling for direct Solana program development, granting developers the flexibility to use familiar tools across different environments.

Conclusion

July 2023 saw a revolution in the interoperability of Ethereum and Solana with the launch of Neon EVM and Solang — with each bridging the delta between the Ethereum and Solana ecosystems in complementary ways: facilitating a harmonious integration between Ethereum and Solana.

Developers aiming to create deep integrations between Ethereum applications and Solana programs can benefit from both tools.

For those who want to develop Solana-native dApps from scratch and build them to be compatible with the programming, compute, and memory models of Solana, while retaining Solidity as the codebase, Solang is the perfect solution. While for those dApp developers who wish to leverage Ethereum’s compute layer to transact on Solana to take advantage of Solana’s parallel transaction capabilities and lower transaction fees; with only minimal reconfiguration of the existing codebase of their dApp, Neon EVM is waiting to accept your transactions.

Links and resources

Find the Neon EVM community on Twitter or Discord. Additionally:

• Get involved by becoming one of the supported Early Builders
• To choose a public RPC endpoint, see ChainList
• For a high-level overview of the technical architecture and features of Neon EVM, the whitepaper is available at NeonEVM.org/whitepaper.pdf
• View Neon EVM transactions settled to Solana with the NeonScan or BlockScout explorers