NeonEVM: The First Parallelized EVM on Solana

GM GM, everybody. Welcome to what's going to be another great DevNTell. So, if you didn't know, DevNTell is a 30-minute window for builders, hackers, founders to come on the show and demonstrate what they've built. So, whether you are a big-time Web3 founder or weekend hacker or anything in between, this is your platform to showcase the awesome projects that you've built. And today, I am ecstatic to welcome Daria, who's a DevRel at Neon EVM. If you didn't know, Neon is an Ethereum Virtual Machine that allows developers to build and deploy Ethereum-native dApps on Solana, all from their existing codebase. So, if you stick around for today's show, you will see Daria give us an overview of Neon EVM, why you should use it to build your next dApp, and how you can get started today. All right, let's get into it.

GM GM, welcome to the show, Daria. Ecstatic to have you on.

Yeah, thanks for having me.

My pleasure, my pleasure. Yeah, so we're really looking forward to seeing all the fun stuff you have planned for us from the Neon EVM side. Believe it or not, we don't often get so many Solana-based projects coming on, but it's really nice to see one make it finally on the show. So, I guess before we begin, do you want to give a brief introduction about yourself in case folks aren't familiar?

Yeah, sure. So, my name is Daria and I'm a DevRel at Neon, and before that, I was a DevRel at SKD, where I was also helping developers onboard. And before, before that, I was working as a blockchain dev, so I was like a Web3-native, I guess, engineer and then I switched to being a DevRel.

Excellent, awesome, awesome. And how did you kind of start your journey in tech and development and end up in Web3? I'm just curious to hear what your inspirations were for coming into Web3.

Okay. So, I mean, when I was in high school, we had a computer lessons, whatever, and we were programming this obscure, I don't know if anyone else does it, but we were like programming a turtle or something and I was super good at it. So, I kind of got more into coding after that, and I just went to study computer science in college. And after that, I kind of didn't really have time to do anything else. I almost from the beginning picked up Web3 and smart contracts and it was about three, four years ago, and started working as a blockchain dev and just realized that it's way more fun and the atmosphere is much more interesting than in Web2 companies. So, now I kind of don't imagine myself going back. And so, yeah, I spent some time doing just the engineering and then I became a DevRel. It was actually kind of funny story because like a recruiter reached out to me on LinkedIn and said, 'Oh, so there is this job where you can kind of tell developers about how to use your product, also travel, like speak at conferences, make technical content and also like code whatever fun project you can make up with this.' And I was like, 'Okay, this sounds like a scam, so I'm not going to answer that.' So, I ignored it for like 10 days, and then I was like, 'Okay, I have nothing to lose, I'll just check it out,' and that's how I became a DevRel.

Awesome, awesome, living the dream. I guess, would you ever go back to being a developer now, living the DevRel life, or?

I don't know. I think it's like, like being a DevRel is too fun compared to other jobs because you get to be creative when you don't want to go into coding, and when you don't want to be creative, you can just go and like do the technical part, so it's kind of like best of both, I think. So, if I had to, I would definitely miss the creative part.

Yeah, yeah, totally fair and great answer. Yeah, I guess what inspired you to join Neon over any other Web3 company? Was there something that pulled you to them or something that really stood out to you?

I think it's like the technology, most of all, how you can make a completely different VM process EVM bytecode. I thought it was very cool. And also I am, like I've started in Ethereum, so I'm always kind of always leaning more towards Ethereum out of all things. So, for me, it's kind of like, I don't know, I like to think that you're bringing essentially, you're giving Ethereum dApps the access to this parallelized VM where they can benefit and they can scale without issues. So, I think that's like a really cool part, and you also bringing EVM dApps to like completely new ecosystem where they can function but and also get access to all of this new liquidity, new users, yeah, and stuff like that.

Awesome. Yeah, fantastic answer. And I guess with that, I think it's a perfect time to segue into what you have prepared for us today.

Okay. Yeah, I have like a little overview of what Neon EVM is. So, I'm going to share my screen. Hopefully, it goes well. Cross fingers. Yeah. Okay. You should see it now, right? Yeah, it's on the screen. Go for it. So, yeah, I just wanted to quickly go over what Neon EVM is. So, basically, Neon EVM has multiple components, but the main component which kind of does all of the like work that allows your dApp to function normally on Solana is the Neon EVM program that is deployed on Solana. And it is basically taking your EVM transaction and wrapping it to be a Solana transaction that can be executed on Solana blockchain. And by doing this, you kind of get benefits of both Ethereum and Solana. So, like coming from Ethereum, you have your dApp in Solidity and there is no code changes required. You can do it in your familiar languages like Solidity or Vyper, which are both, I think, at least to me seem like a much easier choice, especially if you're starting out versus like framework like Anchor. You can also use all of your Ethereum tooling that you're used to, like MetaMask, Hardhat, and most importantly, like Foundry, where you can do all of this comprehensive testing. Like the API that we provide is also identical to Ethereum. You have the same signature, same token standards also are compatible with Neon.

And then in addition to all of this, you also get parallel execution that Solana gives you, like relatively lower fees, especially if you're comparing with Ethereum, and then higher transaction speed because all of your transactions are executed on Solana itself, and then you can also access everything in Solana's ecosystem and I'll actually go into how you can do that from your EVM dApp further. So, let's look at, so we are having a mainnet running all over a year now, and here's some stats from it. So, let's look at the ecosystem.

So, as far as ecosystem, we are compatible with MetaMask and also like with WalletConnect, with many other EVM wallets. You also have deBridge as a bridge, so you can use it to bridge your tokens from like other EVM networks. And we have our own kind of, it's not exactly a bridge, but you can basically wrap your tokens from Solana and transfer them to Neon, and it's not a bridge because Neon is not really an L2. And then you have also all of the indexing infrastructure that you can use on Ethereum also on Neon, all of the dev frameworks as well, and the IDE, like even Remix you can use.

And then, so yeah, here's some bridges, and it actually shows like the difference between using deBridge and using Neon Pass. So, you can see that here, Neon Pass is kind of transferring SPL tokens from Solana to Neon in a more native way, rather than having like this pattern that most bridges use where like you lock tokens on one network and release them on the other.

And here's the again the overview of the dev tooling I just mentioned. And yeah, for me, like my one of my favorite parts is actually that you can use Foundry with Neon because it has like the most comprehensive, I think, testing suite out of all. And you also can use those libraries and like for those who prefer Wagmi and viem to Ethers, it also supports Neon. So, you basically have all of your favorite like best functioning dev tools that you're used to on other EVM chains.

And here is a little overview of Neon architecture. So, again, if you have a dApp frontend and your user interacting with it, you don't really notice any difference because you submit your transaction from your MetaMask to this frontend and it goes, it behaves like Ethereum transaction, just instead of being forwarded to an Ethereum RPC node, it goes to our proxy, and that proxy interacts with Neon EVM program that is deployed on Solana.

And here is some little overview of like how classical Solana program works. So, the most important part to remember is that basically Solana programs can create data accounts and store data on them, and they can also invoke other programs. And Neon EVM takes advantage of that. So, this is how it basically stores its data and like the Ethereum Virtual Machine part, and Ethereum accounts on Solana network, and how it facilitates execution of those transactions.

And okay, here we have an example of how you can pack your essentially how Neon packs an EVM transaction into Solana transaction. So, it has like a list of accounts and a list of contracts, and Solana needs that for parallel execution. Or then you have the index of the address of Neon EVM program, and we'll actually see where it's deployed on Solana later when I show you the like a little demo that I have. And here we have all of the Ethereum compatible data.

And storing all of that kind of in a Solana compatible way allows you to facilitate this parallel execution shown here, where like if you have transactions that kind of are independent of each other, you can go ahead and take advantage of the throughput and speed that Solana offers you.

And actually, like my favorite part that we are working a lot on lately is composability. So, composability is basically the feature of Neon EVM that allows you to call Solana programs from your EVM dApp. So, that means that if you have like your Solidity contract instead of having kind of to switch or learn Rust or create another project, you can just call a Solana program from your Solidity code. And I wanted to show a little bit more on how you can do it.

So, here is a little scheme that I made of how a normal token transfer happens on Solana. So, basically, you have like your account one and account two, and you have token accounts that are associated with the both of those, and you have the token itself and then the Solana token program that kind of does all the work. So, essentially, what happens is you call Token Program and you give it all of the inputs that are here, so like source, destination, and the token, and it goes ahead and like transfers the amount that you want. And like that's how it that's like on a higher level how it happens on Solana.

But with Neon, you can do it from a Solidity smart contract, and it would look kind of like this, where you call Neon EVM on Solana and the Neon EVM then outputs like a Solana instruction and calls a Solana program. It can be like a Token Program, but it can be really anything, like any other program. And essentially, it would look like this: we basically have this pre-compiled contract on Neon that has this interface, and I think the most important function is execute. So, you can think about it like a little bit as a delegate call, where you can just forward the data of the instructions that you want to call and it'll go ahead and like forward it to any Solana program.

So, this is an overview of how you would do the same thing shown here, but with essentially like using Neon EVM. So, it looks very similar. It's just you have your Neon EVM account, so like you can think about it as your MetaMask and it has EVM address, and then you take this EVM transaction and send it to Solidity contract, and then this Solidity contract has the interface of this pre-compiled that is deployed on Neon. And in this case, we're doing like a transfer. Hopefully, you can see. Yeah, we're doing a transfer, so it will take this data and just call transfer on like the Solana Token Program because that's what we have as the program that we want to interact with. And in its turn, the Token Program will manage like the token transfer from account one that belongs to our EVM account to the destination account. Yeah, so that's like the main cool part that I wanted to go over today.

And we also have like a builders chat which you can join on Telegram if you want to ask more questions about anything regarding Neon. So, yeah, feel free to join, and here's some links relevant to Neon. And do you have still time for a demo?

Oh, yeah, definitely.

Cool. Sorry, I forget to like breathe sometimes with this presentation. It's all good, you're excited, you're excited, it's all good. Sure, sure. Okay. So, yeah, today I just wanted to show really quickly how you can deploy your EVM project on Neon, and we'll see how it is reflected on Solana. So, I'm just going to re-share my screen.

And audience, while Daria is doing the demo, please feel free to ask any questions in the chat and we will bring them up as we go.

Yeah, so here I have like just a normal like hello foundry project that you get when you just run like your first like foundry init. And what I did is I only changed the RPCs.

Sorry, Daria, could you zoom in like maybe once?

One sec. I don't know how. Okay. On your keyboard, if you do Command Plus, it will zoom it. Yeah. Okay. Is it better? Yeah, that's that's good.

Okay, cool. Yeah, just simple counter contract, doesn't really matter. So, yeah, basically, like what I did, I just started a foundry project and I only changed my .env file, which I can't show because it has my private key, but I just changed like I went to Chainlist, I got the Neon RPC and Neon Chain ID from there, replaced that, put my like MetaMask private key, and that's it. Like you don't really need to change anything else for it to be compatible with Neon. So, you just do like okay, so you just run 'forge create', like your RPC URL that you have in the .env file, private key, and the contract. And you also need to do '--legacy' because we're yet we don't yet support like the 1559 transactions, but we're working on like supporting them really soon, so you'll be able to also do like gasless stuff as well, which is really cool. So, we're going to run this and hopefully, it's going to work.

Okay, cool. Yeah, so it's deployed. We're going to go to Neon Scan. Like we have the block scout, but it doesn't show Solana transactions. So, we're going to use this one. Okay, this is our transaction and it was just finalized. Yeah. So, we created like this counter contract.

And what's interesting is here you can unwrap this and go and see the Solana transaction. And let's go and see it. So, what happens here is yeah, here you can see like our Neon EVM program deployed directly on Solana. And that's how you can take advantage of this composability feature where you don't really need like a bridge or a cross-chain messaging protocol if you want to interact with with Solana from Neon. And here we have all of the logs for our transactions, so it's account creation for the for our new contract and like all of the fees are also taken care of. And here you can see like all of the instructions that were called during this.

So, I guess like the main takeaway that I wanted to show is for any transaction that you do on Neon, like we can check actually some other one as well. So, if we go here, it's going to have like one or more Solana transactions. So, it's kind of natively integrated with Solana, and that enables you to do many cool things without kind of having to worry about communicating between like different chains. And you can also natively access liquidity, like you can even call from your EVM dApp you can call like a swap on Orca swap because of the fact that Neon EVM is deployed on Solana and also because Solana allows for cross cross program invocation. So, what's going to happen is Neon EVM is going to call another program for you and your like swap on Orca swap or anything else is going to take effect, and I think it's like super exciting because it's kind of a different approach to interoperability because usually you have like a, yeah, it's just like very different from what other people are doing, and I think it's like super exciting in that way to have a different approach. So, yeah, I think it's about it what I wanted to show on my screen. Okay, I have to find it. Okay.

Yeah, that looks very very fascinating. So, if I understand correctly, I can just take the I can just take my existing EVM code, my smart contract code, and deploy it on Neon EVM and it'll basically just work like magic.

Sort of. So, there is there is like a little bit of okay, so it's mostly, yeah, it's compatible. There's like some things that you can do to like optimize it in a way because of some kind of peculiarities of how Solana stores data because of its parallelized nature. So, Solana has this thing where it limits like the number of accounts kind of touched in your transaction, I think it's like at the moment 64. So, this like a small thing where like if you have a mapping that has like too many entries, like Solana has to create like another program derived account, and we are trying to like overcome this, and it will be also very helpful when Solana increases this limit. So, we advise you like if you can, you should avoid using like big mappings, but if not, it's still like most likely like 99% it's going to be compatible unless it's like a very hefty contract, which is also like people rarely do in Solidity anyway because it's like gas intensive.

Gotcha, gotcha. So, yeah, basically, it works like magic. Like magic, that's right. And just trying to picture it in my head, so say I have a dApp, right, that I have somebody connect their wallet to and pay for something with crypto. So, if I have my EVM the backend of it deployed through Neon EVM and it ends up on Solana, if the end user pays for something with ETH, I think you mentioned it, but does Neon EVM take care of the bridging automatically to say, 'Oh, this person paid with Ethereum ETH, I have to go and do swapping on the backend so that the transaction can properly settle'?

Well, in that way, we like don't really touch Ethereum, so it's kind of different, like our native token is not ETH, so we take like gas is paid in the native token and I'm not sure, like maybe wrapped Ethereum exists on Neon network, I don't know, but I think the answer would be no because we don't really interact with Ethereum ETH in any way, I would say. But if you go ahead and like I don't the main feature is you can just use your EVM without having to like create a Solana wallet. You can use, sorry, not your EVM, your MetaMask.

Yeah. Cool, cool. Yeah, yeah, excellent, great answer. And I guess is there has there been any really interesting dApps being developed that have caught your eye using Neon that you could highlight?

I think I would definitely want to highlight like IcecreamSwap, because it's like identical to the IcecreamSwap that you have like on mainnet, on other networks. I think it's like really cool that they went ahead and like deployed this very used protocol on Neon where now like users kind of can also tap into Solana ecosystem just with their like normal wallet. And another one, like there's a few like I think on our website there's like an ecosystem page and it has a few cool dApps, like another one is LendOS where you can like stake your tokens. So, there's actually like a bunch of cool ones. We also have also Neon is like we have a few of NFT game dApps deployed as well, so that's I don't know, like those are cool too.

Yeah, sounds like it, and I'm sure it's only going to those kinds of apps are only going to increase as time goes on here. We have a question from Jonathan, a couple actually. So, he wants to confirm that there is nothing different for the developer experience or user experience, it's just translating and executing on Solana.

Yeah. Also, I saw someone asking for Telegram group link, so I posted it in our private chat. I can't type in the public one for some reason, I don't know, so maybe you could like forward it there. So, there's nothing different for developer experience or user experience. Yeah, so yeah, you can basically say that, like you're not going to notice much difference except for some RPC methods are not supported. Like again, 1559 estimate fee is not supported at the moment. It will be, hopefully, soon, but yeah, overall, you can say that it is pretty similar.

Great question, great answer. As we're coming towards the end of the session, is there anything you can share around the roadmap for Neon EVM? Any any alpha you can maybe leak as to like what's coming up?

Yeah, so we actually had like a kind of exciting announcement yesterday about Neon going Solana native. So, that means that we are going to work more towards providing like a seamless experience for EVM builders to interact with Solana and like connect EVM builders and users with Solana's liquidity. So, that's like something we're really working hard on, and I think it's very exciting because Solana recently had like a huge influx of liquidity, I think it was like from Ethereum or like versus Ethereum, I don't remember, like I saw the graph. So, yeah, we are actively working on that, and I would also say like keep an eye on announcement for next week, hopefully. We also have like another exciting thing to share from the roadmap that I can't say yet, so.

Ooh, ooh, excellent, excellent, looking forward to that. And maybe maybe that big spike you mentioned before was Iggy Azalea and her venture into crypto. Oh, yeah, and we also, sorry, yeah, we just have like a points program. So, if you check out Twitter on Neon, like you can still take part in the points program where you rewarded for like on-chain activity.

Excellent, and last question, if people want to start hacking with Neon EVM, what's the best place for them to kind of get a quick start? Would it be the docs? Is there a template repo people can fork?

There is docs. So, there's no template repo because we realized that it's as easy as like changing the RPC. So, you don't really need to, you just start like a project, again Foundry, I don't know, like Wagmi, whatever setup you prefer, and like just go ahead, like go to Chainlist and start copy the links and start hacking. Other than that, I would say like, yeah, the best place to start is docs and then the Telegram group for specifically for builders that we have, like you can go ahead, you can ask any questions that you want and we'll like do our best to help you.

Amazing, amazing. And yeah, you heard it from Daria. It's as pretty simple. So, if you want to start experimenting with your existing dApps on the Solana network, Neon EVM is your go-to. And with that, I just want to say a huge thank you to Daria. Thank you so much for coming on the show today and giving us that wonderful overview. And yeah, really interested to see how folks use Neon EVM to build amazing dApps going forward. Okay, thank you for having me. It was super fun. I didn't even notice like already 30 minutes past. Yeah, yeah, amazing. Yeah, a lot of people have quite a fun time here on the show, and that's what we love to see. And yeah, with that, I just want to wish everybody a very happy Friday, happy weekend wherever you may be, and we will catch you back here next week for another great episode DevNTell. And just a brief announcement, if you didn't know, DevNTell has a new website, devntell.com, and for you to check out as well if you would like. And we are now hosting all our podcasts not only on YouTube and X, but additionally on Spotify and Apple Podcasts as well, so you have your plethora of choices on how you want to listen to the podcast going forward. But yeah, with that, we will catch you all back here next week for another great week of DevNTell. Cheers. Bye.