How Amazing I felt After Sending SOL from my phone to my local Ubuntu terminal

Murtala Mudi — Mon, 25 May 2026 14:38:34 +0000

Hi everyone, I moved to Day 7 of the 100 days of Solana challenge today and I can say It has been very interesting to go through all these experiments.

I did something really cool. I tried sending devnet SOL from the normal Phantom app I downloaded on my mobile phone straight to the CLI wallet on my local computer's terminal. To be honest, I found it so fascinating that I even did it twice! I just wanted to confirm and see exactly how things work in real-time, and it was amazing to watch the command line balance increase the moment I sent it from my phone.

While doing this, I noticed a big difference in how these wallets handle security and convenience:

The Mobile Wallet: I noticed that the app on my phone is not that convenient for quick back-and-forth work. Even without minimizing it or moving out of the app, after some seconds or minutes, it just asks me to confirm my fingerprint again. The moment I move out of the app to check something on my browser and come back, it must require that I initiate my fingerprint again. Even though this is not that convenient, I think it is the most secure way to safeguard my digital assets so that they can be accessed by only me and not anyone else.
The CLI Wallet: On the other hand, the one on my local computer is just the most convenient. All I need is to type in the command to do something, either to show the remaining balance or transfer something, and it just works instantly without asking for fingerprints every second.

For my personal use, I will definitely choose the one on my phone because I want my digital assets to be completely secured. But for development and practicing code, the CLI is just the best because it is fast.

It feels great to see how these different wallets connect on the same network. I am excited to finish this first week and see what is required of me in the next steps!

Let me know how your first week went!

Dear Web2 Developer... Solana is here calling

Murtala Mudi — Mon, 25 May 2026 13:15:21 +0000

As web developers, we know exactly how user accounts work. When a user signs up for an application, we create a users table in a database. We hash their password, assign them a unique user_id, and manage their session status using tokens or cookies.

In this traditional Web2 setup, identity is entirely fragmented. A user is one row in a GitHub database, another row in a LinkedIn database, and another row in their banking application. None of these applications inherently speak to each other, and more importantly, the user doesn't actually own their identity, the company hosting the database actually does. If an admin deletes that database row, that identity is gone.

As I've been jumping into the first week of the 100 Days of Solana challenge, the biggest mental shift wasn't learning a new framework; it was redefining what "identity" actually means on a blockchain.

Check how identity works on Solana below, I explained it through concepts we're already familiar with in our everyday life.

The Model: You Already Use Web3 Identity (I'm assume this to be true)

You connecting to a remote server or you securely pushing code to GitHub using terminal commands, knowingly or unknowingly, you've already used the core engine of Web3 identity: SSH Keypairs.

When setting up SSH, you run a command locally to generate a keypair. This gives you:

A Public Key that you safely share with GitHub or a remote Linux server.
A Private Key that stays hidden inside your machine's local configuration files.

When you push code, your machine uses your private key to cryptographically "sign" the request. The server uses your public key to verify that the signature is valid.

Solana works exactly the same way. On-chain identity starts with an Ed25519 cryptographic keypair. There are no centralized registration forms, no email verifications, and no usernames. The entire network acts as a single, global ledger, and your public key is your universal identity across every single application built on top of it.

Breakdown of a Solana Address

In Web2, your username might be dev_muritala. On Solana, your identity looks more like this: 4zMMC9srtxt2nvbBt3wjfBBs71A7HK8gZrybFmZuxyJu.

This string is a 32-byte public key encoded in Base58. Cryptographers deliberately chose Base58 for blockchain addresses because it optimizes for human scannability by completely removing visually ambiguous characters. You won't find the number 0, uppercase O, uppercase I, or lowercase l in a Solana address. This prevents catastrophic copy-paste mistakes when developers or users are routing assets or interacting with software on-chain.

Custody: No Password Reset Flows

The shift in architectural control changes everything when transitioning from Web2 to Web3.

In Web2, if a user loses their credentials, they click a "Forgot Password" link. An automated backend system sends an email link, verifies their response, and updates the database row. The platform retains ultimate authority over the account data.

On Solana, there is no corporate admin panel, no support desk, and no password reset flow. Identity is completely non-custodial.

If your private key lives as a plaintext file on your local development machine (like a standard CLI development environment), it is highly scriptable but vulnerable if the machine compromises.
If your private key is encrypted inside a browser extension wallet (like Phantom), it introduces a secure confirmation popup layer before any transaction can execute.
If it is guarded behind mobile OS secure sandboxes protected by biometric fingerprint scanners, it trades off rapid script deployment for superior physical protection.

But regardless of the storage medium, whoever holds the private key owns the identity. If you lose the key material or your recovery seed phrase, the identity is mathematically unrecoverable.

What This Identity Enables

This cryptographic setup does more than just replace the traditional username/password paradigm. Because your identity is recognized globally by the entire Solana runtime, it acts as a universal passport.

With a single public key, you can simultaneously hold tokens, execute custom code routines, vote on platform governance protocols, and build a verifiable developer reputation across hundreds of independent ecosystem tools. You don't need to request access or integrate third-party OAuth providers. You simply sign a permission request with your private key, and you are instantly authenticated.

Conclusion

Transitioning into Web3 as a developer requires looking past the surface level of tools and looking directly at the architectural foundation. Identity on Solana isn't a collection of accounts granted to you by corporate servers, it is a sovereign, mathematical certainty that you control completely from your own local workspace.

If you are a developer looking to build systems where users have true ownership of their data and actions, understanding the mechanics of the cryptographic keypair is your first real step.