In e23, we explored what a wallet really is: not an app, but a cryptographic identity on-chain, controlled by your private key and represented by your public address.

In this edition, we go one level deeper.

Those 12 or 24 words you write down when you create a wallet are not magic. They are a human-readable encoding of raw randomness, checksums, hashing, and elliptic curve cryptography. Together, they turn a single backup phrase into a potentially infinite number of addresses, all tied to one “root” identity.

Understanding this is not just for nerds. It explains why:

• Your seed phrase can restore all of your wallet on any compatible app

• Two people will almost certainly never have the same seed

• Losing that phrase really does mean losing access forever

Let’s follow the full journey: from randomness to seed phrase, from seed phrase to keys, and from keys to your zkSync wallet address.

Every wallet begins with entropy, which is just a technical word for randomness of very high quality.

When you create a new non-custodial wallet, the software generates a random number with either 128 bits (for 12 words) or 256 bits (for 24 words) of entropy using a cryptographically secure random number generator.

To give this some intuition:

• 128 bits of entropy means there are 21282128 possible values. That is an astronomically large number.

• 256 bits of entropy means 22562256 possibilities, a space so huge it is effectively impossible to brute-force.

Some hardware wallets even let you roll dice many times and feed the results into the entropy pool, so you can see the randomness being created.

At this point, your wallet is just a big, secret random number. No words. No address. No app logic. Just entropy.

A raw 256-bit number is not something most humans can safely write down and transcribe. So the industry uses a standard called BIP-39 to turn that entropy into the 12 or 24 word seed phrase you know.

BIP-39 defines a clear process:

1. Generate entropy

   • 128 bits of entropy → 12-word phrase

   • 256 bits of entropy → 24-word phrase

2. Compute a checksum

   • Take the SHA-256 hash of the entropy

   • Append a few bits from that hash to the original entropy

   • 128 bits + 4 checksum bits = 132 bits, which splits nicely into 12 groups of 11 bits

   • 256 bits + 8 checksum bits = 264 bits, which splits into 24 groups of 11 bits

3. Map bits to words

   • Each 11-bit chunk represents a number from 0 to 2047

   • BIP-39 defines a word list of 2048 unique words

   • The wallet looks up each 11-bit value in that list to pick the corresponding word

That is how you end up with 12 or 24 everyday words representing your unique entropy plus a checksum that can detect many types of mistakes. If you mistype or reorder words, the checksum often fails and the wallet can warn you that something is off.

The BIP-39 words are still not used directly to generate keys. First, they are turned into a master seed.

This is done using a function called PBKDF2-HMAC-SHA512, which takes:

• Your mnemonic phrase (those 12/24 words)

• An optional passphrase (sometimes called the “25th word”)

and runs them through 2,048 rounds of hashing to produce a 512-bit master seed.

This serves three purposes:

• It makes brute-force attacks much harder by slowing down each guess

• It allows you to add an extra layer of protection through an optional passphrase

• It turns the mnemonic into a standardized binary seed that all BIP-32 compatible wallets can use

At this point, you have:

• Human-readable backup: seed phrase

• Computed core secret: 512-bit master seed

From this master seed, your wallet can deterministically generate all of your future keys.

Next comes BIP-32 and BIP-44, the standards that define Hierarchical Deterministic (HD) wallets.

The idea is simple but powerful:

• One master seed → one master private key (also called the root or master key)

• From that master key, you derive a structured “tree” of child keys: accounts, change addresses, and more

• The process is deterministic: given the same seed and path, you get the same key every time

A typical derivation path looks like this:

textm / 44' / 60' / 0' / 0 / 0

Each part has a meaning:

• 44' → BIP-44 (the standard)

• 60' → coin type (60 is Ethereum; zkSync is Ethereum-compatible)

• 0' → account index

• 0 → external chain (receiving addresses)

• 0 → address index

Think of the master seed as the root of a huge tree and the derivation path as directions to one specific branch. From that one seed, you can have:

• A “main” account

• A separate “savings” account

• Various change addresses used for privacy

All restorable from the same words.

This is why a single seed phrase can restore your entire wallet across different devices and compatible apps.

Once a specific private key has been derived via an HD path, the next step is to generate its corresponding public key.

Modern blockchains like Bitcoin, Ethereum, and zkSync use elliptic curve cryptography (ECC), and most of them use the same curve: secp256k1.

In simple terms:

• The private key is a large random number (256 bits)

• The public key is a point on the secp256k1 curve

• The public key is computed by multiplying the private key by a special generator point GG on the curve

Mathematically, it looks like:

Public Key=Private Key×GPublic Key=Private Key×G

This operation is easy to perform in one direction (private → public), but effectively impossible to reverse (public → private) with current computing power.

This one-way relationship is what makes public key cryptography secure: you can share your address and others can verify your signatures, but no one can derive your private key from them.

The wallet address you see in the app (for example, 0x... on Ethereum/zkSync) is usually a shorter, user-friendly representation derived from the public key.

The exact process varies slightly by chain, but the general pattern is:

1. Take the public key

2. Run it through one or more hash functions (for Ethereum-like addresses, Keccak-256 is used)

3. Take part of the resulting hash and format it into an address string (for Ethereum, the last 20 bytes, often displayed with a checksum)

The end result: a shorter, shareable address that is easier to handle than a full public key, while still being cryptographically linked to your private key.

So the full chain looks like this:

Entropy → Seed Phrase (BIP-39) → Master Seed → HD Tree (BIP-32/BIP-44) → Private Key → Public Key (secp256k1) → Wallet Address

All of this is what your wallet app quietly does for you in a fraction of a second.

At this point you might wonder: with so many people generating wallets, how does the system avoid collisions?

The answer is the sheer size of the number space.

• For 128 bits of entropy, there are 21282128 possible mnemonic phrases

• For 256 bits, there are 22562256 possibilities, a number so large it is effectively unreachable by random chance or brute force

The probability of two people independently generating the same seed phrase is so absurdly low that it is considered practically impossible. It is far more likely that:

• All the devices you have ever used fail at the same time

• Or you independently hand-write the exact same 24 words as someone else by accident

than that a properly generated seed phrase collides.

This is why crypto wallets can safely rely on randomness instead of central registration.

Bringing this back to the Nodle app and the Nodle Network, your seed phrase is not “just a backup” of the app. It is the root of your wallet’s entire cryptographic tree and the single source from which all your keys and addresses can be recreated. As long as you have that phrase, along with any additional passphrase you may have set, you can reconstruct your master seed, regenerate every key and address derived from it, and regain access to your NODL on any compatible zkSync wallet.

If you lose it, there is no forgotten-password link and no administrator who can “reset” your wallet for you. The way the system is designed simply does not allow that. At the same time, that design has a powerful upside. No central party can take your NODL away from you as long as you keep your seed phrase and private keys secure. Moving to a new device or trying a different wallet app becomes a straightforward process of importing your seed phrase and using the same derivation paths, rather than starting from scratch or asking anyone for permission.

In other words, you are truly in control. That is the promise of Web3, but it is also the responsibility: the same cryptography that protects you from censorship and seizure also means you are the one who has to safeguard your keys.

In e23 and e24, we focused on how your identity in the Nodle ecosystem is created. We explored what a wallet really is and how it relates to the Nodle app, and we followed the journey from entropy and seed phrases through HD wallets and elliptic curve cryptography all the way to your zkSync address.

In e25, we will move from identity creation to identity usage. We will dig deeper into how digital signatures actually work, how the network verifies transactions on-chain, and how all of this connects to Nodle’s mission to build a decentralized physical infrastructure network.

If you now understand where your wallet comes from, the next step is understanding how it proves things to the world.

Stay curious, stay in control, keep Clicking. 🧠