The transaction took less than two seconds to appear on screen. But in those two seconds, elliptic curve math ran, a unique signature was generated, a network of validators checked the cryptographic proof, and an immutable record was written to a blockchain secured by Ethereum. None of that was visible. All of it was essential.

In e23 and e24, we explored what a wallet is and how it comes into existence. You now know that your wallet is not an app — it is a pair of cryptographic keys living on the ZKsync blockchain, born from entropy, shaped by BIP-39 and elliptic curve cryptography, and represented by your public address.

In this edition, we answer the next logical question: once your wallet exists, how does it actually prove things to the world? How does the network know that a transaction was really authorized by you and not by someone who just knows your address?

The answer is the digital signature — the mechanism that makes self-custody possible, trustless verification real, and the entire system function without a bank, a government, or any central authority in the middle.

A digital signature in blockchain is not a picture of your handwriting. It is a piece of mathematics, unique to both you and the specific transaction you are authorizing.

Think of it like a wax seal on a letter. A wax seal proves who sent the letter and guarantees that nobody opened it along the way. A digital signature does the same thing — but in a way that is mathematically verifiable by anyone, anywhere, in milliseconds, without trusting the person verifying it.

What makes it powerful is that it achieves two things at once.

It proves authentication — that the person who holds the private key authorized this specific action. And it proves integrity — that the transaction data has not been altered since it was signed. Change even a single character in the transaction and the signature immediately becomes invalid.

When you tap "Send NODL" in the Nodle app, here is what happens at the cryptographic layer.

Step 1: Hash the transaction.
The app takes all the details of your transaction — the recipient address, the amount, the fee, and the nonce — and runs them through a hash function (Keccak-256 on Ethereum-compatible chains like ZKsync). The result is a short, fixed-length fingerprint of the transaction. No matter how long or complex the transaction data is, the output is always the same length. And any change to the input produces a completely different output — so the hash function is both a compressor and a tamper detector.

Step 2: Sign the hash with your private key.
Using the ECDSA algorithm (Elliptic Curve Digital Signature Algorithm), the app combines the transaction hash with your private key and a randomly generated number to produce a signature: two values called r and s. The random number ensures that even if you sign the exact same transaction twice, you get a different signature each time — making it impossible to reverse-engineer your private key from your signatures even if someone collects thousands of them.

Step 3: Broadcast the signed transaction.
The app sends the signed transaction to the ZKsync network. The package contains the original transaction data, the signature (r, s), and your public key or address. Your private key is never included. It never leaves your device.

Step 4: Validators verify the signature.
Nodes on the network receive your transaction and run the verification algorithm. They use your public key to check whether the signature matches the transaction hash. If the math confirms it, the transaction is authentic. If anything was tampered with — the amount, the recipient, the fee — the check fails instantly and the transaction is rejected.

When your signed transaction arrives at the ZKsync network, it enters a holding area called the mempool — a temporary pool of unconfirmed transactions waiting to be processed.

Validators monitor the mempool continuously. Before including your transaction in a block, they run a multi-step check.

First, they verify your digital signature using your public key. A valid signature confirms both that you authorized the transaction and that the data was not modified in transit.

Second, they check that your address actually has enough balance to cover the amount plus the transaction fee. The blockchain's current state tells them this instantly.

Third, they verify your nonce — the transaction counter introduced in e24. A correct nonce confirms this transaction has the right sequence number and has not already been processed or replayed.

If all three checks pass, the transaction is valid. Validators group it with other valid transactions into a block, and the block gets added to the chain.

Because Nodle runs on ZKsync, the validation process has an extra layer worth understanding.

ZKsync is a zk-rollup — a Layer 2 network that processes transactions off the Ethereum mainchain and then submits a cryptographic proof back to Ethereum, confirming that all transactions in a batch were valid.

The type of proof ZKsync uses is called a zero-knowledge proof. In simple terms: a zero-knowledge proof allows the network to mathematically confirm that a statement is true — for example, "all 5,000 transactions in this batch have valid signatures and correct balances" — without revealing the contents of those individual transactions.

This has three practical benefits for you as a Nodle user.

Your transactions appear on screen almost instantly, because ZKsync gives users immediate confirmations while proof generation happens in the background.

Fees are significantly lower than on Ethereum mainchain, because thousands of transactions are batched and verified together rather than individually.

Security is mathematically guaranteed. Unlike other Layer 2 approaches that assume transactions are valid unless challenged, ZKsync proves validity cryptographically before anything is finalized on Ethereum.

Full finality — when the proof is verified and settled on Ethereum — takes around three hours. But for everyday use, you can treat your transaction as confirmed the moment it appears in the app.

Understanding digital signatures is not just useful for sending NODL. It goes to the heart of what Nodle is building.

The Nodle Network is a Decentralized Physical Infrastructure Network (DePIN): a global network of smartphones that collects and verifies real-world data — connectivity signals, location proofs, and now authenticated media — coordinated by blockchain and rewarded in NODL.

Every meaningful action on the Nodle Network is, at its core, a signed transaction. When your device detects a Bluetooth signal and reports it to the network, that report is cryptographically signed. When you photograph something with the Click app and swipe to authenticate it, you are creating a digital signature that attaches your identity, a timestamp, and a location to that piece of media — permanently, on-chain, in a way that cannot be faked or altered.

That signed photo becomes what Nodle calls a Deep Real — a verified piece of media content that proves it was captured live, in a real place, by a real person, not generated by AI. The C2PA standard embedded in every Click capture encodes tamper-evident metadata including device information, time, and location.

Across the last three editions, you have followed the complete lifecycle of a wallet on the Nodle Network.

In e23, you learned that your wallet is not the app — it is a cryptographic identity on ZKsync, with a private key that proves ownership and a public address that receives funds. The Nodle app is the frontend. The blockchain is the backend. The app shows you what the blockchain already knows.

In e24, you followed the creation of that identity: from pure entropy to a BIP-39 seed phrase, through PBKDF2 hashing to a master seed, down HD derivation paths to a private key, through secp256k1 elliptic curve multiplication to a public key, and finally through Keccak-256 hashing to your 0x... ZKsync address.

In e25, you saw that identity being used: how ECDSA signatures prove authorization without revealing private keys, how validators check transactions in the mempool, how ZKsync batches and settles those transactions using zero-knowledge proofs, and how the same signature mechanism underpins Nodle's mission to verify real-world data in a world full of synthetic fakes.

Your private key is not just a password. It is the mathematical proof that you are you — on-chain, trustless, and in control.

The next edition will shift from the individual wallet to the wider network. We will explore how consensus mechanisms work — how a distributed network of validators that do not know or trust each other still manages to agree on a single shared truth, every block, every time.

If e25 answered "how does my wallet prove things to the network?", e26 will answer "how does the network decide what to believe?"

Stay curious, stay in control, keep Clicking and Nodle on! 🧠