Python, JS, & React | Build a Blockchain & Cryptocurrency

Preview Python fundamentals and explain how each section contributes to building a blockchain in cryptocurrency, while outlining upcoming JavaScript web development and React topics.

Explore Python fundamentals by working with numbers, strings, and lists in the interpreter, use it as a calculator, and learn type with the type function and arithmetic operators.

Explore strings and variables in Python, learning string creation, quoting, and concatenation. Master slicing with zero-based indexing and negative indices for last characters, plus floor division for valid indexes.

Explore how Python functions perform actions, take arguments, and return values, define them with def, treat functions as objects, and understand their scope and side effects when calling.

Explore booleans and Python's comparison operators to drive control flow with if statements, evaluating conditions for true or false outcomes, and branch actions; learn about string comparisons and loops.

Explore how Python controls execution flow with while and for loops, using conditions, indentation, and range to iterate and print sequences.

Explore Python data structures, including lists, sets, and dictionaries, and learn practical manipulation with append, extend, remove, and sort. See dynamic dictionary views for keys and values.

Explore how classes and object-oriented programming let you create custom objects with templates, attributes, and methods, including inheritance and object instances like bears and lions with habitats and diets.

Learn how to define Python classes with init and self, attach attributes and methods, instantiate objects, and use inheritance with a lion class to extend an animal.

Start building the blockchain application by setting up the main blockchain data structure, mining blocks, genesis block, and hashes, while embracing bugs as learning opportunities during this turning point.

Discover how blockchain operates as a distributed, decentralized ledger linking blocks via hashes, with cryptography, wallets, and proof-of-work mining powering cryptocurrencies.

Build a basic block chain and cryptocurrency in Python by implementing a block chain class, adding blocks with data, and printing a readable chain structure.

Learn how to structure Python projects with modules by splitting classes into block.py and blockchain.py, using from imports, and guarding executable code with if __name__ == '__main__'.

Expand the block class to include timestamp, last hash, data, and hash, and implement a mine_block method with a genesis block to start the blockchain.

Refactor the blockchain by moving genesis and mine_block into the Block class as static methods, initialize the chain with the genesis block, and update add_block accordingly.

Develop a sha-256 hashing workflow in Python by implementing a crypto_hash function, encoding input to utf-8, and converting to hex digest, including json.dumps handling.

Explore hashing and sha-256, generating block hashes from data, timestamp, and previous hash. Learn the 256-bit, hex-encoded, one-way properties and how to verify blocks by regenerating hashes in code.

Explore encoding in UTF-8, turning strings into bytes and decoding them back, to enable cross-application data transfer and hashing workflows.

Extend the crypto hash to accept multiple arguments with *args, use map and a lambda to stringify inputs, sort for order invariance, and wire hashing into the block.

Install Pytest and set up a virtual environment to isolate project dependencies for the blockchain project. Create a requirements.txt and readme.md to document installation, activation, and collaboration steps.

Organize the project into backend, blockchain, and util packages by moving modules and adding __init__.py files, enabling dot-notation imports. Run and test modules with python -m to verify package structure.

Create a backend test directory mirroring the project structure, test the crypto hash method, and document running tests with pi test.

Demonstrate testing the blockchain by validating block creation via mine block and genesis, using a genesis data dictionary, and testing block chain creation and adding blocks with pytest.

Explore the proof of work concept and its relation to mining blocks, and learn why this mechanism enables the stable growth of the blockchain.

Explore how proof of work requires miners to perform computational work and adjust difficulty to secure blocks, explain hashes, nonce, and the 51% attack risk in blockchain networks.

Explain how a proof-of-work blockchain mines blocks by adjusting the nonce to produce a hash with a required number of leading zeros, guided by a dynamic difficulty.

Examine the adjust difficulty tests for the proof of work system, validating quick and slow mine blocks, preventing drop below 1, and using genesis and test data.

Write a script to mine blocks and measure the average time, revealing how the proof of work drives difficulty adjustments toward the target mine rate.

Implement hex to binary conversion in the backend to translate hex block hashes into binary for a precise proof-of-work check, and update tests and mining flow accordingly.

Implement and test a hex-to-binary converter used for the proof-of-work system. Validate that leading zeros checks and binary conversion work, then outline forthcoming block validation and blockchain rules.

Explore how to prepare the blockchain for collaboration by validating incoming chains and replacing the current chain when a better one arrives, enabling a multi-participant blockchain network.

Validate the chain by checking block fields, last hash, hash integrity, and the proof of work. Replace the current chain with a longer, valid one in a decentralized network.

Learn to validate blockchain blocks with is_valid_block using pytest, employing fixtures for last block and block, and testing invalid hash, invalid last hash, proof of work, and hash integrity.

Learn to validate an entire blockchain by implementing a static is valid chain method that ensures the genesis block is valid and every block is formatted correctly.

Explain chain replacement to achieve decentralized consensus by adopting a longer, valid incoming blockchain and updating the local chain accordingly.

Explore setting up an api with Flask to expose blockchain data and mining capabilities, enabling individual blockchain instances via a web server and http get and post requests.

Create a main blockchain instance in Flask, expose an endpoint at /blockchain, and return blockchain data using repr; then refactor to JSON for web sharing.

Refactor the block chain endpoint to return JSON by adding serialization with jsonify and to_json methods, then map the chain to serialized blocks for API output.

Explore how to mine blocks and extend a blockchain API, adding data as a transaction, returning the mined block in JSON, and planning a decentralized network with consensus.

Implement a real-time pub/sub messaging network for a block chain by publishing new blocks to a shared block channel and allowing nodes to subscribe to updates.

Learn to set up Pubnub pub-sub for blockchain nodes, configure publish and subscribe keys, subscribe and publish to a test channel, and handle messages with a listener.

Create a pub sub class to encapsulate the publish subscribe logic for block chain network nodes, including init, subscribe, listener, and publish methods for inter-node communication.

Configure peer instances with an environment variable to assign a unique port beyond 5000, enabling multi-node communication via pubsub; document steps and plan to broadcast blocks for synchronization.

Implement a block receiver that validates incoming blocks, appends them to a potential chain, and replaces the local chain when the new chain is valid, deserializing blocks from JSON.

Synchronize a peer on startup by fetching the root node's blockchain data via http get, converting JSON to a blockchain, and replacing the local chain.

Explore wallets, keys, and transactions, learn to generate a signature and validate transactions, and gain an overview of how keys operate in cryptocurrency.

Discover how digital wallets manage balances, private and public keys, and addresses to sign and verify cryptocurrency transactions on a blockchain.

Build a backend wallet class that assigns a unique address via uuid4, initializes balance from config, and enables transaction authorization through elliptic curve cryptography with private and public keys.

Sign data with the wallet’s private key to generate a verifiable signature for transactions, encoding input as JSON and hashing with SHA-256 for secure verification.

Add a static verify method on the world class that takes a public key, json-dumped utf-8 data, and the signature to validate the data, returning a boolean.

Write unit tests for the wallet class to validate signature generation and verification. Use pytest to confirm that a valid signature verifies and an invalid one does not.

Define a transaction class to document currency exchanges between a sender and recipients, using output and input structures, a unique id, and signatures with a public key for verification.

Add an update method to the Transaction class to allow a sender to designate multiple recipients. Validate balances, adjust outputs, and re-sign the input to finalize the updated transaction.

Test transaction updates by evaluating balance-exceeding exceptions and successful updates to multiple recipients, then outline validating transactions before miners include them in blocks.

Implement a static is_valid_transaction method to validate a transaction by summing outputs, comparing to the sender's balance, and verifying the signature, raising exceptions. Include tests for valid and invalid cases.

Implement a wallet transact post endpoint to create transactions from json input and debug serialization of elliptic curve keys and signatures for API responses.

Learn to serialize cryptographic signatures by encoding and decoding DS signatures with cryptography utils, verify wallet transact requests via a post wallet transact endpoint, and test the workflow.

Learn how the transaction pool collects unique transactions, updates existing ones, and can rewrite multiple transactions, enabling synchronized networks and mining of new blocks.

Learn how to broadcast transactions through a pub/sub system by adding a transaction channel, deserializing the JSON payload into a transaction, and updating the transaction pool across nodes.

Update the API to modify an existing transaction in the transaction pool when the sender reuses a transact call, and use truthy and falsy checks to handle the update.

Connect the blockchain and cryptocurrency by enhancing mining and transaction validations, showing how pool transactions become official in blocks and enable wallet balance calculations and mining rewards.

Build an automated Python test script to interact with blockchain endpoints—get blockchain, post wallet transact, and mine—using a base URL and brief delays.

Develop and test a clear block chain transactions method in the transaction pool to remove duplicates by iterating the block chain, checking each transaction ID, and safely deleting entries.

Calculate wallet balances by scanning blockchain history from the most recent block to the genesis, using transaction outputs to determine the balance and prevent double counting.

Calculate the true balance for a wallet address by aggregating transaction outputs across the blockchain. Implement a calculateBalance method that scans blocks, resets on sender, and adds outputs for recipients.

Make balance a property that derives wallet balance from blockchain data on access, and expose address and balance via /wallet/info, setting up mining reward groundwork.

Define a mining reward of 250 and a hardcoded reward input in the config, awarding the miner's wallet. Implement a reward_transaction method and tests to enforce one reward per block.

Hook into the transaction validation flow to verify mining rewards, enforcing a single reward output with the official value, and extend tests to cover valid and invalid scenarios.

Validate a blockchain's transactions by enforcing unique transaction IDs, a single mining reward per block, and each transaction's validity via the Transaction class's is_valid_transaction method.

Explore how to validate cryptocurrency transactions by recalculating balances using a historic blockchain slice, ensuring transaction input amounts match blockchain history and mining rewards are handled.