Build a Blockchain from Zero: Bitcoin and Ethereum clone.

Put your learning into practice by building a basic blockchain with JavaScript, named Satoshi Coin, to understand how a blockchain works.

Create a block class in Node.js with timestamp, data, previous hash, and nonce; compute a SHA-256 hash and mine by iterating nonce until the hash meets the difficulty.

Create and inspect a blockchain block with a transaction, then mine it by incrementing the nonce until the hash starts with the required zeros, illustrating mining and difficulty.

Develop a blockchain class with a genesis block, manage a chain array, and implement mining, difficulty adjustment, and validation to guard against tampering.

Debug a blockchain by building Satoshi coin, adding blocks, and validating the chain as mining difficulty increases. See how tampering breaks validity and what comes next with wallets and transactions.

Create a transaction class with sender, receiver, and amount; manage a pending transaction pool, mine transactions into blocks, and issue miner rewards via a minting address.

Create a mint wallet with the elliptic library to generate a secp256k1 key pair, derive the mint public address, and sign transactions by hashing from, to, and amount with sha256.

Debug the transaction flow by creating wallets, sending 100 satoshis, signing the transaction, and mining the block in the Satoshi coin blockchain.

Implement a get balance method in the blockchain class that takes a public address and computes its balance by traversing blocks and transactions, subtracting sender amounts and adding receivers.

Learn how blockchain validity depends on valid transactions, including balance checks, signature verification with elliptic curves, and hash-based integrity, plus validating blocks and guarding the transaction pool.

Follow a debugging session where wallets sign a transfer and the miner mines a block. The genesis block credits John 1000 satoshis, enabling the 100-satoshi transfer to Jennifer.

Explore how gas fees sustain blockchain operation after cap, rewarding miners and funding energy costs, and implement gas as a transaction property with updated balance checks and rewards.

Debug a blockchain app by creating wallets, simulating signed transactions, applying gas fees, and tracking genesis and block rewards to explain miner balances.

Build a basic client-server setup using WebSockets to illustrate how two machines communicate. Then adapt the code toward a true peer-to-peer architecture for a cryptocurrency network.

Build a websocket-based client-server setup on port 8081 that sends a 'Hello, world' message every second and logs connections and incoming messages between server and client.

Run a server and a client in two terminals, watch client connected and client disconnected messages, and contrast client-server architecture with bitcoin's peer-to-peer network using the VSE module.

Build a peer-to-peer network where every node acts as both client and server, connect John’s and Jennifer’s machines over a local area network, exchange messages, and prepare blockchain integration.

Create the first node by setting up a websocket server on port 3000, exchanging peer addresses with a handshake, and connecting to peers to form a local peer-to-peer network.

Create two new nodes by duplicating the miner node, assign ports 3001 and 3002 for John and Jennifer, and schedule messages after three and ten seconds.

Debug a three-node blockchain network by wiring miners and peers, establishing connections between John and Jennifer, and ensuring message propagation with basic error handling to keep terminals open.

Build a bitcoin-like blockchain network with miner, full, and light nodes; validate transactions, mine blocks, and synchronize ledgers across John, Jennifer, and Bob.

Modify the blockchain by using static mint and John keys, making is valid static, and ensure a consistent genesis block timestamp across nodes for reliable wallet and transaction validation.

Learn how to build a miner node that mines transactions, validates blocks, and broadcasts new blocks using a websocket network, with terminal commands for mining, balance, and blockchain display.

Create John and Jennifer as full nodes to store the complete blockchain, validate and broadcast transactions from their mempools, and implement duplicate checks as miners confirm blocks.

Install dependencies and run multiple nodes to broadcast and validate transactions, mine blocks, and synchronize chains, illustrating mempool handling, transaction validation, fees, and miner rewards.

Learn how to create a light node that relies on full nodes for state and balance checks, handle balance and verify messages, and fix get hash with a static method.

Debug a small blockchain network by cleaning a light Bob node, validating balances, broadcasting transactions, and mining across John, Jennifer, Minor, and Bob, with verification and gas fee.

Rebuild the block structure to match the Bitcoin protocol: block size, a header with version, previous hash, merkle root, timestamp, difficulty target, nonce, plus a transaction counter and transactions.

Explore merkle trees and hash trees introduced by Ralph Merkle as the backbone of blockchain data verification. Understand how the merkle root in headers enables light-node verification.

Explore the merkle tree as a data structure that summarizes block transactions with the merkle root, built from leaf hashes of transactions using SHA-256.

Learn how merkle trees compress Bitcoin block transactions into a merkle root, so light nodes can verify a transaction with a few hashes and detect tampering through root changes.

Refactor the blockchain by extracting duplicated node functions into shared utils, introduce blockchain utils for transaction checks, and update function imports across all four nodes.

Implement a bitcoin-like block header with nonce, previous hash, merkle root, timestamp, and difficulty. Estimate block size and compute the block hash from the header using SHA-256 and merkle trees.

Debug a multi-node blockchain by executing transactions, mining blocks, and validating balances, while noting block properties and merkle roots; address merkle root duplication by adding a timestamp to transactions.

Record each transaction with a current timestamp, set the gas fee to zero where needed, and validate the blockchain by testing nodes, ensuring unique timestamps produce distinct sha-256 merkle roots.

The light node stores only block headers to reduce storage and network data, and verifies blocks using header fields (nonce, previous hash, merkle root, timestamp, difficulty) from genesis header.

Debug a four-terminal blockchain setup, mine blocks, and confirm a light node stores block headers while exploring genesis block details; next course covers Bob Node’s transaction verification.

Learn how light nodes use simplified payment verification to confirm transactions by constructing the merkle path and verifying the merkle root against block headers, avoiding full blockchain storage.

SPV implementation shows a light node maintaining a transaction history, broadcasting transactions, and verifying inclusion in a block using merkle proofs and sha-256 leaves.

Verify a Merkle root against block headers in the chain array. Confirm a transaction's inclusion with a Merkle proof by reconstructing the Merkle tree using SHA-256.

Debug and refine a blockchain transaction workflow across nodes, resolve a proof object mismatch, reconstruct valid proofs, and implement Merkle tree techniques to empower light nodes.

Extend your blockchain to support smart contracts like Ethereum, turning it into a platform for decentralized applications. Learn about Solidity, Ether, and how to deploy smart contracts on a blockchain.

Explore how smart contracts on the Ethereum blockchain automate agreements with ether, enabling self-executing property transfers, bets, and rentals without intermediaries, and learn about deploying a custom contract language.

Explore deploying a smart contract on Ethereum by creating a deployment transaction with contract code in the data field, paying gas, and sending to a deployment address.

Explore how to execute smart contracts on a blockchain by sending transactions to a deployed contract address, and understand the role of the Ethereum Virtual Machine.

Explore how a runtime engine stores smart contract results in a global state using LevelDB or the Ethereum state database, and practice put, get, and iterator.