A Solflare developer reflects on moving from Ethereum to Solana — what transferred, what didn't, and why the biggest lesson wasn't technical at all.
I recently changed jobs, moving from the Ethereum ecosystem to the Solana ecosystem. My previous role required me to be familiar with the inner workings of Ethereum, while my current role requires me to build things quickly on top of Solana.
It has been an interesting experience and transition so far, and it has taught me that sometimes the presence or absence of tools does not make a challenge easier or harder; the tools just force us to look at challenges differently.
Ethereum taught me to disassemble the engine; Solana taught me how to start the car
During my time in the Ethereum ecosystem, I worked closely with the EVM (Ethereum Virtual Machine). I knew (some, not all) the difference between various EVM forks, like Op-geth, Arbitrum Nitro, and Coreth. I also worked on one of the Ethereum debuggers, which required understanding how the EVM handles variables, contract calls, stack operations, and more. So, I had a solid grasp of the tech Ethereum runs on.
And so what do I know about Solana? I know it’s a blockchain, that it runs on SVM, and that smart contracts — sorry, programs — are written in Rust. So, effectively, I was stranded in the jungle, alone and without a compass. Or so I thought.
The weight of my tools slowing me down
The first thing I tried to do in the Solana ecosystem was fetch a simple portfolio for a given wallet. I had already done this, and I had done it more than once and more than one way. I knew all the pitfalls that awaited me and how to avoid them. I first needed to determine the token standards on Solana to detect transfers, index them, and fetch the balance.
I decided to start with that last one, and thank God I did, because I might have lost my marbles had I done it the other way ’round. So how do you fetch a token balance for a wallet? In Ethereum it’s simple. You know the token’s address, send a balanceOf call to it with the desired wallet’s address, and voila: there’s your balance! There must be a similar call you can do on Solana, right? Well, yes, there is! You have the getTokenAccountBalance, and once you figure out that a wallet pubKey (not address) is not the same as the ATA’s pubKey, you are good to go. Now, all you need to do is figure out how to get the ATAs for any token balances you want to see.
Eventually, this path will lead you down to the fresh spring waters of the getTokenAccountsByOwner RPC method. Ok, great! For a wallet, you will (among other things) get the ATAs for all of the tokens owned by that wallet. Already, this is surprising. No need for indexing? No need for tracking all the transfers? Really? Almost perfect! But it is actually perfect. Because once you look at all those ‘other things’ in the response, you will see that there is also a tokenAmount field for each of the ATAs. And that tokenAmount field is actually what we want!
So instead of going through all the hoops, as in Ethereum, you can call a single RPC endpoint and get the entire portfolio for any wallet (minus the real-world prices, which work the same way in both ecosystems).
Okay, so this Solana thing is EASY, I don’t know what I was ever worried about!
With that get-to-know-the-system task out of the way, my first actual task once I started working at Solflare was to parse Jupiter’s limit order fill transactions so we could detect them as they happened and log some info — standard stuff. Now, I had no idea what a Solana transaction looked like, but I had Claude to help with that. Some instruction calls, some logs. Good. Those are like CALLs and Events on Ethereum. Now, if I can just see which variables are passed to where, I can figure out the sender, receiver, and amount.
Except, Solana has no debugger, at least not a step-by-step one. The program is verified, which means I have the ABI — sorry, the IDL — but no code to read. It may be open-source, but Rust is a nightmare if you haven’t learned it (I still haven’t). I spent hours looking at various transactions on SolScan, chatting with Claude, trying to figure out what the hell is going on with the transactions!
Suddenly, just as my desperation peaked, alongside my thirst for any progress, something clicked: “All this wildlife survives here; there must be a water source nearby”. Ok, when we dispense with the metaphor, it was more like “I could fetch the portfolio easily; is there another way to do this?” And sure enough, there was! I didn’t need to know the exact code; I didn’t need to know how everything worked. I just needed to find the correct instruction within the transaction and extract the correct parameters from it.
Lo and behold, it took me less than an hour from having this realization to having working detection logic.
Throwing away the survival manual
So, what was the problem then? Why did I spend hours trying to figure out how to do simple things, instead of just doing them?
Well, the thing is, I was trying to understand the system fully and build from the ground up. After all, my entire experience in web3 was exactly that: moving from the ground up. However, that’s fine when you are in a city and have the luxury of its conveniences. You can craft a beautiful hunting spear. But when you are in the jungle, you do not have that luxury. All you need is a sharp piece of rock on a stick. In fact, you may not even have time to make that. Just sharpen the stick.
In other words, the book titled “Survival Manual” is useful, but sometimes reading through it and doing stuff the “right” way takes significantly longer than just doing stuff whichever way (and potentially revisiting how you do it in the future). And my experience in Ethereum taught me to always read the manual, while my role in Solana required me to move quickly.
Built with different purposes in mind
It might sound like I am saying that Ethereum is slow, not suited for real-world use, worse than Solana in every way imaginable, and will never catch up. I am not saying this at all. Some parts of that sentence are correct, but that’s besides the point.
What I am trying to say is that these systems are built for different purposes. Ethereum is built with the idea of “security and decentralization first, and we’ll add as much scale as we can without sacrificing any of the above.” Solana is built with the idea of “scale first, and we’ll add as much security and decentralization as we can without sacrificing scale.” And this philosophical difference has shaped almost every aspect of the two ecosystems. The first one is geared more towards developers, while the second is geared more towards everyday users.
And the problem arises when you try to use one like you would the other. Same as if looking at a jungle and a city. You cannot buy meat in the jungle, just as you can’t hunt for it in the city. Your tent is useless in the city, since you can just sleep in a room; similarly, your phone is useless in the jungle because you have no signal.
Which blockchain is better?
As always, the answer is: It depends.
The community has reached a tacit consensus that Solana (and other similar chains) is best for quick transactions, trading, and other high-volume operations. Basically, if you want to grocery shop, do it with Solana. TPS is higher, block confirmation is shorter, and fees are lower.
However, the community has also reached a tacit consensus that Ethereum (both the chain and the ecosystem) is best used for long-term storage of funds. Security and decentralization are much better there, but the fees are higher (though not as high as they used to be, and now much closer to Solana’s fees than before), and block confirmation times are longer.
On the other hand, you can look at TVL and just assume that Ethereum is the clear winner, with approximately 10x Solana’s TVL. But if you look at throughput, you will see that Solana is winning. Additionally, Solana does not need to “use up” transactions on communication between various L1 and L2 chains.
That said, both chains are moving closer to the midpoint between their two philosophies, which is completely natural. They started from different ends of the spectrum, but still, the best place to be is in the middle.
Ultimately, after all that hedging, Solana’s lower fees and higher throughput make it better positioned to serve as the world’s financial system’s backend.
