Lesson 06: Important Blockchain Concepts

Before you start building, there are a few foundational blockchain concepts and practical tools worth knowing. Not at a technical level, just well enough to know what's actually happening and where to find what you need.

---

You just learned what Monad is. This lesson covers two things: the basic blockchain vocabulary (blocks, consensus, proof of stake, gas, finality) that gets thrown around without explanation, and the practical toolkit (chain IDs, RPCs, faucets, explorers) you'll use the moment you go from "understand Monad" to "actually do something on Monad."

---

How Does a Blockchain Actually Work?

Every blockchain starts with a Genesis State, which is the moment the network goes live for the first time. Bitcoin's genesis state happened in 2009. Ethereum's in 2015. Monad's in 2025.

Nodes

A blockchain doesn't run on one computer. It runs on thousands of them, spread across the world. Each computer is called a node, and each node keeps its own complete copy of the transaction history.

When a new transaction happens, every node checks it independently. No single node is in charge. If one node goes offline or tries to cheat, the rest of the network carries on. This is what makes a decentralized system resilient: there's no single point of failure.

A special type of node called a validator is responsible for proposing new blocks. Validators stake tokens as collateral, which means they have something to lose if they act dishonestly.

Blocks and Chains

Transactions don't get recorded one at a time. They're bundled into blocks. Each block contains a batch of transactions that the network has verified.

Every block is cryptographically linked to the one before it. Change one block and every block after it breaks. That's what makes the record immutable: it can't be altered after the fact.

On Ethereum, a new block is produced roughly every 12 seconds. On Monad, blocks are produced much faster, every 400 milliseconds. Every time a block is finalized, the state of the network updates: balances change, contract storage changes, everything gets locked in.

---

Consensus

In a traditional system, there's a central authority that decides what's true. Your bank says how much money you have. A company's server says whether your account exists. You trust them because they're in charge.

Blockchains don't have a central authority. Thousands of nodes around the world each hold a copy of the same data. So how do they all agree on what's true? That's what consensus solves.

A consensus mechanism is the set of rules that all nodes follow to agree on the current state of the network. It decides which transactions are valid, which blocks get added, and what happens if two nodes disagree.

Without consensus, different nodes could have different versions of reality - and the whole point of a decentralized network falls apart.

---

Proof of Work vs. Proof of Stake

There are different ways to achieve consensus. The two most important ones are Proof of Work and Proof of Stake.

Proof of Work is the original consensus mechanism, used by Bitcoin and early Ethereum. In PoW, nodes called miners compete to solve a computationally hard math puzzle. The first one to solve it gets to add the next block and earn a reward. The puzzle is hard to solve but easy for everyone else to verify - that's the trick. It's secure because attacking the network would require an enormous amount of computing power, which is expensive.

The downside: it consumes massive amounts of electricity. Ethereum used Proof of Work until 2022, when it switched to Proof of Stake in an event called The Merge - reducing its energy consumption by roughly 99.95%.

Proof of Stake is what Ethereum uses today, and what Monad uses as well. Instead of competing to solve puzzles, validators put up ETH, or MON in case of Monad, as collateral (their "stake") to participate in block production. They're randomly selected to propose new blocks and vote on blocks proposed by others.

The collateral is the key. If a validator tries to cheat - proposing invalid transactions or lying about the state - they lose their staked ETH. This is called slashing. The financial risk of losing your stake makes dishonest behavior extremely expensive, keeping the network secure without burning massive amounts of energy.

---

Gas

Gas is the fee you pay to execute transactions on the blockchain.

Every action on an EVM-compatible chain - sending tokens, deploying a contract, calling a function - requires computation. That computation is measured in gas units. The more complex the action, the more gas it uses. A simple ETH transfer uses a fixed amount of gas. A complex smart contract interaction uses much more.

You don't pay in gas units directly - you pay in ETH, or MON in case of Monad. The gas fee is calculated as:

gas fee = gas units used x gas price

The gas price fluctuates based on network demand. When a lot of people are trying to transact at the same time, gas prices go up. When the network is quiet, they go down. This is why you'll sometimes see Ethereum gas fees spike during high-traffic events like major NFT drops or market volatility.

Gas serves two purposes. First, it pays the validators who process your transaction. Second, it prevents spam - every transaction costs something, so it's not free to flood the network with garbage.

On Monad, gas works the same way but costs significantly less because Monad can handle far more transactions per second. More throughput means less competition for block space, which means lower fees.

In practice, you don't need to understand the exact gas pricing formula to build. You need to know three things: every action costs a small amount of MON, your wallet shows the estimated cost before you confirm, and if you run out of MON, transactions fail until you top up.

---

Finality

When you send a bank transfer, there's usually a delay before it's truly settled. Even after it shows as complete, it can sometimes be reversed under certain conditions.

On a blockchain, finality refers to the point at which a transaction is permanently settled and cannot be reversed. Once a transaction has finality, it's done. No one - not the validator, not the developer, not Monad - can undo it.

Different blockchains achieve finality differently and at different speeds. On Ethereum, finality takes a few minutes as checkpoint blocks are voted on by validators. Monad's architecture is designed for fast finality, which is part of what makes it practical for real applications.

Fast finality matters for users. If someone pays for something onchain, you want to know as quickly as possible that the payment is settled and irreversible.

---

The Practical Toolkit

That's the theory. Here's the practical side: the small set of tools every Monad builder bumps into the moment they start doing things on-chain. Chain IDs. RPCs. Faucets. Explorers. You'll use all of them.

No code. Just the map.

Mainnet vs Testnet

Before anything else, you need to know which Monad you're talking to. Every blockchain has multiple networks that look the same from the outside but behave very differently:

• Monad Mainnet. The real one. Real MON tokens. Real transactions. Real cost. This is where you go when you're shipping to real users.
• Monad Testnet. A separate chain for testing. Tokens on testnet have no real value. Use this to try things out without risk.

Rule of thumb: every experiment lives on testnet. Anything touching real money lives on mainnet. You don't want to test a new contract by deploying to mainnet with actual funds on the line.

Chain IDs

A chain ID is a unique number that identifies a blockchain. It's how wallets and tools know "this transaction is for Monad, not Ethereum, not Polygon, not some other chain."

Every wallet you use, every library you call, every tool you install will ask you "which chain?" The answer is the chain ID. Get it wrong and your transaction goes to the wrong network, or doesn't land at all.

You don't have to memorize it. You paste it in once when you add the network to your wallet, and then the wallet handles it from there. The canonical source for current chain IDs is docs.monad.xyz.

RPCs

An RPC (short for Remote Procedure Call) is a URL your wallet or app uses to talk to a blockchain. Every transaction you send, every balance you read, every contract call you make, all of it goes through an RPC.

Think of it like a phone number for the blockchain. When you hit "send," your wallet dials that phone number and says "please include this transaction in the next block." When you open a block explorer, it's also dialing an RPC to ask "what's the latest state?"

You don't build RPCs yourself. You use them:

• Public RPCs. Free endpoints provided by Monad or the community. Fine for development and testing.
• Paid RPCs. Hosted services like Alchemy, QuickNode, or Monad's own infrastructure partners. You pay for higher rate limits, better reliability, and additional features. Use these when you ship to real users.

For most early building, the public RPC is enough. docs.monad.xyz lists the current RPC URLs for both testnet and mainnet.

Faucets

A faucet is a website that hands out free testnet tokens. You need a faucet because testnet tokens have no real value, so nobody sells them. Instead, the Monad team gives them away so builders can test.

You connect a wallet or paste in your address, click a button, and a small amount of testnet MON lands in your wallet a few seconds later. Now you can deploy contracts, send transactions, and try things without spending real money.

• Official Monad faucet: faucet.monad.xyz

If you've seen an older HackQuest faucet linked elsewhere for Monad, skip it. It's no longer reliable. Use the official one above.

Heads up, faucets have limits. Most faucets cap how much you can claim per day per wallet. If you blow through your testnet MON, you might have to wait a few hours before claiming again. Design your testing accordingly (don't spam-send 10,000 transactions in a row the first day).

Block Explorers

A block explorer is a website that lets you look up anything on-chain: transactions, wallets, contracts, blocks. It's your window into what the chain is actually doing.

You'll use an explorer constantly:

• "Did my transaction land?" Paste the tx hash into the explorer, see status, gas used, and any errors.
• "What does this contract look like?" Paste the contract address, read the code if it's verified, see all the transactions against it.
• "How much MON does this wallet hold?" Paste the wallet address and see the balance plus the whole transaction history.

Explorers are also the fastest way to confirm you're on the right chain. If you're debugging a testnet deploy and looking at the mainnet explorer, you'll see an empty wallet and wonder what went wrong. That's not a bug, it's the wrong explorer.

• Monad Explorer (mainnet): monadscan.com
• Monad Explorer (testnet): testnet.monadscan.com

Adding Monad to Your Wallet

If your wallet (MetaMask, Rabby, Phantom with EVM support, etc.) doesn't already know about Monad, you add the network manually. You paste in:

• Network name: Monad Mainnet (or Testnet)
• RPC URL: from docs.monad.xyz
• Chain ID: from docs.monad.xyz
• Currency symbol: MON
• Block explorer URL: monadscan.com for mainnet, testnet.monadscan.com for testnet

Most wallets also support a "one-click add" via chainlist.org. Search "Monad," click the add button, approve in your wallet, done. That's the easiest path.

---

Putting It Together

These concepts connect to each other in a chain:

Transactions get batched into blocks. Nodes use a consensus mechanism - in Ethereum and Monad's case, Proof of Stake - to agree on which blocks are valid. Validators are kept honest by their staked collateral and the risk of slashing. Users pay gas to compensate validators and prevent spam. Once enough blocks have been confirmed, transactions reach finality and become permanent.

The practical toolkit is how you actually interact with all of the above: chain IDs tell wallets which network, RPCs carry your requests, faucets give you testnet tokens to play with, and explorers let you see what's happening on-chain.

Every time you interact with your app - calling a contract, saving data onchain, transferring tokens - this entire system runs in the background. You don't have to think about it while you're building. But knowing it's there, and why it works the way it does, is what separates someone who builds on blockchain from someone who truly understands what they're building on.

---

What's Next

With these concepts and tools in place, the next lesson looks at what Monad's 10,000 TPS and sub-second finality actually change for the kinds of apps you can build, and how to separate the honest claims from the hype.