Building a Blockchain Application With JavaScript

Coinpedia · 2024-08-14T17:23:07.000Z

The post Building a Blockchain Application with JavaScript appeared first on Coinpedia Fintech News Introduction Blockchain technology has an impact on many of today’s game-changing innovations, from cryptocurrencies like Bitcoin to decentralized apps (DApps) in different fields. A blockchain is a shared ledger that keeps track of transactions across many computers so that the record can’t be changed after the fact. Each entry, or “block,” is connected to the one before it making a chain of blocks, which is why it’s called a “blockchain.” This setup makes sure data is open, secure, and can’t be altered, which is key for lots of uses JavaScript in Blockchain Javascript is a multifaceted and celebrated language especially suited for blockchain development. With its extensive ecosystem and strong community support, JavaScript simplifies blockchain development in several ways: Wide Adoption: Since Javascript is the core language used for web development its very obvious to have application in the blockchain landscape with web applications. Asynchronous Processing: JavaScript’s asynchronous capabilities, facilitated by Node.js, are ideal for handling multiple transactions and interactions in a blockchain environment. Rich Ecosystem: Tools and libraries in the JavaScript ecosystem, such as Node.js for server-side development and Express.js for APIs, streamline blockchain application development. Audience This article is designed for developers who are familiar with JavaScript and wish to delve into blockchain technology. It will guide you through setting up your development environment, understanding blockchain fundamentals, building a basic blockchain application, and exposing it via a simple API. Chapter 1: Setting Up the Development Environment Installing Node.js Download node js on your system from the official website and prefer the LTS (Long Term Support) version as it is recommended the best for all the operating systems and maintain stability. Follow the installation instructions specific to your OS. The installation includes npm (Node Package Manager), which is essential for managing project dependencies. Verify the installation is done properly or not by running the following commands in the bash: node -v npm -v After you run the commands you should get the respective versions of the packages you installed if the setup is successful. Choosing an IDE When you opt for JavaScript as your programming language the best partner to cater all the development needs is VsCode its robust features and versatile environment is best suitable. Visual Studio Code: Download VsCode from the official site Install the extensions as follows: ESLint: For identifying and fixing problems in JavaScript code. Prettier: For consistent code formatting. Debugger for Chrome: For debugging JavaScript code running in Google Chrome. Node.js: For Node.js debugging capabilities. Installing Required Libraries JavaScript libraries are managed via npm. Initialize your project and install the required libraries with: npm init -ynpm install express body-parser crypto//express is the node framework //body-parser is the middle ware to parse the incoming requests//crypto function used for hashing Chapter 2: Understanding Blockchain Concepts with JavaScript Blockchain Basics in JavaScript A blockchain comprises of blocks, which contain: Index: Position of the block in the chain. Timestamp: Date and time when the block was created. Data: Transaction data or other information stored in the block. Previous Hash: Hash of the previous block in the chain, linking blocks together. Hash: Unique identifier for the block, generated by hashing its content. const crypto = require(‘crypto’);class Block { constructor(index, timestamp, data, previousHash = ”) { this.index = index; this.timestamp = timestamp; this.data = data; this.previousHash = previousHash; this.hash = this.calculateHash(); } calculateHash() { return crypto.createHash(‘sha256’) .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data)) .digest(‘hex’); }} Importance of decentralization, immutability, and consensus mechanisms: Decentralization: There is no central authority that holds all the necessary data or transaction validation rather it is all distributed across the network. As we know in blockchain, every node maintains a copy of the ledger which ensures there isn’t any discrepancy due to a single point of control. Transparency: All the nodes and participants can view the ledger ensuring transparency throughout the network. In Ethrerneum the transactions are visible on the blockchain explorer. Immutability: One needs to be very careful before executing any transaction because once it’s done it can’t be further altered. This property is quite helpful in preventing fraud and double-spending. Consensus Mechanism: Consensus mechanisms are a set of protocols that the nodes should follow in the network to agree on the state of the ledger. These mechanisms are used for the validation and authentication of transactions. These mechanisms ensure all nodes in the DLT agree on the state of the ledger. Components of a Blockchain Application Block structure in JavaScript: const crypto = require(‘crypto’);class Block { constructor(index, timestamp, data, previousHash = ”) { this.index = index; this.timestamp = timestamp; this.data = data; this.previousHash = previousHash; this.hash = this.calculateHash(); this.nonce = 0; // For Proof of Work } calculateHash() { return crypto.createHash(‘sha256’) .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce) .digest(‘hex’); } mineBlock(difficulty) { while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join(“0”)) { this.nonce++; this.hash = this.calculateHash(); } console.log(“Block mined: ” + this.hash); }} Creating and verifying transactions using JavaScript: Transactions form the basic building blocks of data in a blockchain. They show a shift in value, carry out a contract, or make other changes to the blockchain’s condition. The system groups these transactions into blocks and puts them on the blockchain. Details of the Transaction: Sender: The public key or specific identification of who’s sending it over. Receiver: The public key or specific identification of the lucky one who’s getting the transaction. Amount: What’s getting passed around, be it money or some info. Time Stamp: When they decided to hit send on this thing. Authenticity Proof/Signature: Some super-secret code stuff that shows the deal’s legit and has not been tampered with. The one who sends it uses their secret key to seal the deal, and everyone else can check it’s for real with the public key. Code snippet for the transaction: class Transaction { constructor(fromAddress, toAddress, amount) { this.fromAddress = fromAddress; this.toAddress = toAddress; this.amount = amount; this.timestamp = new Date().toISOString(); } calculateHash() { return crypto.createHash(‘sha256’) .update(this.fromAddress + this.toAddress + this.amount + this.timestamp) .digest(‘hex’); } signTransaction(signingKey) { if (signingKey.getPublic(‘hex’) !== this.fromAddress) { throw new Error(‘You cannot sign transactions for other wallets!’); } const hashTx = this.calculateHash(); const sig = signingKey.sign(hashTx, ‘base64’); this.signature = sig.toDER(‘hex’); } isValid() { if (this.fromAddress === null) return true; if (!this.signature || this.signature.length === 0) { throw new Error(‘No signature in this transaction’); } const publicKey = ec.keyFromPublic(this.fromAddress, ‘hex’); return publicKey.verify(this.calculateHash(), this.signature); }} Transaction verification confirms the legitimacy of a transaction by checking that the sender has properly signed it and that the sender has enough funds. This process usually involves validating the cryptographic signature and ensuring that the sender’s balance is equal to or greater than the transaction amount. class Blockchain { constructor() { this.chain = [this.createGenesisBlock()]; this.pendingTransactions = []; this.miningReward = 100; } createGenesisBlock() { return new Block(Date.parse(‘2024-01-01’), [], ‘0’); } getLatestBlock() { return this.chain[this.chain.length – 1]; } minePendingTransactions(miningRewardAddress) { let block = new Block(Date.now(), this.pendingTransactions, this.getLatestBlock().hash); block.mineBlock(this.difficulty); console.log(‘Block successfully mined!’); this.chain.push(block); this.pendingTransactions = [ new Transaction(null, miningRewardAddress, this.miningReward) ]; } addTransaction(transaction) { if (!transaction.fromAddress || !transaction.toAddress) { throw new Error(‘Transaction must include from and to address’); } if (!transaction.isValid()) { throw new Error(‘Cannot add invalid transaction to chain’); } this.pendingTransactions.push(transaction); } getBalanceOfAddress(address) { let balance = 0; for (const block of this.chain) { for (const trans of block.data) { if (trans.fromAddress === address) { balance -= trans.amount; } if (trans.toAddress === address) { balance += trans.amount; } } } return balance; } isChainValid() { for (let i = 1; i < this.chain.length; i++) { const currentBlock = this.chain[i]; const previousBlock = this.chain[i – 1]; if (!currentBlock.hasValidTransactions()) { return false; } if (currentBlock.hash !== currentBlock.calculateHash()) { return false; } if (currentBlock.previousHash !== previousBlock.hash) { return false; } } return true; }} Overview of consensus algorithms compatible with JavaScript: Proof of Work (PoW): Technical Explanation: Proof of Work is also known as mining. In this consensus mechanism, the users have to solve cryptographic puzzles that reward them.It is a contest where the first one to solve gets to pass the new block. This algorithm uses hashing to secure the blockchain. Developer Implementation: Tools for implementing PoW are provided by the Bitcoin Developer Environment like Bitcoin Core. Proof of Stake (PoS): Technical Explanation: Proof of Stake selects validators based on the number of coins they have and the stake as collateral. The selection process just doesn’t depend only upon the stake but also on factors such as the age of the coin and randomness. Validators having the lowest hash value and highest stake amount are chosen to add the new block Developer Implementation: Tools and libraries for PoS are provided by Ethereum 2.0 SDK Delegated Proof of Stake (DPoS): Technical Explanation: Uses voting and delegates for validation of the transaction and creation of new blocks. Developer Implementation: EOSIO SDK provides tools and libraries for DPoS. Chapter 3: Building a Simple Blockchain with JavaScript In this you will learn about the blockchain structure, defining classes and block and block parameters, and how they are linked together. Creating the Block Class Blockchain as the name represents is comprised of blocks and each block class bas attributes like: Index: A numerical identifier for the block’s position within the blockchain. Timestamp: The time at which the block was created. Data: The data or transactions stored in the block. This could include information like transaction details, user data, etc. PreviousHash: The hash of the previous block in the chain, ensuring continuity and security. Hash: A unique identifier for the block, generated by hashing the block’s contents. Nonce: A number used for the Proof of Work algorithm, which is adjusted until a valid hash is found. Implement methods to calculate the hash of the block using JavaScript syntax: createGenesisBlock(): Creates the first block in the blockchain, known as the genesis block. getLatestBlock(): Retrieves the most recent block in the blockchain. addBlock(): Adds a new block to the blockchain after mining it. isChainValid(): Validates the integrity of the blockchain by ensuring each block’s hash matches and that the previous hashes are consistent. Creating the Blockchain Class Define a Blockchain class to manage the chain and implement methods to add new blocks: class Blockchain { constructor() { this.chain = [this.createGenesisBlock()]; this.difficulty = 4; // Difficulty level for mining } // Method to create the genesis block createGenesisBlock() { return new Block(0, “01/01/2024”, “Genesis Block”, “0”); } // Method to retrieve the latest block in the chain getLatestBlock() { return this.chain[this.chain.length – 1]; } // Method to add a new block to the chain after mining it addBlock(newBlock) { newBlock.previousHash = this.getLatestBlock().hash; newBlock.mineBlock(this.difficulty); this.chain.push(newBlock); } // Method to validate the integrity of the blockchain isChainValid() { for (let i = 1; i < this.chain.length; i++) { const currentBlock = this.chain[i]; const previousBlock = this.chain[i – 1]; // Check if the current block’s hash is correct if (currentBlock.hash !== currentBlock.calculateHash()) { return false; } // Check if the current block’s previous hash matches the hash of the previous block if (currentBlock.previousHash !== previousBlock.hash) { return false; } } return true; }} Chapter 4: Implementing Consensus Mechanisms in JavaScript Proof of Work Proof of Work, often referred to as mining, is a decentralized system in which network members, or miners, compete to solve cryptographic puzzles. The first miner to solve the puzzle adds the next block to the blockchain and receives a reward. This process uses hashing to secure the blockchain. The difficulty of PoW puzzles ensures the blockchain remains secure and controls the speed at which new blocks are added. In the Block class, we can implement Proof of Work by adding a mineBlock method. This method adjusts the nonce until the block’s hash meets a specific difficulty target (e.g., the hash must start with a certain number of zeros). Code Snippet: class Block { constructor(index, timestamp, data, previousHash = ”) { this.index = index; this.timestamp = timestamp; this.data = data; this.previousHash = previousHash; this.hash = this.calculateHash(); this.nonce = 0; } // Calculate the hash of the block using SHA-256 calculateHash() { return crypto.createHash(‘sha256’) .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce) .digest(‘hex’); } // Implementing Proof of Work mineBlock(difficulty) { while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join(“0”)) { this.nonce++; this.hash = this.calculateHash(); } console.log(`Block mined: ${this.hash}`); }} Update the Blockchain class to validate proof before adding new blocks. class Blockchain { constructor() { this.chain = [this.createGenesisBlock()]; this.difficulty = 4; } // Create the genesis block createGenesisBlock() { return new Block(0, “01/01/2024”, “Genesis Block”, “0”); } // Get the latest block in the chain getLatestBlock() { return this.chain[this.chain.length – 1]; } // Add a new block to the chain addBlock(newBlock) { newBlock.previousHash = this.getLatestBlock().hash; newBlock.mineBlock(this.difficulty); // Implementing Proof of Work this.chain.push(newBlock); } // Check if the blockchain is valid isChainValid() { for (let i = 1; i < this.chain.length; i++) { const currentBlock = this.chain[i]; const previousBlock = this.chain[i – 1]; if (currentBlock.hash !== currentBlock.calculateHash()) { return false; } if (currentBlock.previousHash !== previousBlock.hash) { return false; } } return true; }} Chapter 5: Creating a Simple Blockchain API with JavaScript Just creating a blockchain is not enough one needs to make it usable in real life. For this purpose, we need to create an interface for interaction which will be a simple API. Setting Up the API Environment Before you start with building the API setting up the environment with all the essential tools and frameworks is necessary. Install node and npm Initialize your project with the command: npm init -y Install Express: npm install express –save (Express is the node js framework that helps in building APIs faster) Install Body parser to handle the incoming request: npm install body-parser –save Building the API Now that your environment is set up, let’s build the API. The API will allow users to interact with the blockchain, view the chain, and add new blocks. Create the server with Express: const express = require(‘express’);const bodyParser = require(‘body-parser’);const Blockchain = require(‘./blockchain’); // Import the Blockchain classconst app = express();app.use(bodyParser.json());let demoBlockchain = new Blockchain(); // Initialize a new Blockchain instance Define API endpoints app.get(‘/blocks’, (req, res) => { //endpoint to get the blockchain res.json(demoBlockchain.chain);});//this is the endpoint to create a newblockapp.post(‘/mine’, (req, res) => { const newBlock = new Block( demoBlockchain.chain.length, Date.now(), req.body.data, demoBlockchain.getLatestBlock().hash ); demoBlockchain.addBlock(newBlock); res.send(`Block successfully mined: ${newBlock.hash}`);}); Start the server app.listen(3000, () => { console.log(‘Blockchain API running on port 3000’);});node server.js Chapter 6: Running and Testing the Application This phase is critical to ensure that your blockchain is functioning correctly and that all features work as expected. Running the Application Start the server: Navigate to your project directory and then run the target: node server.js Get Server Confirmation: Blockchain API running on port 3000 Accessing the Application: Your application is now running locally on http://localhost:3000, making it ready to accept HTTP requests Testing with Postman Postman is a widely used tool for testing APIs, allowing you to send HTTP requests and view the responses. It’s particularly useful for verifying the functionality of your blockchain API. Install Postman Testing the Blockchain Endpoint Test the Mining endpoint Verify the blockchain (Step1)node server.jsBlockchain API running on port 3000//http://localhost:3000/block(Step2)[ { “index”: 0, “timestamp”: 1636568887994, “data”: “Genesis Block”, “previousHash”: “0”, “hash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9” }](Step3){ “data”: { “amount”: 100, “sender”: “John Doe”, “receiver”: “Jane Smith” }}(Step4){ “message”: “Block successfully mined”, “block”: { “index”: 1, “timestamp”: 1636578990123, “data”: { “amount”: 100, “sender”: “John Doe”, “receiver”: “Jane Smith” }, “previousHash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”, “hash”: “5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2” }} (Step5)[ { “index”: 0, “timestamp”: 1636568887994, “data”: “Genesis Block”, “previousHash”: “0”, “hash”:“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9” }, { “index”: 1, “timestamp”: 1636578990123, “data”: { “amount”: 100, “sender”: “John Doe”, “receiver”: “Jane Smith” }, “previousHash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”, “hash”: “5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2” }] curl http://localhost:3000/blocks //View the blockchain[ { “index”: 0, “timestamp”: 1636568887994, “data”: “Genesis Block”, “previousHash”: “0”, “hash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9” }]//Mining a new blockcurl -X POST -H “Content-Type: application/json” -d ‘{“data”: {“amount”: 100, “sender”: “John Doe”, “receiver”: “Jane Smith”}}’ http://localhost:3000/mine//verify the blockcurl http://localhost:3000/blocks[ { “index”: 0, “timestamp”: 1636568887994, “data”: “Genesis Block”, “previousHash”: “0”, “hash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9” }, { “index”: 1, “timestamp”: 1636578990123, “data”: { “amount”: 100, “sender”: “John Doe”, “receiver”: “Jane Smith” }, “previousHash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”, “hash”: “5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2” }] Chapter 7: Live Example of Building a Blockchain Application with JavaScript Step-by-Step Execution Step 1: Create the Block class with necessary attributes using JavaScript syntax. class Block { constructor(index, timestamp, data, previousHash = ”) { this.index = index; this.timestamp = timestamp; this.data = data; this.previousHash = previousHash; this.hash = this.calculateHash(); this.nonce = 0; }} Step 2: Implement the calculateHash method. calculateHash() { return crypto.createHash(‘sha256’) .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce) .digest(‘hex’);} Step 3: Define the Blockchain class and initialize it with a genesis block. class Blockchain { constructor() { this.chain = [this.createGenesisBlock()]; }} Step 4: Implement methods to add new blocks and retrieve the latest block using JavaScript. getLatestBlock() { return this.chain[this.chain.length – 1];}addBlock(newBlock) { newBlock.previousHash = this.getLatestBlock().hash; newBlock.hash = newBlock.calculateHash(); this.chain.push(newBlock);} Step 5: Add Proof of Work functionality to the Block class and update the Blockchain class. mineBlock(difficulty) { while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join(“0”)) { this.nonce++; this.hash = this.calculateHash(); }} Step 6: Set up the API environment to handle requests using Express. npm init -ynpm install express –save //Setting up the project andthe directoryconst express = require(‘express’); //Setting up the express serverconst bodyParser = require(‘body-parser’);const Blockchain = require(‘./blockchain’); // Assuming you have the Blockchain class from previous chaptersconst app = express();app.use(bodyParser.json());const demoBlockchain = new Blockchain();app.get(‘/blocks’, (req, res) => { res.json(demoBlockchain.chain);}); app.post(‘/mine’, (req, res) => { //creating a new block const newBlock = new Block(demoBlockchain.chain.length, Date.now(), req.body.data, demoBlockchain.getLatestBlock().hash); newBlock.mineBlock(2); // Assuming a difficulty of 2 for PoW demoBlockchain.addBlock(newBlock); res.send(`Block successfully mined: ${newBlock.hash}`);});app.listen(3000, () => { //starting the server console.log(‘Blockchain API running on port 3000’);});node server.js Step 7: Test the application by mining a new block and verifying the blockchain using Postman or curl. In postman send the request:GET request to http://localhost:3000/blocks.{ “data”: { “amount”: 10, “sender”: “Alice”, “receiver”: “Bob” }}In curl:curl http://localhost:3000/blocks Lets summarize the above steps in short Let’s go through the process step by step to bring your blockchain application to life: Begin by defining the Block and Blockchain classes to establish the core structure of your blockchain. Incorporate Proof of Work by adding the mineBlock method to the Block class, ensuring each block meets the required difficulty before being added to the chain. Set up an API using Express that allows you to interact with your blockchain, enabling operations like viewing the chain and adding new blocks. Execute and test your application with Postman or curl to verify that everything functions as expected, from mining blocks to retrieving the blockchain data. Happy Coding!!

Postarea Construirea unei aplicații Blockchain cu JavaScript a apărut mai întâi pe Coinpedia Fintech News
Introducere
Tehnologia Blockchain are un impact asupra multora dintre inovațiile actuale care schimbă jocul, de la criptomonede precum Bitcoin până la aplicații descentralizate (DApps) în diferite domenii. Un blockchain este un registru partajat care ține evidența tranzacțiilor pe mai multe computere, astfel încât înregistrarea să nu poată fi schimbată după fapt. Fiecare intrare, sau „bloc”, este conectată la cea dinaintea ei, formând un lanț de blocuri, motiv pentru care se numește „blockchain”. Această configurare se asigură că datele sunt deschise, securizate și nu pot fi modificate, ceea ce este esențial pentru multe utilizări
JavaScript în Blockchain
Javascript este un limbaj cu mai multe fațete și celebru, potrivit în special pentru dezvoltarea blockchain. Cu ecosistemul său extins și sprijinul puternic al comunității, JavaScript simplifică dezvoltarea blockchain în mai multe moduri:
Adopție largă: Deoarece Javascript este limbajul de bază folosit pentru dezvoltarea web, este foarte evident să existe aplicații în peisajul blockchain cu aplicații web.
Procesare asincronă: capabilitățile asincrone ale JavaScript, facilitate de Node.js, sunt ideale pentru gestionarea tranzacțiilor și interacțiunilor multiple într-un mediu blockchain.
Ecosistem bogat: instrumentele și bibliotecile din ecosistemul JavaScript, cum ar fi Node.js pentru dezvoltarea pe server și Express.js pentru API-uri, eficientizează dezvoltarea aplicațiilor blockchain.
Public
Acest articol este conceput pentru dezvoltatorii care sunt familiarizați cu JavaScript și doresc să se aprofundeze în tehnologia blockchain. Vă va ghida prin configurarea mediului de dezvoltare, înțelegerea fundamentelor blockchain, construirea unei aplicații de bază blockchain și expunerea acesteia printr-un API simplu.
Capitolul 1: Configurarea mediului de dezvoltare
Instalarea Node.js
Descărcați node js pe sistemul dvs. de pe site-ul oficial și preferați versiunea LTS (Long Term Support), deoarece este recomandată cea mai bună pentru toate sistemele de operare și mențineți stabilitatea.
 Urmați instrucțiunile de instalare specifice sistemului dvs. de operare. Instalarea include npm (Node Package Manager), care este esențial pentru gestionarea dependențelor de proiect.
Verificați că instalarea este efectuată corect sau nu, rulând următoarele comenzi în bash:
nodul -v
npm -v
După ce rulați comenzile, ar trebui să obțineți versiunile corespunzătoare ale pachetelor pe care le-ați instalat dacă configurarea are succes.
Alegerea unui IDE
Când optați pentru JavaScript ca limbaj de programare, cel mai bun partener pentru a satisface toate nevoile de dezvoltare este VsCode, caracteristicile sale robuste și mediul versatil este cel mai potrivit.
Cod Visual Studio:
Descărcați VsCode de pe site-ul oficial
Instalați extensiile după cum urmează:
ESLint: pentru identificarea și remedierea problemelor în codul JavaScript.
Mai frumos: pentru formatarea coerentă a codului.
Depanator pentru Chrome: pentru depanarea codului JavaScript care rulează în Google Chrome.
Node.js: pentru capabilitățile de depanare Node.js.
Instalarea bibliotecilor necesare
Bibliotecile JavaScript sunt gestionate prin npm. Inițializați-vă proiectul și instalați bibliotecile necesare cu:
npm init -ynpm install express body-parser crypto//express este cadrul nodului //body-parser este programul mediu pentru a analiza cererile primite//funcția cripto folosită pentru hashing
Capitolul 2: Înțelegerea conceptelor Blockchain cu JavaScript
Bazele blockchain în JavaScript
Un blockchain este format din blocuri, care conțin:
Index: Poziția blocului în lanț.
Marca temporală: data și ora la care a fost creat blocul.
Date: date despre tranzacție sau alte informații stocate în bloc.
Previous Hash: Hash al blocului anterior din lanț, care leagă blocurile între ele.
Hash: identificator unic pentru bloc, generat prin hashing conținutul acestuia.
const crypto = require(‘crypto’);class Block {    constructor(index, timestamp, data, previousHash = ”) {        this.index = index;        this.timestamp = marcaj temporal;        this.data = date;        this.previousHash = previousHash;        this.hash = this.calculateHash();    }    calculateHash() {        return crypto.createHash(‘sha256’)            .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data))            ); est    }}
Importanța mecanismelor de descentralizare, imuabilitate și consens:
Descentralizare: 
Nu există nicio autoritate centrală care să dețină toate datele necesare sau validarea tranzacțiilor, mai degrabă, toate acestea sunt distribuite în rețea. După cum știm în blockchain, fiecare nod păstrează o copie a registrului, care asigură că nu există nicio discrepanță din cauza unui singur punct de control. 
Transparenţă:
Toate nodurile și participanții pot vizualiza registrul asigurând transparență în întreaga rețea. În Ethrerneum tranzacțiile sunt vizibile în exploratorul blockchain.
Imuabilitate:
Trebuie să fii foarte atent înainte de a executa orice tranzacție, deoarece odată ce este finalizată, nu poate fi modificată în continuare. Această proprietate este destul de utilă în prevenirea fraudei și a dublei cheltuieli.
Mecanism de consens:
Mecanismele de consens sunt un set de protocoale pe care nodurile ar trebui să le urmeze în rețea pentru a conveni asupra stării registrului. Aceste mecanisme sunt utilizate pentru validarea și autentificarea tranzacțiilor. Aceste mecanisme asigură că toate nodurile din DLT sunt de acord cu starea registrului. 
Componentele unei aplicații Blockchain
Structura blocurilor în JavaScript:
const crypto = require(‘crypto’);class Block {    constructor(index, timestamp, data, previousHash = ”) {        this.index = index;        this.timestamp = marcaj temporal;        this.data = date;        this.previousHash = precedentHash;        this.hash = this.calculateHash();        aceasta.nonce = 0; // Pentru dovada lucrării    }    calculateHash() {        return crypto.createHash('sha256')            .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.  nce.data)    di    nce. ('hex');    }    mineBlock(dificultate) {        while (this.hash.substring(0, dificultate) !== Array(dificulty + 1).join(“0”)) {            this.nonce++;            this.hash = this.calculateHash();        }        console.log(„Bloc minat: ” + this.hash);    }}
Crearea și verificarea tranzacțiilor folosind JavaScript:
Tranzacțiile formează blocurile de bază ale datelor într-un blockchain. Ei arată o schimbare a valorii, execută un contract sau fac alte modificări în starea blockchain-ului. Sistemul grupează aceste tranzacții în blocuri și le pune în blockchain.
Detalii despre tranzacție:
Expeditor: cheia publică sau identificarea specifică a cui o trimite.
Destinatar: cheia publică sau identificarea specifică a celui norocos care primește tranzacția.
Sumă: ce se transmite, fie că sunt bani sau unele informații.
Marca temporală: Când au decis să apese trimite pe acest lucru.
Dovada/Semnătura de autenticitate: Unele coduri super-secrete care arată că afacerea este legitimă și nu a fost modificată. Cel care îl trimite își folosește cheia secretă pentru a încheia afacerea, iar toți ceilalți pot verifica dacă este real cu cheia publică.
Fragment de cod pentru tranzacție:
clasa Tranzacție {    constructor(fromAddress, toAddress, amount) {        this.fromAddress = fromAddress;        this.toAddress = toAddress;        this.amount = suma;        this.timestamp = data noua().toISOString();    }    calculateHash() {        return crypto.createHash(‘sha256’)            .update(this.fromAddress + this.toAddress + this.amount + this.timestamp)                 ;('  .digest);    }    signTransaction(signingKey) {        if (signingKey.getPublic(‘hex’) !== this.fromAddress) {            throw new Error(‘Nu poți semna tranzacții pentru alte portofele!’);        }        const hashTx = this.calculateHash();        const sig = signingKey.sign(hashTx, ‘base64’);        this.signature = sig.toDER(‘hex’);    }    isValid() {        dacă (this.fromAddress === null) returnează adevărat;        if (!this.signature || this.signature.length === 0) {            throw new Error(‘Fără semnătură în această tranzacție’);        }        const publicKey = ec.keyFromPublic(this.fromAddress, ‘hex’);        return publicKey.verify(this.calculateHash(), this.signature);    }}
Verificarea tranzacției confirmă legitimitatea unei tranzacții prin verificarea faptului că expeditorul a semnat-o corect și că expeditorul are suficiente fonduri. Acest proces implică de obicei validarea semnăturii criptografice și asigurarea faptului că soldul expeditorului este egal sau mai mare decât suma tranzacției.
clasa Blockchain {    constructor() {        this.chain = [this.createGenesisBlock()];        this.pendingTransactions = [];        this.miningReward = 100;    }    createGenesisBlock() {        return new Block(Date.parse(‘2024-01-01’), [], ‘0’);    }    getLatestBlock() {        return this.chain[this.chain.length – 1];    }    minePendingTransactions(miningRewardAddress) {        let block = new Block(Date.now(), this.pendingTransactions, this.getLatestBlock().hash);        block.mineBlock(aceasta.dificultate);        console.log(‘Blocul minat cu succes!’);        acest.lanț.împinge(bloc);        this.pendingTransactions = [            nouă Tranzacție (null, miningRewardAddress, this.miningReward)        ];    }    addTransaction(tranzacție) {        if (!transaction.fromAddress || !transaction.toAddress) {            throw new Error(„Tranzacția trebuie să includă adresa de la și către adresa”);        }        if (!transaction.isValid()) {            throw new Error(‘Nu se poate adăuga tranzacție nevalidă în lanț’);        }        this.pendingTransactions.push(tranzacție);    }    getBalanceOfAddress(adresă) {        let sold = 0;        for (const block of this.chain) {            for (const trans of block.data) {                if (trans.fromAddress === adresa) {                    balance -= trans.amount;                }                dacă (trans.laAdresă === adresă) {                    sold += trans.suma;                }            }        }        sold de returnare;    }    isChainValid() {        for (fie i = 1; i < this.chain.length; i++) {            const currentBlock = this.lanț[i];            const previousBlock = this.chain[i – 1];            dacă (!currentBlock.hasValidTransactions()) {                return false;            }            if (currentBlock.hash !== currentBlock.calculateHash()) {                return false;            }            dacă (currentBlock.previousHash !== previousBlock.hash) {                return false;            }        }        return true;    }}
Prezentare generală a algoritmilor de consens compatibili cu JavaScript:
Dovada muncii (PoW):
Explicație tehnică: Dovada muncii este cunoscută și sub numele de minerit. În acest mecanism de consens, utilizatorii trebuie să rezolve puzzle-uri criptografice care îi recompensează. Este un concurs în care primul care o rezolvă ajunge să treacă de noul bloc. Acest algoritm folosește hashing pentru a securiza blockchain-ul. 
Implementarea dezvoltatorilor: Instrumentele pentru implementarea PoW sunt furnizate de Mediul pentru dezvoltatori Bitcoin, cum ar fi Bitcoin Core.
Dovada mizei (PoS):
Explicație tehnică: Proof of Stake selectează validatorii în funcție de numărul de monede pe care le dețin și de miza ca garanție. Procesul de selecție nu depinde doar de miză, ci și de factori precum vârsta monedei și aleatorietatea. Validatorii care au cea mai mică valoare hash și cea mai mare miză sunt aleși pentru a adăuga noul bloc
Implementare pentru dezvoltatori: instrumentele și bibliotecile pentru PoS sunt furnizate de Ethereum 2.0 SDK
Dovada de miză delegată (DPoS):
Explicație tehnică:  Utilizează votul și delegații pentru validarea tranzacției și crearea de noi blocuri.
Implementare pentru dezvoltatori: EOSIO SDK oferă instrumente și biblioteci pentru DPoS.
Capitolul 3: Construirea unui Blockchain simplu cu JavaScript
 În aceasta veți afla despre structura blockchain-ului, definirea claselor și parametrii blocurilor și blocurilor și modul în care acestea sunt legate între ele.
Crearea clasei bloc
Blockchain-ul, așa cum îl reprezintă numele, este format din blocuri și fiecare clasă de blocuri bas atribute cum ar fi:
Index: un identificator numeric pentru poziția blocului în blockchain.
Timp: ora la care a fost creat blocul.
Date: Datele sau tranzacțiile stocate în bloc. Aceasta ar putea include informații precum detaliile tranzacției, datele utilizatorului etc.
PreviousHash: Hash-ul blocului anterior din lanț, asigurând continuitate și securitate.
Hash: un identificator unic pentru bloc, generat prin hashing conținutul blocului.
Nonce: un număr folosit pentru algoritmul Proof of Work, care este ajustat până când este găsit un hash valid.
Implementați metode pentru a calcula hash-ul blocului folosind sintaxa JavaScript:
createGenesisBlock(): creează primul bloc din blockchain, cunoscut sub numele de bloc genesis.
getLatestBlock(): Preia cel mai recent bloc din blockchain.
addBlock(): adaugă un nou bloc în blockchain după extragerea lui.
isChainValid(): validează integritatea blockchain-ului, asigurându-se că hashurile fiecărui bloc se potrivesc și că hashurile anterioare sunt consecvente.
Crearea clasei Blockchain
Definiți o clasă Blockchain pentru a gestiona lanțul și implementați metode pentru a adăuga noi blocuri:
clasa Blockchain {    constructor() {        this.chain = [this.createGenesisBlock()];        aceasta.dificultate = 4;  // Nivel de dificultate pentru minerit    }    // Metoda de creare a blocului genesis    createGenesisBlock() {        return new Block(0, „01/01/2024”, „Genesis Block”, „0”);    }    // Metodă de a prelua cel mai recent bloc din lanț    getLatestBlock() {        return this.chain[this.chain.length – 1];    }    // Metodă de adăugare a unui bloc nou în lanț după extragerea acestuia    addBlock(newBlock) {        newBlock.previousHash = this.getLatestBlock().hash;        newBlock.mineBlock(aceasta.dificultate);        this.chain.push(newBlock);    }    // Metodă de validare a integrității blockchain-ului    isChainValid() {        for (let i = 1; i < this.chain.length; i++) {            const currentBlock = this.chain[i];            const previousBlock = this.chain[i – 1];            // Verificați dacă hash-ul blocului curent este corect            if (currentBlock.hash !== currentBlock.calculateHash()) {                return false;            }            // Verificați dacă hash-ul anterior al blocului curent se potrivește cu hash-ul blocului anterior            if (currentBlock.previousHash !== previousBlock.hash) {                return false;            }        }        return true;    }}
Capitolul 4: Implementarea mecanismelor de consens în JavaScript
Dovada Muncii
Proof of Work, denumită adesea mining, este un sistem descentralizat în care membrii rețelei, sau minerii, concurează pentru a rezolva puzzle-uri criptografice. Primul miner care a rezolvat puzzle-ul adaugă următorul bloc la blockchain și primește o recompensă. Acest proces folosește hashing pentru a securiza blockchain-ul. Dificultatea puzzle-urilor PoW asigură că blockchain-ul rămâne sigur și controlează viteza cu care sunt adăugate blocuri noi.
În clasa Block, putem implementa Proof of Work prin adăugarea unei metode mineBlock. Această metodă ajustează nonce până când hash-ul blocului îndeplinește o anumită țintă de dificultate (de exemplu, hash-ul trebuie să înceapă cu un anumit număr de zerouri).
Fragment de cod:
class Block {    constructor(index, timestamp, data, previousHash = ”) {        this.index = index;        this.timestamp = marcaj temporal;        this.data = date;        this.previousHash = previousHash;        this.hash = this.calculateHash();        aceasta.nonce = 0;    }    // Calculați hash-ul blocului folosind SHA-256    calculateHash() {        return crypto.createHash('sha256')           .update(this.index + this.previousHash + this.timestamp +(this.timestamp) +(this.timestamp) this.nonce)            .digest('hex');    }    // Implementarea dovezii de lucru    mineBlock(dificultate) {        while (this.hash.substring(0, dificultate) !== Array(dificulty + 1).join(“0”)) {            this.nonce++;            this.hash = this.calculateHash();        }        console.log(`Block mined: ${this.hash}`);    }}
Actualizați clasa Blockchain pentru a valida dovada înainte de a adăuga noi blocuri.
clasa Blockchain {    constructor() {        this.chain = [this.createGenesisBlock()];        aceasta.dificultate = 4;    }    // Creați blocul genesis    createGenesisBlock() {        return new Block(0, „01/01/2024”, „Genesis Block”, „0”);    }    // Obțineți cel mai recent bloc din lanț    getLatestBlock() {        return this.chain[this.chain.length – 1];    }    // Adăugați un bloc nou în lanț    addBlock(newBlock) {        newBlock.previousHash = this.getLatestBlock().hash;        newBlock.mineBlock(aceasta.dificultate);  // Implementarea dovezii de lucru        this.chain.push(newBlock);    }    // Verificați dacă blockchain-ul este valid    isChainValid() {        pentru (let i = 1; i < this.chain.length; i++) {            const currentBlock = this.chain[i];            const previousBlock = this.chain[i – 1];            if (currentBlock.hash !== currentBlock.calculateHash()) {                return false;            }            dacă (currentBlock.previousHash !== previousBlock.hash) {                return false;            }        }        return true;    }}
Capitolul 5: Crearea unui API Blockchain simplu cu JavaScript
Doar crearea unui blockchain nu este suficientă pentru a-l face utilizabil în viața reală. În acest scop, trebuie să creăm o interfață de interacțiune care va fi un simplu API.
Configurarea mediului API
Înainte de a începe să construiți API-ul, este necesară configurarea mediului cu toate instrumentele și cadrele esențiale.
Instalați node și npm 
Inițializați-vă proiectul cu comanda: npm init -y
Install Express: npm install express –save (Express este cadrul nod js care ajută la construirea mai rapidă a API-urilor)
Instalați Body parser pentru a gestiona cererea de intrare: npm install body-parser –save
Construirea API-ului
Acum că mediul dvs. este configurat, să construim API-ul. API-ul va permite utilizatorilor să interacționeze cu blockchain-ul, să vadă lanțul și să adauge noi blocuri.
Creați serverul cu Express:
const express = require(‘express’);const bodyParser = require(‘body-parser’);const Blockchain = require(‘./blockchain’);  // Importă aplicația Blockchain classconst = express();app.use(bodyParser.json());let demoBlockchain = new Blockchain();  // Inițializați o nouă instanță Blockchain
Definiți punctele finale API
app.get('/blocks', (req, res) => {     //endpoint pentru a obține blockchain-ul    res.json(demoBlockchain.chain);});//acesta este punctul final pentru a crea un newblockapp.post(' /mine', (req, res) => {    const newBlock = new Block(        demoBlockchain.chain.length,        Date.now(),        req.body.data,        demoBlockchain. ); latestBlock (demoBlockchain. ); LatestBlock blocare );     res.send(`Blocul extras cu succes: ${newBlock.hash}`);});
Porniți serverul
app.listen(3000, () => {    console.log(‘Blockchain API rulează pe portul 3000’);});node server.js
Capitolul 6: Rularea și testarea aplicației
Această fază este critică pentru a vă asigura că blockchain-ul dumneavoastră funcționează corect și că toate funcțiile funcționează conform așteptărilor.
Rularea aplicației
Porniți serverul: navigați la directorul proiectului și apoi rulați ținta: node server.js
Obțineți confirmarea serverului: API-ul Blockchain rulează pe portul 3000
Accesarea aplicației: aplicația dvs. rulează acum local pe http://localhost:3000, făcând-o gata să accepte solicitări HTTP
Testare cu Postman
Postman este un instrument utilizat pe scară largă pentru testarea API-urilor, permițându-vă să trimiteți solicitări HTTP și să vizualizați răspunsurile. Este deosebit de util pentru verificarea funcționalității API-ului blockchain.
Instalați Postman
Testarea punctului final Blockchain
Testați punctul final Mining
Verificați blockchain-ul
(Step1)node server.jsBlockchain API rulează pe portul 3000//http://localhost:3000/block(Step2)[    {        „index”: 0,       „timestamp”: 1636568888888     ,         „ previousHash”: „0”,        „hash”: „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    }](Pasul 3. : " :     " :     " :     " ,        „emițător”: „John Doe”,        „destinatar”: „Jane Smith”    }} (Pasul 4){    „mesaj”: „Blocare extrasă cu succes”,    „blocare”: {        „index”: 1,       „marca temporală”: 1636578990123,         „date”:                         „sender”: „John Doe” ,            „receptor”: „Jane Smith”        },        „previousHash”: „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d               „hash”: „5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    }} (Pasul 5)[    {         “     ” 6” :    ” 6”    6 87994,        „date”: „ Genesis Block”,        „previousHash”: „0”,        „hash”:„81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b”
 
   },    {
 
       „index”: 1,        „marca temporală”: 1636578990123,        „date”: {            „sumă”: 100,            „expeditor”: „John Doe” :                                   },        „previousHash”: „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”, „hash”: „5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    }]
curl http://localhost:3000/blocks //Vizualizați blockchain-ul[    {        „index”: 0,        „timestamp”: 1636568887994,         „date”: „Genesis Block”,       :         „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    }]//Exploarea unui nou blockcurl -X POST -H „Content-Type: application/{“:“:”: „John”: „0:“:” hn Doe”, „ receptor”: „Jane Smith”}}' http://localhost:3000/mine//verify the blockcurl http://localhost:3000/blocks[    {        „index”: 0,        „timestamp”: 1636568887994,            : „Blocul Genesis”,        „previousHash”: „0”,        „hash”: „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022e12022e12022e12022e                     index”: 1,        „marca temporală”: 1636578990123,        „date”: {            „sumă”: 100,             „expeditor” : „John Doe”,            „destinator”: „Jane Smith”        },        „previousHash”: „81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca782”,             „hash”: „5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    }]
Capitolul 7: Exemplu live de construire a unei aplicații Blockchain cu JavaScript
Execuție pas cu pas
Pasul 1: Creați clasa Block cu atributele necesare folosind sintaxa JavaScript.
class Block {    constructor(index, timestamp, data, previousHash = ”) {        this.index = index;        this.timestamp = marcaj temporal;        this.data = date;        this.previousHash = previousHash;        this.hash = this.calculateHash();        aceasta.nonce = 0;    }}
Pasul 2: Implementați metoda calculateHash.
calculateHash() {    return crypto.createHash(‘sha256’)        .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)        .digest(‘hex’);}
Pasul 3: Definiți clasa Blockchain și inițializați-o cu un bloc de geneză.
clasa Blockchain {    constructor() {        this.chain = [this.createGenesisBlock()];    }}
Pasul 4: Implementați metode pentru a adăuga blocuri noi și pentru a prelua cel mai recent bloc folosind JavaScript.
getLatestBlock() {    return this.chain[this.chain.length – 1];}addBlock(newBlock) {    newBlock.previousHash = this.getLatestBlock().hash;    newBlock.hash = newBlock.calculateHash();    this.chain.push(newBlock);}
Pasul 5: Adăugați funcționalitatea Proof of Work la clasa Block și actualizați clasa Blockchain.
mineBlock(dificultate) {    while (this.hash.substring(0, dificultate) !== Array(dificulty + 1).join(“0”)) {        this.nonce++;        this.hash = this.calculateHash();    }}
Pasul 6: Configurați mediul API pentru a gestiona solicitările folosind Express.
npm init -ynpm install express –save                        //Configurarea proiectului și a directoruluiconst express = require(‘express’);      //Configurarea serverului expres const bodyParser = require(‘body-parser’);const Blockchain = require(‘./blockchain’); // Presupunând că aveți clasa Blockchain din capitolele anterioareconst app = express();app.use(bodyParser.json());const demoBlockchain = new Blockchain();app.get('/blocks', (req, res) => {    res.json(demoBlockchain.chain);});      app.post('/mine', (req, res) => {            //crearea unui nou bloc             const newBlock = new Block(demoBlockchain.chain.length,         Data.now(),    de                                                                                                                                                              const newBlock ('/mine), (req, res) => {            ().hash);     newBlock.mineBlock(2) // Presupunând o dificultate de 2 pentru PoW    demoBlockchain.addBlock(newBlock);     res.send(`Block cu succes: ${newBlock.hash}`);}); app.listen(3000, () => {                               //pornirea serverului    console.log('Blockchain API rulează pe portul 3000');});node server.js
Pasul 7: Testați aplicația prin extragerea unui bloc nou și verificând blockchain-ul folosind Postman sau curl.
În poștaș trimiteți cererea: solicitarea GET către http://localhost:3000/blocks.{    „date”: {        „sumă”: 10,        „sender”: „Alice”,        „receptor”: „Bob”    }}În curl :curl http://localhost:3000/blocks
Să rezumăm pe scurt pașii de mai sus
Să parcurgem procesul pas cu pas pentru a aduce la viață aplicația ta blockchain:
Începeți prin a defini clasele Block și Blockchain pentru a stabili structura de bază a blockchain-ului dvs.
Încorporați Proof of Work prin adăugarea metodei mineBlock la clasa Block, asigurându-vă că fiecare bloc îndeplinește dificultatea necesară înainte de a fi adăugat în lanț.
Configurați un API folosind Express care vă permite să interacționați cu blockchain-ul dvs., permițând operațiuni precum vizualizarea lanțului și adăugarea de noi blocuri.
Executați și testați aplicația dvs. cu Postman sau curl pentru a verifica dacă totul funcționează conform așteptărilor, de la extragerea blocurilor până la preluarea datelor blockchain.
Codare fericită!!

Explorați mai multe de la acest creator

Ultimele știri