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!!

Ziņa Blokķēdes lietojumprogrammas izveide ar JavaScript pirmo reizi parādījās vietnē Coinpedia Fintech News
Ievads
Blockchain tehnoloģijai ir ietekme uz daudziem mūsdienu jauninājumiem, kas maina spēli, sākot no kriptovalūtām, piemēram, Bitcoin, līdz decentralizētām lietotnēm (DApps) dažādās jomās. Blokķēde ir koplietojama virsgrāmata, kas reģistrē darījumus daudzos datoros, lai ierakstu pēc tam nevarētu mainīt. Katrs ieraksts jeb “bloks” ir savienots ar iepriekšējo, veidojot bloku ķēdi, tāpēc to sauc par “blokķēdi”. Šī iestatīšana nodrošina, ka dati ir atvērti, droši un tos nevar mainīt, kas ir ļoti svarīgi daudzos gadījumos.
JavaScript blokķēdē
Javascript ir daudzpusīga un slavena valoda, kas īpaši piemērota blokķēdes izstrādei. Ar savu plašo ekosistēmu un spēcīgu kopienas atbalstu JavaScript vienkāršo blokķēdes izstrādi vairākos veidos:
Plaša pieņemšana: tā kā Javascript ir galvenā valoda, ko izmanto tīmekļa izstrādē, ir ļoti acīmredzams, ka to var izmantot blokķēdes ainavā ar tīmekļa lietojumprogrammām.
Asinhronā apstrāde: JavaScript asinhronās iespējas, ko veicina Node.js, ir ideāli piemērotas vairāku darījumu un mijiedarbību apstrādei blokķēdes vidē.
Bagātīga ekosistēma: rīki un bibliotēkas JavaScript ekosistēmā, piemēram, Node.js servera puses izstrādei un Express.js API, racionalizē blokķēdes lietojumprogrammu izstrādi.
Auditorija
Šis raksts ir paredzēts izstrādātājiem, kuri pārzina JavaScript un vēlas iedziļināties blokķēdes tehnoloģijā. Tas palīdzēs jums izveidot izstrādes vidi, izprast blokķēdes pamatus, izveidot pamata blokķēdes lietojumprogrammu un atklāt to, izmantojot vienkāršu API.
1. nodaļa: Attīstības vides iestatīšana
Node.js instalēšana
Lejupielādējiet node js savā sistēmā no oficiālās vietnes un dodiet priekšroku LTS (Long Term Support) versijai, jo tā ir ieteicama vislabākā visām operētājsistēmām un saglabāt stabilitāti.
 Izpildiet instalēšanas norādījumus, kas attiecas uz jūsu OS. Instalācija ietver npm (Node Package Manager), kas ir būtiska projektu atkarību pārvaldībai.
Pārbaudiet, vai instalēšana ir veikta pareizi, palaižot šādas komandas bash:
mezgls -v
npm -v
Ja iestatīšana ir veiksmīga, pēc komandu izpildīšanas jums vajadzētu iegūt attiecīgās instalēto pakotņu versijas.
IDE izvēle
Izvēloties JavaScript kā savu programmēšanas valodu, vislabākais partneris visu izstrādes vajadzību apmierināšanai ir VsCode, tā robustās funkcijas un daudzpusīgā vide ir vislabāk piemērota.
Visual Studio kods:
Lejupielādējiet VsCode no oficiālās vietnes
Instalējiet paplašinājumus šādi:
ESLint: lai identificētu un novērstu problēmas JavaScript kodā.
Skaistāks: konsekventai koda formatēšanai.
Atkļūdotājs pārlūkam Chrome: lai atkļūdotu JavaScript kodu, kas darbojas pārlūkprogrammā Google Chrome.
Node.js: Node.js atkļūdošanas iespējām.
Nepieciešamo bibliotēku instalēšana
JavaScript bibliotēkas tiek pārvaldītas, izmantojot npm. Inicializējiet savu projektu un instalējiet vajadzīgās bibliotēkas ar:
npm init -ynpm install express body-parser crypto//express ir mezgla ietvars //body-parser ir starpprogrammatūra ienākošo pieprasījumu parsēšanai//šifrēšanas funkcija, ko izmanto jaukšanai
2. nodaļa: Blockchain jēdzienu izpratne, izmantojot JavaScript
Blockchain pamati JavaScript
Blokķēde sastāv no blokiem, kas satur:
Indekss: bloka pozīcija ķēdē.
Laika zīmogs: bloka izveides datums un laiks.
Dati: Darījuma dati vai cita informācija, kas tiek glabāta blokā.
Iepriekšējais jaukums: ķēdes iepriekšējā bloka jaucējvārds, kas savieno blokus kopā.
Jaukšana: bloka unikāls identifikators, kas ģenerēts, jaukjot tā saturu.
const crypto = prasīt('crypto');klases bloks {    konstruktors(indekss, laikspiedols, dati, iepriekšējais hash = ) {        this.index = indekss;        this.timestamp = laikspiedols;        this.data = dati;        this.previousHash = previousHash;        this.hash = this.calculateHash();    }    calculateHash() {        atgriezt crypto.createHash('sha256')            .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data))            .digest('hex');    }}
Decentralizācijas, nemainīguma un vienprātības mehānismu nozīme:
Decentralizācija: 
Nav nevienas centrālās iestādes, kas glabā visus nepieciešamos datus vai darījumu validāciju, bet gan tas viss tiek izplatīts tīklā. Kā mēs zinām blokķēdē, katrs mezgls uztur virsgrāmatas kopiju, kas nodrošina, ka viena kontroles punkta dēļ nav nekādu neatbilstību. 
Pārredzamība:
Visi mezgli un dalībnieki var skatīt virsgrāmatu, nodrošinot caurspīdīgumu visā tīklā. Programmā Ethrerneum darījumi ir redzami blokķēdes pārlūkā.
Nemainība:
Pirms jebkura darījuma veikšanas jābūt ļoti uzmanīgam, jo, kad tas ir izdarīts, to vairs nevar mainīt. Šis īpašums ir ļoti noderīgs, lai novērstu krāpšanu un dubultu tēriņu.
Vienprātības mehānisms:
Vienprātības mehānismi ir protokolu kopa, kas mezgliem jāievēro tīklā, lai vienotos par virsgrāmatas stāvokli. Šie mehānismi tiek izmantoti darījumu apstiprināšanai un autentifikācijai. Šie mehānismi nodrošina, ka visi DLT mezgli vienojas par virsgrāmatas stāvokli. 
Blockchain lietojumprogrammas sastāvdaļas
Bloķēšanas struktūra JavaScript:
const crypto = prasīt('crypto');klases bloks {    konstruktors(indekss, laikspiedols, dati, iepriekšējais hash = ) {        this.index = indekss;        this.timestamp = laikspiedols;        this.data = dati;        this.previousHash = previousHash;        this.hash = this.calculateHash();        this.nonce = 0; // Darba apliecinājumam    }    calculateHash() {        return crypto.createHash('sha256')            .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)            .digest ('hex');    }    mineBlock(grūtības) {        while (this.hash.substring(0, grūtības) !== Masīvs(grūtības + 1).join("0") {            this.nonce++;            this.hash = this.calculateHash();        }        console.log(“Block mined:” + this.hash);    }}
Darījumu izveide un pārbaude, izmantojot JavaScript:
Darījumi veido galvenos datu blokus blokķēdē. Tie parāda vērtības maiņu, slēdz līgumu vai veic citas izmaiņas blokķēdes stāvoklī. Sistēma sagrupē šos darījumus blokos un ievieto blokķēdē.
Sīkāka informācija par darījumu:
Sūtītājs: publiskā atslēga vai īpaša identifikācija, kas to sūta.
Saņēmējs: publiskā atslēga vai īpaša identifikācija laimīgajam, kurš saņem darījumu.
Summa: kas tiek nodots, vai tā būtu nauda vai kāda informācija.
Laika zīmogs: Kad viņi nolēma nospiest šo lietu, nosūtiet.
Autentiskuma apliecinājums/paraksts: daži īpaši slepeni koda elementi, kas parāda darījuma likumīgumu un nav bojāti. Tas, kurš to nosūta, izmanto savu slepeno atslēgu, lai noslēgtu darījumu, un visi pārējie var pārbaudīt, vai tā ir īsta, izmantojot publisko atslēgu.
Koda fragments darījumam:
klase Darījums {    constructor(fromAddress, toAddress, summa) {        this.fromAddress = fromAddress;        this.toAddress = toAdrese;        this.summa = summa;        this.timestamp = new Date().toISOString();    }    calculateHash() {        atgriezt 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('Jūs nevarat parakstīt darījumus citiem makiem!');        }        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('Šajā darījumā nav paraksta');        }        const publicKey = ec.keyFromPublic(this.fromAddress, 'hex');        return publicKey.verify(this.calculateHash(), this.signature);    }}
Darījuma pārbaude apstiprina darījuma likumību, pārbaudot, vai sūtītājs to ir pareizi parakstījis un vai sūtītājam ir pietiekami daudz līdzekļu. Šis process parasti ietver kriptogrāfiskā paraksta apstiprināšanu un pārliecību, ka sūtītāja atlikums ir vienāds ar darījuma summu vai lielāks par to.
klase Blockchain {    konstruktors() {        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 ('Bloks veiksmīgi iegūts!');        this.chain.push(bloks);        this.pendingTransactions = [            new Transaction(null, miningRewardAddress, this.miningReward)        ];    }    addTransaction(transaction) {        if (!transaction.fromAddress || !transaction.toAddress) {            throw new Error('Darījumā jāiekļauj adrese no un uz adresi');        }        if (!transaction.isValid()) {            throw new Error('Nevar pievienot ķēdei nederīgu darījumu');        }        this.pendingTransactions.push(transaction);    }    getBalanceOfAddress(adrese) {        let balance = 0;        for (const block of this.chain) {            for (const trans of block.data) {                if (trans.fromAddress === adrese) {                    bilance -= trans.amount;                }                 ja (trans.toAddress === adrese) {                    bilance += trans.amount;                }            }                    atgriešanas atlikums;    }    isChainValid() {        for (lai i = 1; i < this.chain.length; i++) {            const currentBlock = this.ķēde[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;            }        }        atgriezt patiesu;    }}
Pārskats par konsensa algoritmiem, kas ir saderīgi ar JavaScript:
Darba apliecinājums (PoW):
Tehniskais skaidrojums: Darba apliecinājums ir pazīstams arī kā kalnrūpniecība. Šajā vienprātības mehānismā lietotājiem ir jāatrisina kriptogrāfijas mīklas, kas viņus atalgo. Tas ir konkurss, kurā pirmais, kurš atrisina, tiek nodots jaunajam blokam. Šis algoritms izmanto jaukšanu, lai nodrošinātu blokķēdi. 
Izstrādātāja ieviešana: rīkus PoW ieviešanai nodrošina Bitcoin izstrādātāju vide, piemēram, Bitcoin Core.
Likmes apliecinājums (PoS):
Tehniskais skaidrojums: Proof of Stake atlasa pārbaudītājus, pamatojoties uz viņiem piederošo monētu skaitu un ķīlu. Atlases process nav atkarīgs tikai no likmes, bet arī no tādiem faktoriem kā monētas vecums un nejaušība. Lai pievienotu jaunu bloku, tiek izvēlēti pārbaudītāji, kuriem ir viszemākā jaucējvērtība un lielākā likmes summa
Izstrādātāja ieviešana: PoS rīkus un bibliotēkas nodrošina Ethereum 2.0 SDK
Deleģētais likmes apliecinājums (DPoS):
Tehniskais skaidrojums: izmanto balsošanu un delegātus, lai apstiprinātu darījumu un izveidotu jaunus blokus.
Izstrādātāja ieviešana: EOSIO SDK nodrošina DPoS rīkus un bibliotēkas.
3. nodaļa: Vienkāršas blokķēdes izveide, izmantojot JavaScript
 Tajā jūs uzzināsit par blokķēdes struktūru, klašu un bloku un bloku parametru definēšanu un to, kā tie ir saistīti.
Bloku klases izveide
Blockchain, kā to attēlo nosaukums, sastāv no blokiem un katra bloka klases pamata atribūtiem, piemēram:
Indekss: skaitlisks identifikators bloka pozīcijai blokķēdē.
Laikspiedols: laiks, kurā tika izveidots bloks.
Dati: blokā saglabātie dati vai transakcijas. Tas varētu ietvert informāciju, piemēram, informāciju par darījumu, lietotāja datus utt.
PreviousHash: ķēdes iepriekšējā bloka hash, kas nodrošina nepārtrauktību un drošību.
Jaukts: unikāls bloka identifikators, kas ģenerēts, jaukjot bloka saturu.
Nonce: skaitlis, kas tiek izmantots darba pierādījuma algoritmam, kas tiek koriģēts, līdz tiek atrasts derīgs hash.
Ieviesiet metodes, lai aprēķinātu bloka jaucējkodu, izmantojot JavaScript sintaksi:
createGenesisBlock(): izveido pirmo bloku blokķēdē, kas pazīstams kā ģenēzes bloks.
getLatestBlock(): izgūst jaunāko bloku blokķēdē.
addBlock(): pievieno jaunu bloku blokķēdei pēc tā ieguves.
isChainValid(): apstiprina blokķēdes integritāti, nodrošinot katra bloka jaucējkoda atbilstību un iepriekšējo jaucēju konsekvenci.
Blockchain klases izveide
Definējiet Blockchain klasi, lai pārvaldītu ķēdi un ieviestu metodes jaunu bloku pievienošanai:
klase Blockchain {    konstruktors() {        this.chain = [this.createGenesisBlock()];        šī.grūtības = 4;  // Ieguves sarežģītības pakāpe    }    // Genesis bloka izveides metode    createGenesisBlock() {        return new Block(0, “01/01/2024”, “Genesis Block”, “0”);    }    // Metode jaunākā bloka izgūšanai ķēdē    getLatestBlock() {        return this.chain[this.chain.length – 1];    }    // Metode, kā ķēdei pievienot jaunu bloku pēc tā ieguves    addBlock(newBlock) {        newBlock.previousHash = this.getLatestBlock().hash;        newBlock.mineBlock(this.difficulty);        this.chain.push(newBlock);    }    // Metode blokķēdes integritātes pārbaudei    isChainValid() {        for (lai i = 1; i < this.chain.length; i++) {            const currentBlock = this.chain[i];            const previousBlock = this.chain[i – 1];            // Pārbaudiet, vai pašreizējā bloka hash ir pareizs            if (currentBlock.hash !== currentBlock.calculateHash()) {                return false;            }            // Pārbaudiet, vai pašreizējā bloka iepriekšējais jaucējvārds atbilst iepriekšējā bloka jaukšanai            if (currentBlock.previousHash !== previousBlock.hash) {                return false;            }        }        atgriezt patiesu;    }}
4. nodaļa: Konsensa mehānismu ieviešana JavaScript
Darba apliecinājums
Darba pierādījums, ko bieži dēvē par ieguvi, ir decentralizēta sistēma, kurā tīkla dalībnieki jeb kalnrači sacenšas, lai atrisinātu kriptogrāfijas mīklas. Pirmais kalnracis, kurš atrisina mīklu, pievieno blokķēdei nākamo bloku un saņem atlīdzību. Šis process izmanto jaukšanu, lai nodrošinātu blokķēdi. PoW mīklu sarežģītība nodrošina blokķēdes drošību un kontrolē ātrumu, ar kādu tiek pievienoti jauni bloki.
Block klasē mēs varam ieviest Proof of Work, pievienojot mineBlock metodi. Šī metode pielāgo nonce, līdz bloka hash atbilst noteiktam sarežģītības mērķim (piem., jaukumam jāsākas ar noteiktu nulles skaitu).
Koda fragments:
class Block {    konstruktors(indekss, laikspiedols, dati, iepriekšējā hash = ”) {        this.index = indekss;        this.timestamp = laikspiedols;        this.data = dati;        this.previousHash = previousHash;        this.hash = this.calculateHash();        this.nonce = 0;    }    // Aprēķiniet bloka jaucējvārdu, izmantojot SHA-256    calculateHash() {        return crypto.createHash('sha256')            .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)            .digest('hex');    }    // Darba apliecinājuma ieviešana    mineBlock(grūtības) {        while (this.hash.substring(0, grūtības) !== Array(grūtības + 1).join("0") {            this.nonce++;            this.hash = this.calculateHash();        }        console.log(`Block mined: ${this.hash}`);    }}
Atjauniniet Blockchain klasi, lai pirms jaunu bloku pievienošanas apstiprinātu pierādījumu.
klase Blockchain {    konstruktors() {        this.chain = [this.createGenesisBlock()];        šī.grūtības = 4;    }    // Izveidojiet ģenēzes bloku    createGenesisBlock() {        return new Block(0, "01/01/2024", "Genesis Block", "0");    }    // Iegūstiet jaunāko bloku ķēdē    getLatestBlock() {        return this.chain[this.chain.length – 1];    }    // Pievienojiet ķēdei jaunu bloku    addBlock(newBlock) {        newBlock.previousHash = this.getLatestBlock().hash;        newBlock.mineBlock(this.difficulty);  // Darba apliecinājuma ieviešana        this.chain.push(newBlock);    }    // Pārbaudiet, vai blokķēde ir derīga    isChainValid() {        for (lai 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;            }        }        atgriezt patiesu;    }}
5. nodaļa: Vienkāršas Blockchain API izveide ar JavaScript
Nepietiek tikai ar blokķēdes izveidi, lai to padarītu izmantojamu reālajā dzīvē. Šim nolūkam mums ir jāizveido mijiedarbības saskarne, kas būs vienkārša API.
API vides iestatīšana
Pirms sākat veidot API, ir jāiestata vide ar visiem nepieciešamajiem rīkiem un ietvariem.
Instalējiet mezglu un npm 
Inicializējiet projektu ar komandu: npm init -y
Instalēt Express: npm install express –save (Express ir mezgla js ietvars, kas palīdz ātrāk izveidot API)
Instalējiet Body parseri, lai apstrādātu ienākošo pieprasījumu: npm instalējiet ķermeņa parsētāju – saglabājiet
API izveide
Tagad, kad jūsu vide ir iestatīta, izveidosim API. API ļaus lietotājiem mijiedarboties ar blokķēdi, skatīt ķēdi un pievienot jaunus blokus.
Izveidojiet serveri ar Express:
const express = prasīt('izteikt');const bodyParser = prasīt('body-parser');const Blockchain = prasīt(‘./blockchain');  // Importēt Blockchain classconst app = express();app.use(bodyParser.json());let demoBlockchain = new Blockchain();  // Inicializējiet jaunu Blockchain gadījumu
Definējiet API galapunktus
app.get('/blocks', (req, res) => {     //galapunkts, lai iegūtu blokķēdi    res.json(demoBlockchain.chain);});//šis ir galapunkts, lai izveidotu 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(`Bloks veiksmīgi iegūts: ${newBlock.hash}`);});
Sāciet serveri
app.listen(3000, () => {    console.log('Blockchain API, kas darbojas portā 3000');});node server.js
6. nodaļa: Lietojumprogrammas palaišana un testēšana
Šis posms ir ļoti svarīgs, lai nodrošinātu, ka blokķēde darbojas pareizi un visas funkcijas darbojas, kā paredzēts.
Lietojumprogrammas palaišana
Startējiet serveri: dodieties uz sava projekta direktoriju un pēc tam palaidiet mērķi: node server.js
Saņemiet servera apstiprinājumu: Blockchain API, kas darbojas 3000. portā
Piekļuve lietojumprogrammai: jūsu lietojumprogramma tagad darbojas lokāli vietnē http://localhost:3000, padarot to gatavu pieņemt HTTP pieprasījumus
Testēšana ar Pastnieku
Postman ir plaši izmantots API testēšanas rīks, kas ļauj nosūtīt HTTP pieprasījumus un skatīt atbildes. Tas ir īpaši noderīgi, lai pārbaudītu jūsu blokķēdes API funkcionalitāti.
Instalējiet Postman
Blockchain beigu punkta pārbaude
Pārbaudiet Mining galapunktu
Pārbaudiet blokķēdi
(Step1)node server.jsBlockchain API, kas darbojas portā 3000//http://localhost:3000/block(Step2)[    {        "indekss": 0,        "laikspiedols": 1636568887994,        "data": "Genesis Block", previousHash”: “0”,        “jaukts”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    }](3. darbība){    “             ”:”      uztvērējs”: “Džeina Smita”    }} (4. darbība){    “ziņojums”: “Bloks veiksmīgi iegūts”,    “bloks”: {        “indekss”: 1,        “laikspiedols”: 1636578990123,        “dati”: {            “summa”: 100,            “sūtītājs”: “Džons Dū” ,            "uztvērējs": "Džeina Smita"        },        "iepriekšējais hashs": "81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803bc"        1577fb2d803bc:d 2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    }} (5. darbība)[    {        “indekss”: 0,        “laikspiedols”: 1636568887994,        “dati”: “ Genesis Block”,        “previousHash”: “0”,        “jaukts”:“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”
 
   },    {
 
       "indekss": 1,        "laikspiedols": 1636578990123,        "dati": {            "summa": 100,            "sūtītājs": "Džons Doe",            "saņēmējs": "Džeina Smita"        },        "iepriekšējaisHash" f2fef8f2bca7853d44682e12022fb2d803b9”, “hash”: “5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”        }]
curl http://localhost:3000/blocks //Skatīt blokķēdi[    {        "index": 0,        "laikspiedols": 1636568887994,        "data": "Genesis Block",        "previousHash": "0",        "jaucējs": “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    }]//Jauna bloka loka ieguve -X POST -H “Content-Type: Application”:” n stirna”, “ uztvērējs”: “Džeina Smita”}}' http://localhost:3000/mine//verify the blockcurl http://localhost:3000/blocks[    {        “indekss”: 0,        “laikspiedols”: 1636568887994,        “dati” : "Genesis Block",        "iepriekšējais hash": "0",        "jaukts": "81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9"     6"     6 990123,        “dati”: {            “summa”: 100,            “sūtītājs” : "Džons Dū",            "uztvērējs": "Džeina Smita"        },        "iepriekšējais hashs": "81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2cd.d80d c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    }]
7. nodaļa: Blockchain lietojumprogrammas izveides, izmantojot JavaScript, piemērs
Soli pa solim izpilde
1. darbība. Izveidojiet Block klasi ar nepieciešamajiem atribūtiem, izmantojot JavaScript sintaksi.
class Block {    konstruktors(indekss, laikspiedols, dati, iepriekšējā hash = ”) {        this.index = indekss;        this.timestamp = laikspiedols;        this.data = dati;        this.previousHash = previousHash;        this.hash = this.calculateHash();        this.nonce = 0;    }}
2. darbība. Ieviesiet aprēķinu hash metodi.
CalculateHash() {    return crypto.createHash(‘sha256’)        .update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)        .digest('hex');}
3. darbība: definējiet Blockchain klasi un inicializējiet to ar ģenēzes bloku.
klase Blockchain {    konstruktors() {        this.chain = [this.createGenesisBlock()];    }}
4. darbība. Ieviesiet metodes jaunu bloku pievienošanai un jaunākā bloka izgūšanai, izmantojot JavaScript.
getLatestBlock() {    return this.chain[this.chain.length – 1];}addBlock(newBlock) {    newBlock.previousHash = this.getLatestBlock().hash;    newBlock.hash = newBlock.calculateHash();    this.chain.push(newBlock);}
5. darbība: pievienojiet darba apliecinājuma funkcionalitāti klasei Block un atjauniniet Blockchain klasi.
mineBlock(grūtības) {    while (this.hash.substring(0, grūtības) !== Masīvs(grūtības + 1).join("0") {        this.nonce++;        this.hash = this.calculateHash();    }}
6. darbība: iestatiet API vidi, lai apstrādātu pieprasījumus, izmantojot Express.
npm init -ynpm install express –save                        //Projekta iestatīšana un direktorijaconst express = request('express');      //Ātrā servera iestatīšanaconst bodyParser = request(‘body-parser’);const Blockchain = request(‘./blockchain’); // Pieņemot, ka jums ir Blockchain klase no iepriekšējām 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) => {            //jauna bloka izveide             const newBlock = new Block(demoBlockchain.chain.length,        Date.now(),        req.body.data,        demoBlockin. ().hash);     newBlock.mineBlock(2); // Pieņemot, ka PoW demoBlockchain.addBlock(newBlock);     res.send(`Block veiksmīgi iegūts: ${newBlock.hash});}); app.listen(3000, () => {                                 //servera palaišana        console.log('Blockchain API, kas darbojas portā 3000');});node server.js
7. darbība: pārbaudiet lietojumprogrammu, iegūstot jaunu bloku un pārbaudot blokķēdi, izmantojot Postman vai curl.
Pastnieks nosūtiet pieprasījumu: GET pieprasījums uz http://localhost:3000/blocks.{    “dati”: {        “summa”: 10,        “sūtītājs”: “Alise”,        “saņēmējs”: “Bobs”    }}Curl :curl http://localhost:3000/blocks
Īsumā apkoposim iepriekš minētās darbības
Soli pa solim veiksim procesu, lai atdzīvinātu jūsu blokķēdes lietojumprogrammu:
Sāciet ar Block un Blockchain klases definēšanu, lai izveidotu blokķēdes pamatstruktūru.
Iekļaujiet darba pierādījumu, pievienojot mineBlock metodi Block klasei, nodrošinot, ka katrs bloks atbilst nepieciešamajām grūtībām pirms pievienošanas ķēdei.
Iestatiet API, izmantojot Express, kas ļauj mijiedarboties ar blokķēdi, ļaujot veikt tādas darbības kā ķēdes skatīšana un jaunu bloku pievienošana.
Izpildiet un pārbaudiet savu lietojumprogrammu, izmantojot Postman vai curl, lai pārbaudītu, vai viss darbojas, kā paredzēts, sākot no bloku ieguves līdz blokķēdes datu izgūšanai.
Laimīgu kodēšanu!!

Apskati vairāk satura no autora

Jaunākās ziņas