Build a Blockchain & Cryptocurrency | Full-Stack Edition

Use the following reference in case you get stuck on a lecture. This is a commit-by-lecture breakdown of the section:

* https://github.com/15Dkatz/cryptochain_commits#section-2-blocks--the-blockchain-backend

Enjoy coding!

Set up the starter code for the overall blockchain application that you'll create in the course!

The first step to building a blockchain is the most basic building block of the technology - the block itself! Create the block class in this video.

Recreate the block class through test-driven development!

Learn how to start off the blockchain application through the genesis block. Create the genesis block through test-driven development.

Implement the code to get the genesis block tests to pass. Remember, you can go with your own solution - as long as the test suite turns green!

Add a generic way to create blocks through a mine block function in the block class.

Create the all-important cryptographic sha-256 hash function. This will set the hash values in the blocks.

Add the hash functionality to the creation of a new block.

Review this section!

An overview of the core blockchain class. Now that the block class is present, the blockchain class can be created!

Understand the crucial concepts of chain validation and replacement - necessary aspects in a blockchain application with multiple contributors.

Develop chain validation by writing the tests first.

Write the code to get the chain validation tests to pass. Again, you can implement your own solution as long as the test suite goes green!

Develop the chain replacement functionality. This will support the replacement of the blockchain data when chains are submitted by multiple contributors to the application.

Remove the extra console output in the test suite!

Review this section!

Learn about the proof of work system, and the 51% attack scenario.

Proof of work ensures that blocks get added at a manageable pace. It also ensures that miners must be invested in adding blocks to the chain. This makes it expensive to hoist the 51% attack on the blockchain. More details in the video!

Add the first bits to proof of work - the difficulty and nonce value - through tests!

Get the difficulty and nonce value tests to pass. It's a great opportunity to try and get the test suite to green yourself!

Set an overall mine rate that miners should average around. The growth of the blockchain should be controlled. The mine rate facilitates this!

Execute the difficulty adjustment and get blocks to converge around a mine rate for the system.

Investigate the proof of work system by writing a script that measures mining times.

Follow up on the average work script and explore the advantages/disadvantages to using hexadecimal vs. binary hashes for the difficulty checks.

Guard against an attack scenario where someone could arbitrarily change the difficulty value beyond a regular difference of one.

Review this section!

Gain a picture of how this blockchain application will extend to multiple contributors through an API and network.

Create the express application that will power the blockchain API.

Develop a request in the api to mine a block to the main blockchain instance for the application.

Learn how real-time messaging across nodes will occur through a Publish/Subscribe implementation. This has advantages over a socket-tracking system found in many other peer-to-peer networking implementations!

Choose your pub/sub weapon: redis or pubnub.

Redis: more control.

Pubnub: easier configuration.

Directions to install redis.

Implement the Pub/Sub pattern with a redis backend.

Implement the pub/sub pattern using PubNub.

Broadcast blockchain data to all interested parties in the blockchain pub/sub network!

Configure the code to start local peers in the blockchain application. Also consume the broadcastChain() functionality previously developed, so that the blockchain is broadcasted when a block is mined in the API.

Ensure that new nodes in the network get the current relevant blockchain data when they connect to the network.

Eliminate the redundant interactions found in the current pub/sub implementation.

Recap this section!

Start the cryptocurrency portion of the application! Go over the core cryptocurrency objects: wallets, keys, transactions, and more!

In anticipation of the cryptocurrency portion, organize the code base to make additions more easily.

Develop the primary cryptocurrency object - the wallet - through test-driven development.

Add the crucial key pair and public addresses aspect to the cryptocurrency wallets.

Ensure that wallets have the ability to add their signature to objects in the cryptocurrency. Also make sure that signatures can be verified - to validate signed cryptocurrency data.

Build the tests the next core cryptocurrency object - the transaction. Use an outputMap structure to efficiently track multiple recipients/amounts in the transaction.

Create the code to get the transaction objects tests to pass. If you'd like, take this opportunity to write the code yourself!

Add the next half of the transaction objects - inputs. This will contain information about the sender - address, signature, etc.

Update the utility methods in this project to be more cohesive.

Make sure that transactions are not malformed through validation methods.

Tie the two core cryptocurrency objects - wallets and transactions - together. A wallet.createTransaction() method will save time for generating wallet-specific transactions.

Take advantage of the outputMap structure to allow updates for the same recipient, and additions for new recipients.

Why won't the cryptoHash generate unique hashes when an object's properties change.

Cover edge cases with updating transactions. Make sure that the input and remaining balance output are accurate.

Review this section!

Gain an understanding of the crucial transaction pool - a data structure which will collect transactions from multiple actors in the cryptocurrency.

Create the transaction pool object, along with functionality to set transactions in the structure.

Add a way for transactions to be create-able via the API, and instantiate a main transaction pool for the application.

Do we want invalid transactions? No!

Make sure that transactions are update-able when the same node conducts a transaction again through the API.

Expose the transaction pool map data through the API.

Like the blockchain, the transaction data should be broadcasted to all interested parties (so everyone) in the cryptocurrency!

Make sure that the transaction pool map is also in sync (like the blockchain) with the current application state when a peer connects to the network.

Review this section!

Understand the behavior involved with officially mining transactions in the blockchain and cryptocurrency application.

Create the transaction miner class, and roadmap the necessary methods for properly mining transactions.

Add a way to grab the valid transactions from the transaction pool map.

Generate rewards for a successful miner who has discovered the answer to the proof of work algorithm for the next block.

Clear transactions from the pool that have been included in the blockchain.

Add a way for transactions to be mined through the API.

Transactions that have already been included in the blockchain should be cleared once the blockchain is replaced.

Go over the quite detailed way that wallet balances will be calculated in the cryptocurrency.

Calculate the balance considering transactions in the blockchain history of transactions!

Ensure that the wallet balance is accurate before each transaction is conducted in the cryptocurrency.

Make sure that wallet balances do not double count transactions. Output amounts should only be added for a wallet balance if the output amount was recorded after that wallet's most recent transaction.

Expose a way to get the wallet balance and public key through the API.

Blocks are validated. But the data field needs to follow the rules of the cryptocurrency. Learn the rules we need to enforce in the cryptocurrency!

Add the tests for validating transaction data in blocks. Back to the efficient style of test-driven development!

Write the code to validate transaction data! An opportunity to write the code yourself - if you wish!

Enforce the cryptocurrency rule that input balances should be validated according to the calculated balance against the blockchain history.

Make sure that a block can't have the same transaction twice (a simple but menacing attack).

Make sure that the chain of transactions actually get validated in application code through the new validation methods.

Review this section!

Review what went on while building the blockchain and cryptocurrency backend! This is a particularly helpful video if you plan to jump straight ahead to the frontend portion of the project.

Go over the React.js based web application for the frontend blockchain. How will it work, what will you build, and what aspects are involved overall?

Get an understanding of the React.js framework if you would like a ramp up!

Perhaps not what you were expecting... but frontend step one: make a backend change! Serve a frontend page with the existing express application.

Add JavaScript to the frontend along with the html to set up dynamic functionality for the web application!

With JavaScript in the frontend, now you can add React!

Set up an efficient work flow for developing frontend changes.

Create the core App component for the frontend blockchain application.

Go over the crucial fetch method. Use fetch to get the wallet-info from the backend through an HTTP request. Then display that info in the React application!

Consume the backend /blocks endpoint and visualize the blocks from the backend.

Speed up the frontend development process by generating a bunch of data in the backend. That way, the frontend always has data to work with, even when the overall application restarts due to live reloads.

Time for some style! Any self-respecting web application needs some css and styling.

Create a block component and pass down data through props - to take advantage of the existing blocks data in the application.

Review this section!