การสร้างแอปพลิเคชัน Blockchain ด้วย JavaScript

by

การสร้างแอปพลิเคชัน Blockchain ด้วย JavaScript

บทนำ

เอาล่ะ เพื่อนเขียนโค้ดที่รักของฉัน! ให้ฉันแนะนำคุณผ่านการผจญภัยบล็อคเชนนี้โดยใช้ประสบการณ์หลายปีในการเขียนโปรแกรมและอารมณ์ขัน

ความก้าวหน้าที่ก้าวล้ำยุคใหม่ เช่น สกุลเงินดิจิทัล เช่น Bitcoin และแอปพลิเคชันการกระจายอำนาจ (DApps) ต่างๆ ในหลายอุตสาหกรรม ได้รับอิทธิพลอย่างมากจากเทคโนโลยีบล็อกเชน โดยพื้นฐานแล้ว บล็อกเชนเป็นตัวแทนของฐานข้อมูลรวมที่บันทึกธุรกรรมในอุปกรณ์จำนวนมาก เพื่อให้แน่ใจว่าข้อมูลจะไม่สามารถแก้ไขได้เมื่อถูกบันทึกแล้ว ธุรกรรมแต่ละรายการหรือ “บล็อก” จะเชื่อมโยงกับธุรกรรมที่อยู่ก่อนหน้า ทำให้เกิดลำดับที่ไม่ขาดตอน ดังนั้นคำว่า “บล็อกเชน” โครงสร้างนี้รับประกันความโปร่งใส ความปลอดภัย และไม่เปลี่ยนแปลงของข้อมูล ซึ่งเป็นคุณสมบัติที่สำคัญสำหรับแอปพลิเคชันจำนวนมาก

จาวาสคริปต์ในบล็อคเชน

JavaScript โดดเด่นในฐานะภาษาการเขียนโปรแกรมที่หลากหลายและมีชื่อเสียง ซึ่งมีประโยชน์อย่างยิ่งต่อการสร้างโซลูชันบล็อกเชน ระบบนิเวศที่กว้างขวางและการสนับสนุนชุมชนที่แข็งแกร่งทำให้การพัฒนาแอปพลิเคชันบล็อกเชนง่ายขึ้นโดยนำเสนอข้อดีหลายประการ:

  • การนำไปใช้อย่างกว้างขวาง: เนื่องจาก Javascript เป็นภาษาหลักที่ใช้สำหรับการพัฒนาเว็บ จึงชัดเจนมากที่จะมีแอปพลิเคชันในภูมิทัศน์บล็อกเชนพร้อมกับเว็บแอปพลิเคชัน
  • การประมวลผลแบบอะซิงโครนัส: ความสามารถแบบอะซิงโครนัสของ JavaScript ซึ่งอำนวยความสะดวกโดย Node.js เหมาะอย่างยิ่งสำหรับการจัดการธุรกรรมและการโต้ตอบหลายรายการในสภาพแวดล้อมบล็อกเชน
  • ระบบนิเวศที่สมบูรณ์: เครื่องมือและไลบรารีในระบบนิเวศของ JavaScript เช่น Node.js สำหรับการพัฒนาฝั่งเซิร์ฟเวอร์และ Express.js สำหรับ API ปรับปรุงการพัฒนาแอปพลิเคชันบล็อคเชน

ผู้ชม

ในฐานะนักพัฒนา JavaScript ผู้ช่ำชองและมีประสบการณ์หลายปี ผมขอแนะนำบทความนี้ให้กับทุกคนที่ต้องการขยายทักษะและดำดิ่งสู่โลกแห่งเทคโนโลยีบล็อกเชนอันน่าทึ่ง คู่มือนี้จะแนะนำคุณตลอดขั้นตอนการตั้งค่าสภาพแวดล้อมการพัฒนา แบ่งแนวคิดที่ซับซ้อนออกเป็นพื้นฐานที่เข้าใจได้ ช่วยคุณสร้างแอปพลิเคชันบล็อกเชนพื้นฐาน และเปิดเผยผ่าน API ที่ใช้งานง่ายในท้ายที่สุด ไม่ว่าคุณจะกระตือรือร้นที่จะเรียนรู้หรือต้องการเพิ่มบรรทัดใหม่ให้กับนักพัฒนาของคุณ บทความนี้เป็นแหล่งข้อมูลอันล้ำค่าสำหรับการเดินทางของคุณ

บทที่ 1: การตั้งค่าสภาพแวดล้อมการพัฒนา

การติดตั้ง Node.js

  • ดาวน์โหลด node js บนระบบของคุณจากเว็บไซต์อย่างเป็นทางการ และต้องการเวอร์ชัน LTS (การสนับสนุนระยะยาว) เนื่องจากแนะนำว่าดีที่สุดสำหรับระบบปฏิบัติการทั้งหมดและรักษาความเสถียร
  •  ปฏิบัติตามคำแนะนำในการติดตั้งเฉพาะสำหรับระบบปฏิบัติการของคุณ การติดตั้งประกอบด้วย npm (Node Package Manager) ซึ่งจำเป็นสำหรับการจัดการการขึ้นต่อกันของโปรเจ็กต์
  • ตรวจสอบว่าการติดตั้งทำอย่างถูกต้องหรือไม่โดยการรันคำสั่งต่อไปนี้ใน bash:
    1. โหนด -v
    2. npm -v

เมื่อคุณดำเนินการตามคำสั่งที่กำหนดแล้ว คุณควรค้นหาเวอร์ชันที่เกี่ยวข้องของแพ็คเกจที่ติดตั้งในระบบของคุณ โดยถือว่ากระบวนการติดตั้งสำเร็จ

การเลือก IDE

การเลือก JavaScript เป็นภาษาการเขียนโปรแกรมของคุณ Visual Studio Code (VSCode) เป็นเพื่อนที่ยอดเยี่ยมในการจัดการกับข้อกำหนดการพัฒนาทั้งหมดของคุณ ความสามารถอันทรงพลังและสภาพแวดล้อมที่ปรับเปลี่ยนได้ทำให้เหมาะอย่างยิ่งสำหรับการพัฒนา JavaScript

  • รหัส Visual Studio:
    1. ดาวน์โหลด VsCode จากเว็บไซต์อย่างเป็นทางการ
    2. ติดตั้งส่วนขยายดังนี้:
      1. ESLint: สำหรับการระบุและแก้ไขปัญหาในโค้ด JavaScript
      2. สวยกว่า: สำหรับการจัดรูปแบบโค้ดที่สอดคล้องกัน
      3. ดีบักเกอร์สำหรับ Chrome: สำหรับการดีบักโค้ด JavaScript ที่ทำงานใน Google Chrome
      4. Node.js: สำหรับความสามารถในการแก้ไขจุดบกพร่องของ Node.js

การติดตั้งไลบรารีที่จำเป็น

การจัดการไลบรารี JavaScript ทำได้ผ่าน npm (Node Package Manager) ในการเริ่มต้นโครงการของคุณและติดตั้งแพ็คเกจที่จำเป็น ให้ใช้คำสั่งต่อไปนี้:

npm init -y
npm ติดตั้ง express body-parser crypto

//express เป็น  เฟรมเวิร์กโหนด
//body-parser เป็นมิดเดิลแวร์สำหรับแยกวิเคราะห์คำขอที่เข้ามา
//ฟังก์ชัน crypto ที่ใช้สำหรับการแฮช

บทที่ 2: ทำความเข้าใจแนวคิดบล็อกเชนด้วย JavaScript

พื้นฐานบล็อคเชนใน JavaScript

บล็อกเชนประกอบด้วยบล็อกซึ่งประกอบด้วย:

  • ดัชนี: ตำแหน่งของบล็อกในห่วงโซ่
  • การประทับเวลา: วันที่และเวลาที่สร้างบล็อก
  • ข้อมูล: ข้อมูลธุรกรรมหรือข้อมูลอื่น ๆ ที่เก็บไว้ในบล็อก
  • Previous Hash: แฮชของบล็อกก่อนหน้าในห่วงโซ่ เชื่อมโยงบล็อกเข้าด้วยกัน
  • แฮช: ตัวระบุที่ไม่ซ้ำสำหรับบล็อก สร้างขึ้นโดยการแฮชเนื้อหา
const crypto = need(‘crypto’);

class Block {    
ตัวสร้าง (ดัชนี, การประทับเวลา, ข้อมูล, PreviousHash = ”) {        
this.index = ดัชนี;        
this.timestamp = การประทับเวลา;        
this.data = ข้อมูล;        
this.previousHash = ก่อนหน้าHash;        
this.hash = this.calculateHash;    
}
    calculateHash {        
ส่งคืน crypto.createHash(‘sha256’)            < br/>.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data))           
 .digest(‘hex’);    
}
}

ความสำคัญของกลไกการกระจายอำนาจ การเปลี่ยนแปลงไม่ได้ และความเห็นพ้องต้องกัน:

การกระจายอำนาจ: 

ในระบบบล็อกเชน แทนที่จะอาศัยหน่วยงานกลางในการจัดเก็บข้อมูลและการตรวจสอบความถูกต้องของธุรกรรม ความรับผิดชอบจะถูกกระจายไปยังโหนดที่เข้าร่วมทั้งหมด ซึ่งหมายความว่าแต่ละโหนดจะเก็บบันทึก (หรือสำเนา) ของบัญชีแยกประเภทของตนเอง ซึ่งช่วยขจัดปัญหาที่อาจเกิดขึ้นจากจุดควบคุมเพียงจุดเดียว

ความโปร่งใส:

ในฐานะนักวิจัยที่สำรวจ Ethereum ฉันสามารถพูดได้อย่างมั่นใจว่าทุกโหนดและผู้เข้าร่วมภายในเครือข่ายสามารถเข้าถึงบัญชีแยกประเภทได้ ซึ่งรับประกันความโปร่งใสอย่างไม่เปลี่ยนแปลงทั่วทั้งระบบ ธุรกรรมใน Ethereum จะแสดงต่อสาธารณะเพื่อให้ทุกคนเห็นบน blockchain explorer โดยมอบสภาพแวดล้อมที่เปิดกว้างและโปร่งใสสำหรับทุกคนที่เกี่ยวข้อง

ความไม่เปลี่ยนรูป:

สิ่งสำคัญคือต้องคิดให้ถี่ถ้วนก่อนที่จะทำธุรกรรมให้เสร็จสิ้น เนื่องจากโดยทั่วไปแล้วการเปลี่ยนแปลงหรือการกลับรายการจะเป็นไปไม่ได้หลังจากข้อเท็จจริงแล้ว คุณลักษณะนี้มีประโยชน์ในการหลีกเลี่ยงการฉ้อโกงและธุรกรรมที่ซ้ำกัน

กลไกฉันทามติ:

ในเครือข่าย กลไกฉันทามติทำหน้าที่เป็นแนวทางสำหรับโหนดในการตัดสินใจร่วมกันเกี่ยวกับสถานะปัจจุบันของบัญชีแยกประเภทแบบกระจาย กลไกเหล่านี้เป็นเครื่องมือในการตรวจสอบและรับรองความถูกต้องของธุรกรรม พวกเขารับประกันว่าโหนดที่เข้าร่วมทั้งหมดใน Distributed Ledger Technology (DLT) เห็นด้วยกับสถานะของบัญชีแยกประเภท

ส่วนประกอบของแอปพลิเคชันบล็อคเชน

โครงสร้างบล็อกใน JavaScript:

const crypto = need(‘crypto’);

class Block {    
ตัวสร้าง (ดัชนี, การประทับเวลา, ข้อมูล, PreviousHash = ”) {        
this.index = ดัชนี;        
this.timestamp = การประทับเวลา;        
this.data = ข้อมูล;        
this.previousHash = ก่อนหน้าHash;        
this.hash = this.calculateHash;        
this.nonce = 0; // สำหรับหลักฐานการทำงาน    
}

calculateHash {        
ส่งคืน crypto.createHash(‘sha256’)            
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce )            
.digest(‘hex’);    

mineBlock(ความยาก) {        
ในขณะที่ (this.hash.substring(0, ความยาก ) !== Array(ความยาก + 1).join(“0”)) {            
this.nonce++;            
this.hash = this.calculateHash;        
}        
console.log(“บล็อกขุด: ” + this.hash);    
}
}

การสร้างและการตรวจสอบธุรกรรมโดยใช้ JavaScript:

ในบล็อกเชน แต่ละธุรกรรมทำหน้าที่เป็นหน่วยพื้นฐานของข้อมูล ซึ่งแสดงถึงการเปลี่ยนแปลงมูลค่า การดำเนินการตามข้อตกลง หรือการเปลี่ยนแปลงใดๆ ในสถานะโดยรวมของบล็อกเชน ระบบรวบรวมธุรกรรมเหล่านี้ไว้ด้วยกันภายในบล็อคแล้วผนวกเข้ากับบล็อคเชน

รายละเอียดของธุรกรรม:

  • ผู้ส่ง: กุญแจสาธารณะหรือการระบุเฉพาะของผู้ที่ส่งไป
  • ผู้รับ: กุญแจสาธารณะหรือข้อมูลประจำตัวเฉพาะของผู้โชคดีที่ได้รับธุรกรรม
  • จำนวนเงิน: สิ่งที่ถูกส่งผ่านไป ไม่ว่าจะเป็นเงินหรือข้อมูลบางอย่าง
  • การประทับเวลา: เมื่อพวกเขาตัดสินใจที่จะกดส่งสิ่งนี้
  • หลักฐานความถูกต้อง/ลายเซ็น: รหัสลับสุดยอดบางอย่างที่แสดงให้เห็นถึงความถูกต้องของข้อตกลงและไม่ได้ถูกแก้ไข ผู้ที่ส่งมันจะใช้รหัสลับเพื่อปิดผนึกข้อตกลง และทุกคนสามารถตรวจสอบได้ว่าเป็นของจริงด้วยรหัสสาธารณะ

ข้อมูลโค้ดสำหรับธุรกรรม:

ธุรกรรมระดับ {    
ตัวสร้าง (fromAddress, toAddress, จำนวน) {        
this.fromAddress = fromAddress;        
this.toAddress = toAddress;        
this.amount = จำนวน;        
this.timestamp = ใหม่ Date.toISOString;    
}
    calculateHash {        
ส่งคืน crypto.createHash(‘sha256’)            < br/>.update(this.fromAddress + this.toAddress + this.amount + this.timestamp)            
.digest(‘hex’);    
}

signTransaction(signingKey) {        
if (signingKey.getPublic(‘hex’) !== this.fromAddress) {            
โยนข้อผิดพลาดใหม่ (‘คุณไม่สามารถลงนามธุรกรรมสำหรับกระเป๋าเงินอื่นได้!’);        
}

 const hashTx = this.calculateHash;        
const sig = signingKey.sign(hashTx, ‘base64’);        
this.signature = sig.toDER(‘hex’);    
    isValid {        
ถ้า (this.fromAddress === null) ให้คืนค่าเป็นจริง

if (!this.signature || this.signature.length === 0) {            
โยนข้อผิดพลาดใหม่ (‘ไม่ใช่ ลงนามในธุรกรรมนี้’);       
 }

const publicKey = ec.keyFromPublic(this.fromAddress, ‘hex’);        
ส่งคืน publicKey.verify (this.calculateHash, this.signature);    
}
}

การตรวจสอบธุรกรรมทำให้มั่นใจได้ถึงความถูกต้องโดยการยืนยันว่าผู้ลงนามถูกต้องตามกฎหมายและมีเงินทุนเพียงพอ โดยทั่วไปกระบวนการนี้เกี่ยวข้องกับการตรวจสอบความสมบูรณ์ของลายเซ็นดิจิทัล และตรวจสอบว่ายอดคงเหลือในบัญชีของผู้ส่งเท่ากับหรือเกินกว่ามูลค่าธุรกรรม

คลาส Blockchain {    
ตัวสร้าง {        
this.chain = [this.createGenesisBlock];        
this.pendingTransactions = [];        
this.miningReward = 100;    
}

createGenesisBlock {        
ส่งคืนบล็อกใหม่ (Date.parse(‘2024-01-01’), [], ‘0’);    
}
    getLatestBlock {        
ส่งคืน this.chain[this.chain.length – 1];    
}

minePendingTransactions(miningRewardAddress) {        
ให้ block = บล็อกใหม่ (Date.now, this.pendingTransactions, this.getLatestBlock.hash);        
block.mineBlock(this.difficulty);

console.log(‘บล็อกการขุดสำเร็จแล้ว !’);        
this.chain.push(block);
        this.pendingTransactions = [            
ธุรกรรมใหม่( null, miningRewardAddress, this.miningReward)        
];   
 }
    addTransaction(ธุรกรรม) {        
if (!transaction.fromAddress || !transaction. toAddress) {            
เกิดข้อผิดพลาดใหม่ (‘ธุรกรรมต้องมีที่อยู่จากและไปยังที่อยู่’);        

if (!transaction.isValid) {            
โยนข้อผิดพลาดใหม่ (‘ไม่สามารถเพิ่มที่ไม่ถูกต้อง การทำธุรกรรมกับลูกโซ่ ‘);        
}
        this.pendingTransactions.push(ธุรกรรม);    
}

getBalanceOfAddress(ที่อยู่) {        
ให้สมดุล = 0;

สำหรับ (const บล็อกของ this.chain) {            
สำหรับ ( const trans ของ block.data) {               
 if (trans.fromAddress === ที่อยู่) {                   
 balance -= trans.amount;               
 }

if (trans.toAddress === ที่อยู่) {                    < br/> ยอดคงเหลือ += จำนวนธุรกรรม;                
}           

 }
        คืนยอดคงเหลือ;    
}
    isChainValid {        
สำหรับ (ให้ i = 1; i < this.chain.length ; i++) {            
const currentBlock = this.chain[i];            
const PreviousBlock = this.chain[i – 1];
            ถ้า (!currentBlock.hasValidTransactions) {                
ส่งคืนเท็จ;            
}
            ถ้า (currentBlock.hash !== currentBlock.calculateHash) {                
ส่งคืนเท็จ;            
}
            ถ้า (currentBlock.previousHash !== PreviousBlock.hash) {                
ส่งคืนเท็จ;            
}        
}
        คืนค่าจริง;    
}
}

ภาพรวมของอัลกอริทึมที่เป็นเอกฉันท์ที่เข้ากันได้กับ JavaScript:

หลักฐานการทำงาน (PoW):

พูดง่ายๆ ก็คือ Proof of Work (มักเรียกว่าการขุด) เป็นวิธีการที่ใช้ในการตรวจสอบธุรกรรมและสร้างบล็อกใหม่ในบล็อกเชน ผู้ใช้แข่งขันกันเพื่อแก้ปัญหาทางคณิตศาสตร์ที่ซับซ้อนหรือ ‘ปริศนาการเข้ารหัส’ คนแรกที่ไขปริศนาได้จะต้องเพิ่มบล็อกถัดไปลงในห่วงโซ่ กระบวนการนี้ปลอดภัยโดยใช้อัลกอริธึมแฮช ซึ่งรับประกันความสมบูรณ์และความปลอดภัยของบล็อกเชน

พูดง่ายๆ ก็คือ เมื่อพูดถึงการนำ Proof-of-Work (PoW) ไปปฏิบัติจริง เครื่องมือสำหรับจุดประสงค์นี้จะถูกนำเสนอภายใน Bitcoin Development Suite ซึ่งรวมถึง Bitcoin Core

หลักฐานการเดิมพัน (PoS):

พูดง่ายๆ ก็คือ Proof of Stake เลือกเครื่องมือตรวจสอบความถูกต้องไม่เพียงแต่ขึ้นอยู่กับจำนวนเหรียญที่พวกเขาถือเป็นหลักประกันเท่านั้น แต่ยังพิจารณาปัจจัยต่างๆ เช่น อายุของเหรียญ และการสุ่มสัมผัสอีกด้วย กระบวนการคัดเลือกเอื้อต่อผู้ตรวจสอบความถูกต้องที่ถือเหรียญมาเป็นเวลานานและผู้ที่มีสัดส่วนการถือหุ้นสูงกว่า ขณะเดียวกันก็รับประกันความเป็นธรรมด้วยค่าแฮชที่ต่ำและจำนวนเงินเดิมพันรวมที่สูง เครื่องมือตรวจสอบที่ต้องการเหล่านี้จะได้รับมอบหมายให้เพิ่มบล็อกใหม่ให้กับบล็อกเชน

การใช้งานของนักพัฒนา: เครื่องมือและไลบรารีสำหรับ PoS จัดทำโดย Ethereum 2.0 SDK

หลักฐานการเดิมพันที่ได้รับมอบหมาย (DPoS):

พูดง่ายๆ ก็คือ ระบบนี้ใช้แนวทางประชาธิปไตยในการยืนยันธุรกรรมและสร้างบล็อกใหม่ โดยอนุญาตให้มีการลงคะแนนเสียงระหว่างผู้เข้าร่วม (เรียกว่า ‘ผู้ได้รับมอบหมาย’) เพื่อตรวจสอบความถูกต้องของธุรกรรมและสร้างบล็อกใหม่ในบล็อกเชน

การใช้งานของนักพัฒนา: EOSIO SDK มอบเครื่องมือและไลบรารีสำหรับ DPoS

บทที่ 3: การสร้างบล็อกเชนอย่างง่ายด้วย JavaScript

ในบทช่วยสอนนี้ เราจะเจาะลึกเกี่ยวกับสถาปัตยกรรมของบล็อกเชน ครอบคลุมการสร้างคลาสที่จำเป็น เช่น บล็อก การกำหนดคุณลักษณะของบล็อก และทำความเข้าใจว่าบล็อกเหล่านี้และพารามิเตอร์เชื่อมโยงถึงกันอย่างไร

การสร้างคลาสบล็อก

บล็อกเชนตามชื่อที่แสดงถึงประกอบด้วยบล็อกและแอตทริบิวต์พื้นฐานของคลาสบล็อกแต่ละอัน เช่น:

  • ดัชนี: ตัวระบุที่เป็นตัวเลขสำหรับตำแหน่งของบล็อกภายในบล็อกเชน
  • การประทับเวลา: เวลาที่บล็อกถูกสร้างขึ้น
  • ข้อมูล: ข้อมูลหรือธุรกรรมที่เก็บไว้ในบล็อก ซึ่งอาจรวมถึงข้อมูล เช่น รายละเอียดธุรกรรม ข้อมูลผู้ใช้ ฯลฯ
  • PreviousHash: แฮชของบล็อกก่อนหน้าในห่วงโซ่ เพื่อให้มั่นใจถึงความต่อเนื่องและความปลอดภัย
  • แฮช: ตัวระบุเฉพาะสำหรับบล็อก สร้างขึ้นโดยการแฮชเนื้อหาของบล็อก
  • Nonce: ตัวเลขที่ใช้สำหรับอัลกอริธึม Proof of Work ซึ่งได้รับการปรับเปลี่ยนจนกว่าจะพบแฮชที่ถูกต้อง

ใช้วิธีการคำนวณแฮชของบล็อกโดยใช้ไวยากรณ์ JavaScript:

  • createGenesisBlock: สร้างบล็อกแรกใน blockchain หรือที่เรียกว่า genesis block
  • getLatestBlock: ดึงข้อมูลบล็อกล่าสุดใน blockchain
  • adBlock: เพิ่มบล็อกใหม่ให้กับ blockchain หลังจากการขุดมัน
  • isChainValid: ตรวจสอบความสมบูรณ์ของบล็อกเชนโดยตรวจสอบให้แน่ใจว่าแฮชของแต่ละบล็อกตรงกัน และแฮชก่อนหน้านั้นสอดคล้องกัน

การสร้างคลาส Blockchain

กำหนดคลาส Blockchain เพื่อจัดการห่วงโซ่และใช้วิธีการเพื่อเพิ่มบล็อกใหม่:

คลาส Blockchain {    
ตัวสร้าง {        
this.chain = [this.createGenesisBlock];        
ความยากนี้ = 4;  // ระดับความยากสำหรับการขุด    
}
    // วิธีการสร้าง genesis block    
createGenesisBlock {
ส่งคืนบล็อกใหม่ (0, “01/01/2024”, “Genesis Block”, “0”);    
}

 // วิธีการดึงข้อมูลบล็อกล่าสุดในห่วงโซ่    < br/>getLatestBlock {        
ส่งคืน this.chain[this.chain.length – 1];    
}

// วิธีการเพิ่มบล็อกใหม่ให้กับเชนหลังจากการขุด    
addBlock(newBlock) {        
newBlock.previousHash = this.getLatestBlock.hash;        
newBlock.mineBlock(ความยากนี้);        
this.chain.push(newBlock);    
}

 // วิธีการตรวจสอบความถูกต้องของบล็อกเชน    
isChainValid {        
for (let i = 1; i < this.chain.length; i++) {            
const currentBlock = นี้.chain[i];            
const PreviousBlock = this.chain[i – 1];

// ตรวจสอบว่า แฮชของบล็อกปัจจุบันถูกต้อง            
if (currentBlock.hash !== currentBlock.calculateHash) {                
return false;           
 }
            // ตรวจสอบว่าแฮชก่อนหน้าของบล็อกปัจจุบันตรงกับแฮชของบล็อกก่อนหน้าหรือไม่            
if (currentBlock.previousHash !== PreviousBlock.hash) {                
ส่งคืนเท็จ;            
}       
 }        
คืนค่าจริง;    
}
}

บทที่ 4: การใช้กลไกฉันทามติใน JavaScript

หลักฐานการทำงาน

พูดง่ายๆ ก็คือ Proof of Work (มักเรียกว่าการขุด) เป็นระบบที่ผู้เข้าร่วมเครือข่ายหรือนักขุดแข่งขันกันเพื่อแก้ปัญหาทางคณิตศาสตร์ที่ซับซ้อนซึ่งเหมือนกับปริศนาที่มีรหัสเข้ารหัส นักขุดที่ไขปริศนาได้ก่อนจะต้องเพิ่มบล็อกถัดไปในห่วงโซ่ข้อมูลที่เรียกว่าบล็อคเชน และจะได้รับรางวัล กระบวนการนี้เกี่ยวข้องกับการใช้แฮชเพื่อรักษาบล็อคเชนให้ปลอดภัย ความซับซ้อนของปริศนาเหล่านี้ช่วยรักษาความปลอดภัยของบล็อคเชนและควบคุมความเร็วของบล็อคใหม่ที่ถูกเพิ่มเข้าไปในเชน

ในคลาส Block เรามารวมแนวคิด Proof of Work เข้าด้วยกันโดยการสร้างฟังก์ชัน ‘mineBlock’ ฟังก์ชันนี้จะปรับ nonce อย่างต่อเนื่องจนกว่าแฮชที่เข้ารหัสของบล็อกจะเป็นไปตามมาตรฐานความซับซ้อนเฉพาะ (เช่น แฮชควรเริ่มต้นด้วยจำนวนศูนย์ที่ระบุ)

ข้อมูลโค้ด:

คลาสบล็อก {    
ตัวสร้าง (ดัชนี, การประทับเวลา, ข้อมูล, PreviousHash = ”) {        
this.index = ดัชนี;        
this.timestamp = การประทับเวลา;        
this.data = ข้อมูล;        
this.previousHash = ก่อนหน้าHash;        
this.hash = this.calculateHash;        
this.nonce = 0;   
 }

 // คำนวณแฮชของบล็อกโดยใช้ SHA-256    
calculateHash {        
return crypto.createHash(‘sha256’)            
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)            
.digest(‘hex’);    
}

    // การใช้หลักฐานการทำงาน    
mineBlock(ความยาก) {        
ในขณะที่ (this.hash.substring(0, ความยาก) !== Array(ความยาก +
1).join(“0”)) {            
this.nonce++;            
this.hash = this.calculateHash;       
 }        
console.log(`บล็อกที่ขุดได้: ${this.hash}`);    
}
}

อัปเดตคลาส Blockchain เพื่อตรวจสอบหลักฐานก่อนเพิ่มบล็อกใหม่

คลาส Blockchain {    
ตัวสร้าง {        
this.chain = [this.createGenesisBlock];        
ความยากนี้ = 4;    
}

 // สร้างบล็อกกำเนิด    createGenesisBlock {        
ส่งคืนบล็อกใหม่ (0, “01/01/2024”, “Genesis Block”, “0”);    
}

// รับบล็อกล่าสุดในเครือ    
getLatestBlock {        
ส่งคืน this.chain[this.chain.length – 1];    
}

// เพิ่มบล็อกใหม่ให้กับเชน    
addBlock(newBlock) {        
newBlock.previousHash = this.getLatestBlock.hash;        
newBlock.mineBlock(ความยากนี้);  // การนำหลักฐานการทำงานไปใช้        
this.chain.push(newBlock);    
}

// ตรวจสอบว่าบล็อคเชนถูกต้องหรือไม่    
isChainValid {        
สำหรับ (let i = 1; i < this.chain.length; i++) {            
const currentBlock = this โซ่[i];            
const PreviousBlock = this.chain[i – 1];
             ถ้า (currentBlock.hash !== currentBlock.calculateHash) {                 คืนค่าเท็จ;           
 }
            if (currentBlock.previousHash !== PreviousBlock.hash) {                
ส่งคืนเท็จ;           
 }        
}        
คืนค่าจริง;    
}
}

บทที่ 5: การสร้าง Blockchain API อย่างง่ายด้วย JavaScript

การพัฒนาบล็อกเชนเป็นเพียงก้าวแรกเท่านั้น จะต้องใช้งานได้จริงในชีวิตประจำวันด้วย เพื่อให้บรรลุเป้าหมายนี้ เราควรออกแบบอินเทอร์เฟซที่เป็นมิตรต่อผู้ใช้ เช่น API (Application Programming Interface) ที่ตรงไปตรงมา ซึ่งช่วยให้โต้ตอบได้ง่าย

การตั้งค่าสภาพแวดล้อม API

ในการสร้าง API ที่มีประสิทธิภาพ จำเป็นอย่างยิ่งที่จะต้องเตรียมพื้นที่ทำงานโดยการติดตั้งเครื่องมือและเฟรมเวิร์กที่จำเป็นทั้งหมดที่จำเป็นสำหรับการพัฒนา

  • ติดตั้งโหนดและ npm 
  • เริ่มต้นโครงการของคุณด้วยคำสั่ง: npm init -y
  • ติดตั้ง Express: npm ติดตั้ง express -save (Express เป็นเฟรมเวิร์กโหนด js ที่ช่วยในการสร้าง API เร็วขึ้น)
  • ติดตั้ง Body parser เพื่อจัดการกับคำขอที่เข้ามา: npm install body-parser -save

การสร้าง API

เมื่อคุณเตรียมการตั้งค่าแล้ว เรามาสร้าง Application Programming Interface (API) กันต่อ อินเทอร์เฟซนี้จะช่วยให้ผู้ใช้สามารถสื่อสารกับบล็อคเชน สังเกตสถานะปัจจุบันของเชน และแม้แต่เพิ่มบล็อกใหม่เข้าไปด้วย

สร้างเซิร์ฟเวอร์ด้วย Express:

const express = need(‘express’);
const bodyParser = need(‘body-parser’);
const Blockchain = ต้องการ(‘./blockchain’);  // นำเข้าคลาส Blockchain

const app = express;
app.use(bodyParser.json);

ให้ demoBlockchain = Blockchain ใหม่;  // เริ่มต้นอินสแตนซ์ Blockchain ใหม่

กำหนดจุดสิ้นสุด API

app.get(‘/blocks’, (req, res) => {     //endpoint เพื่อรับ blockchain    
res.json(demoBlockchain.chain);});

//นี่คือจุดสิ้นสุดในการสร้างบล็อกใหม่

app.post(‘/mine’, ( คำขอ, ความละเอียด) => {    
const newBlock = new Block(        
demoBlockchain.chain.length,        
Date.now,        
req.body.data,        
demoBlockchain.getLatestBlock.hash   
);    
demoBlockchain.addBlock(newBlock);
    res.send(`บล็อกสำเร็จแล้ว: ${newBlock.hash}`);
});

เริ่มเซิร์ฟเวอร์

app.listen(3000, => {    
console.log(‘Blockchain API ทำงานบนพอร์ต 3000’);
}) ;
โหนด server.js

บทที่ 6: การเรียกใช้และการทดสอบแอปพลิเคชัน

ฉันไม่สามารถเน้นย้ำถึงความสำคัญของขั้นตอนนี้มากพอเพื่อให้แน่ใจว่าบล็อกเชนของคุณทำงานได้อย่างราบรื่นและให้ผลลัพธ์ที่คุณคาดหวัง ในฐานะคนที่ใช้เวลาหลายปีในการทำงานกับเทคโนโลยีบล็อกเชนต่างๆ ฉันได้เห็นโครงการนับไม่ถ้วนล้มเหลวเนื่องจากการละเลยขั้นตอนสำคัญนี้ อย่าทำผิดพลาดแบบเดิม – ใช้เวลาในการทดสอบและปรับปรุงบล็อคเชนของคุณอย่างละเอียดก่อนที่จะเปิดตัวสู่สาธารณะ เชื่อฉัน; ผู้ใช้ของคุณจะขอบคุณสำหรับมัน!

การเรียกใช้แอปพลิเคชัน

  1. เริ่มต้นเซิร์ฟเวอร์: นำทางไปยังไดเร็กทอรีโปรเจ็กต์ของคุณ จากนั้นรันเป้าหมาย: node server.js
  2. รับการยืนยันเซิร์ฟเวอร์: Blockchain API ทำงานบนพอร์ต 3000
  3. การเข้าถึงแอปพลิเคชัน: ขณะนี้แอปพลิเคชันของคุณทำงานอยู่ในเครื่องบน http://localhost:3000 ทำให้พร้อมที่จะยอมรับคำขอ HTTP

การทดสอบกับบุรุษไปรษณีย์

ในฐานะนักลงทุน crypto ฉันมักจะพึ่งพาเครื่องมือเช่น Postman เพื่อให้แน่ใจว่า blockchain API ของฉันทำงานได้อย่างเหมาะสมที่สุด ด้วยบุรุษไปรษณีย์ ฉันสามารถส่งคำขอ HTTP และวิเคราะห์การตอบกลับที่ส่งคืนได้อย่างง่ายดาย เครื่องมือนี้มีค่าอย่างยิ่งเมื่อต้องทดสอบและตรวจสอบประสิทธิภาพของ API ของฉัน ทำให้การลงทุนของฉันปลอดภัยและมีประสิทธิภาพ

  • ติดตั้งบุรุษไปรษณีย์
  • ทดสอบจุดสิ้นสุด Blockchain
  • ทดสอบจุดสิ้นสุดการขุด
  • ตรวจสอบบล็อกเชน
(ขั้นตอนที่ 1) node server.js
Blockchain API ทำงานบนพอร์ต 3000

//http://localhost: 3000/บล็อก

(ขั้นตอนที่ 2)[    
{        
“ดัชนี”: 0 ,        
“การประทับเวลา”: 1636568887994,        
“ข้อมูล”: “บล็อกการกำเนิด”,       
 “ PreviousHash”: “0”,       
 “hash”:
“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”   
 }
]

(ขั้นตอนที่ 3){    
“ข้อมูล”: {        < br/>“จำนวน”: 100,        
“ผู้ส่ง”: “John Doe”,        
“ผู้รับ”: “Jane Smith ”   
 }
}

(ขั้นตอนที่ 4){   
 “ข้อความ”: “บล็อกการขุดสำเร็จ”,    
“บล็อก”: {        
“ดัชนี”: 1,        
“การประทับเวลา”: 1636578990123,        
“ข้อมูล”: {            
“จำนวน”: 100,             
“ผู้ส่ง”: “จอห์น โด”,            
“ผู้รับ”: “เจน สมิธ”        
},
“previousHash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,       
 “แฮช”:
“5a1cdd657c8d 0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    
}
}

 (ขั้นตอนที่ 5)[    {
“index”: 0,        “timestamp”: 1636568887994,        “data”: “Genesis Block”,        “previousHash”: “0”,        “hash”:“81f1a4ab4d484c64f1b4c524b1d8f2fef 8f2bca7853d44682e12022fb2d803b9”    },    {        “ดัชนี”: 1,        “การประทับเวลา ”: 1636578990123,        “data”: {            “จำนวน”: 100,            “ผู้ส่ง”: “John Doe”,            “ผู้รับ”: “Jane Smith”        },        “ก่อนหน้าH เถ้า”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,        “แฮช”: “5a1cdd657c8d0d3c0f12c2bb2c9fdf32a7d2d4ad13fcb78 170a8caa82ff4a9a2”    } ]

curl http://localhost:3000/blocks //ดูบล็อคเชน
[   
 {       
 “index”: 0,        
“timestamp”: 1636568887994,       
 “data”: “Genesis Block”,       
 “previousHash”: “0”,       
 “hash”:
“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    
}
]

//การขุด blockcurl ใหม่ -X POST -H “ประเภทเนื้อหา: แอปพลิเคชัน /json” -d ‘{“data”: {“จำนวน”: 100, “ผู้ส่ง”: “John Doe”, “ผู้รับ”: “Jane Smith”}}’ http://localhost:3000/mine
//ตรวจสอบ blockcurl http://localhost:3000/blocks

[   
 {       
 “ดัชนี”: 0,        
“ประทับเวลา”: 1636568887994,       
 “ data”: “Genesis Block”,       
 “previousHash”: “0”,       
 “hash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    < br/>},    
{       
 “ดัชนี”: 1,       
 “การประทับเวลา ”: 1636578990123,        
“ข้อมูล”: {           
 “จำนวน”: 100,            
“ผู้ส่ง ”: “John Doe”,            
“ผู้รับ”: “Jane Smith”       
 },        
“previousHash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,       
 “แฮช”:
“5a1cdd657c8d0d3c0f12c 2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    
}
]

บทที่ 7: ตัวอย่างสดของการสร้างแอปพลิเคชันบล็อกเชนด้วย JavaScript

การดำเนินการทีละขั้นตอน

  • ขั้นตอนที่ 1: สร้างคลาส Block ด้วยแอตทริบิวต์ที่จำเป็นโดยใช้ไวยากรณ์ JavaScript
คลาสบล็อก {    
ตัวสร้าง (ดัชนี, การประทับเวลา, ข้อมูล, PreviousHash = ”) {        
this.index = ดัชนี;        
this.timestamp = การประทับเวลา;        
this.data = ข้อมูล;        
this.previousHash = ก่อนหน้าHash;        
this.hash = this.calculateHash;        
this.nonce = 0;    
}
}
  • ขั้นตอนที่ 2: ใช้วิธีคำนวณ Hash
calculateHash {   
 return crypto.createHash(‘sha256’)        
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)       
 .digest(‘hex’);
}
  • ขั้นตอนที่ 3: กำหนดคลาส Blockchain และเริ่มต้นด้วย genesis block
คลาส Blockchain {    
ตัวสร้าง {        
this.chain = [this.createGenesisBlock];    
}
}
  • ขั้นตอนที่ 4: ใช้วิธีการเพิ่มบล็อกใหม่และดึงข้อมูลบล็อกล่าสุดโดยใช้ JavaScript
getLatestBlock {    
ส่งคืน this.chain[this.chain.length – 1];
}

addBlock(newBlock) {    
newBlock.previousHash = this.getLatestBlock.hash;    
newBlock.hash = newBlock.calculateHash;    
this.chain.push(newBlock);}

  • ขั้นตอนที่ 5: เพิ่มฟังก์ชัน Proof of Work ให้กับคลาส Block และอัปเดตคลาส Blockchain
mineBlock(ความยาก) {    
ในขณะที่ (this.hash.substring(0, ความยาก) !== Array(ความยาก + 1).join(“0”)) {        
this.nonce++;        
this.hash = this.calculateHash;    
}
}
  • ขั้นตอนที่ 6: ตั้งค่าสภาพแวดล้อม API เพื่อจัดการคำขอโดยใช้ Express
npm init -y
npm install express -save                        //การตั้งค่าโครงการและ
ไดเร็กทอรี

const express = need(‘express’);      //การตั้งค่าเซิร์ฟเวอร์ด่วนconst bodyParser = need(‘body-parser’);
const Blockchain = need(‘./blockchain’); // สมมติว่าคุณมีคลาส Blockchain จากบทที่แล้ว

const app = express;app.use(bodyParser.json);

const demoBlockchain = บล็อกเชนใหม่;
app.get(‘/blocks’, (req, res) => {    res.json(demoBlockchain.chain);});

app.post(‘/mine’, (req, res) => {            // การสร้างบล็อกใหม่             const newBlock = ใหม่ บล็อก(
demoBlockchain.chain.length,
        Date.now,
        req.body.data ,
        demoBlockchain.getLatestBlock.hash
);
    newBlock.mineBlock(2); // สมมติว่ามีความยากที่ 2 สำหรับ PoW    demoBlockchain.addBlock(newBlock);    
res.send(`Block ขุดได้สำเร็จ: ${newBlock.hash}`);
});
app.listen(3000, => {                               //การเริ่มต้นเซิร์ฟเวอร์    console.log(‘Blockchain API ทำงานบนพอร์ต 3000’);});

โหนด server.js

  • ขั้นตอนที่ 7: ทดสอบแอปพลิเคชันโดยการขุดบล็อกใหม่และตรวจสอบบล็อคเชนโดยใช้บุรุษไปรษณีย์หรือ curl
ในบุรุษไปรษณีย์ ให้ส่งคำขอ:
GET คำขอไปที่ http://localhost:3000/blocks
{    < br/>“data”: {       
 “จำนวน”: 10,       
 “ผู้ส่ง”: “อลิซ”,        
 “ผู้รับ”: “บ๊อบ”   
 }
}

ใน curl:curl
http://localhost:3000/blocks

ให้สรุปขั้นตอนข้างต้นโดยย่อ

มาดูกระบวนการทีละขั้นตอนเพื่อทำให้แอปพลิเคชันบล็อกเชนของคุณมีชีวิตขึ้นมา:

  1. เริ่มต้นด้วยการกำหนดคลาส Block และ Blockchain เพื่อสร้างโครงสร้างหลักของ blockchain ของคุณ
  2. รวม Proof of Work โดยการเพิ่มเมธอด mineBlock ให้กับคลาส Block เพื่อให้แน่ใจว่าแต่ละบล็อกจะตรงตามความยากที่จำเป็นก่อนที่จะถูกเพิ่มเข้ากับเชน
  3. ตั้งค่า API โดยใช้ Express ที่ช่วยให้คุณสามารถโต้ตอบกับบล็อกเชนของคุณ ช่วยให้ดำเนินการต่างๆ ได้ เช่น การดูเชนและเพิ่มบล็อกใหม่
  4. ดำเนินการและทดสอบแอปพลิเคชันของคุณด้วยบุรุษไปรษณีย์หรือ Curl เพื่อตรวจสอบว่าทุกอย่างทำงานได้ตามที่คาดหวัง ตั้งแต่บล็อกการขุดไปจนถึงการดึงข้อมูลบล็อกเชน

ขอให้มีความสุขในการเขียนโค้ด!!

Sorry. No data so far.

2024-08-14 21:30