This third edition, following those on your wallet and Nodle's Web3/DePIN role, focuses on gas fees - the small, often confusing price paid for network transactions. Historically a barrier due to unpredictability and high cost, innovations like Ethereum's blobs, ZKsync's zk-rollups and the ZyFi partnership have slashed Nodle and Click user gas fees to fractions of a cent. This makes using Nodle as smooth as a Web2 app, while maintaining decentralized integrity.

Most Web2 payments hide a 2–3% fee in the price you pay to card networks and platforms. In Web3, you cut out those intermediaries, but you pay a small, visible gas fee to use shared infrastructure instead.​

Gas is what rewards the computers that keep the network secure and prevents spam. Each time you send tokens, sign with your wallet or use a dApp, you pay a bit of gas (or burn so to speak) so the network can process and include your transaction. On Ethereum and especially on ZKsync, these fees have dropped dramatically and, for typical Nodle actions, are now measured in fractions of a cent.​

Behind every Nodle or Click action is a stack of blockchain layers, each with its own job.

Layer 2 – ZKsync Era (express lanes)
ZKsync Era is where most of the action for Nodle and Click happens. It behaves like a high‑speed train on top of Ethereum: many user transactions are bundled together off‑chain, then checked in once at the main station (Ethereum) with a compact cryptographic proof. This lets Nodle offer fast confirmations and very low fees while still inheriting Ethereum’s final security.​

Layer 1 – Ethereum (main highway)
Ethereum is the settlement layer that records the final result of those bundled transactions. It is slower and more expensive than L2s but extremely secure, which is why rollups like ZKsync ultimately anchor back to it. When Ethereum is busy, gas prices there rise; using an L2 shields most users from that volatility.​

Layer 0 – Infrastructure plumbing
Below all this sits the networking and interoperability layer that lets different chains talk to each other, a bit like the internet cables and protocols that connect websites today. You rarely see this directly, but it is vital for a multi‑chain, DePIN-powered world like Nodle is building.​

On ZKsync, every Nodle or Click transaction goes through the same basic gas flow: an estimate up front, and a final cost once it is processed.

When you confirm a transaction, the app first asks the network how much gas it is likely to use and what a sensible gas price is. From that, it computes an estimated maximum fee in NODL and checks you have at least that much available; for a typical Nodle action this buffer is currently set so the max shows as about 0.04 USD cents. That upper bound protects you if gas briefly spikes as your transaction is being included.​

After the transaction lands in a block on ZKsync, the protocol knows exactly how many gas units were consumed and what price was applied at that moment. The actual fee is calculated from this real usage, and in normal conditions it tends to be lower than the estimated max you saw in the UI - just like a fuel station putting a bigger pre‑authorization on your card, then only charging you for what you actually pumped.​

ZKsync is a zk-rollup, which means it scales Ethereum by moving most computation off-chain and proving correctness with zero-knowledge proofs. Instead of Ethereum processing every Nodle transaction one by one, ZKsync groups hundreds of transactions together, generates a single cryptographic proof that all of them followed the rules, and Ethereum just verifies that proof. This bundling alone cuts costs dramatically, but the real breakthrough came with how ZKsync stores the data behind those bundles.​

For years, rollups like ZKsync had to publish all their batch data to Ethereum so anyone could verify the chain's history. This data went into calldata, which is stored permanently on Ethereum forever. Permanent storage is expensive, so every user transaction carried the weight of that data cost. Even with rollup compression, fees stayed higher than anyone wanted.​

Ethereum's EIP-4844 upgrade introduced a new concept called blobs that fundamentally changed the economics.​

A blob is a temporary data bucket attached to special Ethereum transactions. Instead of living forever like calldata, blobs are pruned from the network after about 18 days. Because they are temporary, they are priced using a separate market mechanism and cost orders of magnitude less than permanent storage.​

For rollups, this is transformative:

• Before blobs: ZKsync posted batch data as calldata, paying the permanent storage price for every byte.​

• After blobs: ZKsync posts the same data as blobs, paying a temporary storage price that is typically 10-100x cheaper depending on network demand.​

This difference flows directly to users. A transaction that might have cost 1 cent with calldata now costs a fraction of that with blobs. Analyses of EIP-4844's real-world impact show that blob-enabled rollups see fees drop at least 2x, and zk-rollups like ZKsync often see even larger reductions.​

Right now, when you use Nodle on ZKsync Era:

• Your transaction is bundled with hundreds of others.

• ZKsync generates a proof that all of them are valid.

• The batch data—which lets anyone verify your transaction happened—is stored as a blob on Ethereum for a short window.​

• After a few weeks, that blob is pruned, but your transaction is already finalized and Ethereum-settled, so you lose nothing in security.​

The blob mechanism keeps the data cost so low that even after ZyFi's paymaster markup, the all-in fee for a typical Nodle action lands at fractions of a cent today.​

Blobs have solved the data cost problem, but ZKsync's roadmap is about reducing everything—computation, storage, and proving time—so fees will approach zero even as the network handles billions of transactions.

Atlas will improve the sequencer and architecture layer, reducing per-transaction overhead as volume grows.​

Airbender, currently live on testnet and expected to launch mainnet in the coming months, will make proof generation itself dramatically cheaper and faster using advanced GPU algorithms to produce a proof for an entire block in about a second. As proving costs drop, the fees that users see will drop proportionally.​​

Together, blobs, Atlas and Airbender represent a complete rearchitecture of rollup economics: data cheaper, proofs faster, execution more efficient. The result is a path toward fees that will be not just low, but functionally invisible.

Even when fees are tiny, traditional gas UX is confusing: you often need a second token (like L2 ETH) just to move the token you actually care about. Nodle deliberately removes that friction by integrating ZyFi on ZKsync.

ZyFi is a "paymaster as a service" provider that lets apps route gas payments through smart contracts called paymasters. When you use the Nodle app, Nodle Portal, or advanced Click features, ZyFi estimates the gas your transaction needs, converts it to an equivalent amount of NODL, and routes it through a paymaster contract that handles the payment. The result is simple: you pay gas in NODL instead of needing L2 ETH, using the same token you already hold for everything else in the Nodle ecosystem.​

There is one important distinction that affects your ability to transact: only your available NODL balance can be used to cover transaction fees.​

Available NODL is already in your wallet and confirmed on-chain—tokens you can spend, transfer, and use to pay gas. Pending NODL is rewards you have earned but not yet claimed; these sit in the network's reward pool, not in your wallet, so they cannot be used for transactions.​

In practice, this means: if you want to claim your pending rewards but your available NODL balance is too small to cover the claim transaction's fee, you will need to acquire a small amount of available NODL first. The fee itself is tiny (fractions of a cent thanks to ZyFi and ZKsync), but it must come from tokens already in your wallet.​

Think of it like a prepaid card: your available balance is the money loaded on the card, and your pending rewards are money that will be added once you process the claim. You need enough available balance right now to pay for the claim transaction itself.

The Nodle app is built with crypto‑curious users in mind: it exposes more of the Web3 surface area and is comfortable talking about wallets, networks, and tokens. The Click Camera, on the other hand, is intentionally Web2‑friendly.​

When someone uses Click, the experience should feel like a modern camera app, not a DeFi dashboard. When a photo is captured and turned into a “Click” on-chain, Nodle covers those blockchain costs for the core capture and signing flow so users do not have to think about gas, tokens, or even blockchains at all. This lets Click act as a gateway: people simply take authentic photos, while in the background Nodle uses ZKsync, NODL, and gas abstraction to grow the Digital Trust Network and expand into new real‑world horizontals.​

For more advanced Click features - such as ClickAI or future on‑chain tools - gas will still be tiny and payable in NODL, using the same ZKsync + ZyFi setup that powers the Nodle app and Portal.​

Thanks to technological and design advances, gas fees will soon be almost imperceptible for Nodle and Click users.

The underlying architecture - ZKsync's zk-rollups, Ethereum's blobs, ZyFi's paymasters and ongoing upgrades - makes decentralized networks as cheap and fast as Web2 apps. This lets users focus on earning, capturing moments, or exploring on-chain tools, with tiny gas costs fading into the background.

This real-world DePIN utility is about robust, unnoticed infrastructure, not hype. As Nodle scales the Digital Trust Network, this foundation of cheap, secure, Ethereum-backed transactions is crucial.

Ready to dive deeper into Web3? Keep an eye out for future editions of Crypto 101 covering tokens, yield, governance and more.

Until then, happy Clicking and keep those NODL coming.