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

บทนำ

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

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

เหตุใดเราจึงควรสร้างแอปพลิเคชันบล็อกเชน

เทคโนโลยีบล็อกเชนนำเสนอความถูกต้องและการปกป้องข้อมูลที่แข็งแกร่ง รวมถึงแพลตฟอร์มที่เชื่อถือได้สำหรับการแลกเปลี่ยนข้อมูลโดยไม่จำเป็นต้องได้รับความไว้วางใจระหว่างฝ่ายต่างๆ เทคโนโลยีนี้ช่วยให้สามารถพัฒนาสัญญาอัจฉริยะและโทเค็นดิจิทัลได้ ซึ่งปูทางไปสู่ระบบการเงินที่เป็นนวัตกรรมใหม่ เช่น การเงินแบบกระจายอำนาจ (DeFi) และสินทรัพย์ที่ใช้โทเค็น ท่ามกลางโมเดลทางเศรษฐกิจใหม่อื่น ๆ

บทความนี้เป็นการทัวร์สั้นๆ 10 นาทีสู่โลกแห่งการพัฒนา Blockchain ผ่าน C++

พื้นฐานของบล็อคเชน

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

C++ ในบล็อกเชน

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

ด้วยเหตุผลหลายประการ C++ จึงมีความโดดเด่นในด้านการพัฒนาบล็อกเชน การจัดการหน่วยความจำระดับต่ำช่วยให้นักพัฒนาสามารถสร้างระบบบล็อกเชนที่แข็งแกร่งและมีประสิทธิภาพพร้อมการควบคุมที่ปรับแต่งอย่างละเอียด ด้วยขนาดที่ใหญ่โตและความปลอดภัยของเครือข่าย Bitcoin ซึ่งประมวลผลธุรกรรมจำนวนมาก จึงไม่น่าแปลกใจเลยที่ C++ จะถูกเลือกสำหรับงานที่ท้าทายนี้ ในความเป็นจริง แอปพลิเคชันบล็อกเชนยอดนิยม เช่น Bitcoin, Litecoin, Ripple, Monero และ EOS ถูกสร้างขึ้นโดยใช้ C++

เหตุใด C++ จึงเป็นภาษาในอุดมคติสำหรับการพัฒนาบล็อกเชน

การคำนวณที่รวดเร็วยิ่งขึ้น
ประสิทธิภาพสูง
การจัดการหน่วยความจำที่มีประสิทธิภาพ
คุณสมบัติเชิงวัตถุ
รองรับมัลติเธรด
การควบคุมทรัพยากรระบบ

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

ทำความเข้าใจแนวคิดบล็อคเชนด้วย C++

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

เสาหลักของบล็อคเชนที่คุณควรรู้

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

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

โปรโตคอลฉันทามติบล็อคเชน: ชุดของกฎที่แนะนำวิธีการทำงานของบล็อคเชน โดยทุกโหนดภายในเครือข่ายจำเป็นต้องเห็นด้วยกับขั้นตอนเหล่านี้ โปรโตคอลฉันทามติเหล่านี้ทำหน้าที่ประสานโหนดและรับประกันว่าจะมีความเข้าใจที่เหมือนกันทั่วทั้งเครือข่าย

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

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

1.การตั้งค่าสภาพแวดล้อมการพัฒนา C++

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

การติดตั้งคอมไพเลอร์ C++

มาเริ่มด้วยการทำความเข้าใจว่าคอมไพเลอร์คืออะไร

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

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

GCC (คอลเลกชันคอมไพเลอร์ GNU):

ลินุกซ์/MacOS:

เปิดเทอร์มินัลแล้วพิมพ์คำสั่งที่ระบุด้านล่างตามลำดับ

ก) Ubuntu/Debian:
sudo apt update
sudo apt install build-essential

b)Fedora
sudo dnf ติดตั้ง gcc gcc-c++

c)MacOS (เครื่องมือบรรทัดคำสั่ง)
xcode-select -install

สำหรับผู้ใช้ Windows: หากคุณใช้ Windows โปรเจ็กต์ MinGW-w64 อาจเป็นตัวเลือกที่ยอดเยี่ยมสำหรับคุณ เนื่องจากเป็นเวอร์ชันของ GCC (GNU Compiler Collection) ที่ออกแบบมาสำหรับ Windows ทำให้คุณ ควบคุมพลังของ GCC ภายในระบบ Windows ของคุณ

ขั้นตอนในการติดตั้ง:

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

เสียงดังกราว:

Linux/MacOS: sudo apt install clang (รวมถึง clang ที่ติดตั้งไว้แล้วใน MacOS)
Fedora: sudo dnf install clang
Windows: Clang สามารถ ติดตั้งโดยใช้ MinGW หรือผ่านตัวติดตั้งโครงการ LLVM

MSVC (Microsoft Visual C++):

Microsoft Visual C++ ซึ่งมักเรียกสั้น ๆ ว่า MSVC เป็นส่วนสำคัญของ Visual Studio ซึ่งเป็นสภาพแวดล้อมการพัฒนาซอฟต์แวร์ (IDE) อันทรงพลังที่สร้างโดย Microsoft Visual Studio มีเครื่องมือมากมายสำหรับการสร้าง ทดสอบ และเปิดใช้งานแอปพลิเคชัน โดยการติดตั้งซอฟต์แวร์นี้จะกำหนดค่า MSVC บนระบบของคุณโดยอัตโนมัติ

ตรวจสอบการติดตั้งโดยใช้คำสั่งต่อไปนี้ในเทอร์มินัลหรือพร้อมท์คำสั่ง:

g++ -version # สำหรับ GCC
clang -version # สำหรับ Clangcl # สำหรับ MSVC

การเลือก IDE

พื้นที่ทำงานที่ได้รับการปรับปรุงประสิทธิภาพที่เรียกว่า Integrated Development Environment (IDE) ช่วยเพิ่มประสิทธิภาพโดยมอบฟีเจอร์ต่างๆ เช่น การเติมข้อความอัตโนมัติ การแก้ไขปัญหา และการจัดระเบียบโปรเจ็กต์ ทั้งหมดนี้อยู่ในแพลตฟอร์มที่ใช้งานง่ายเพียงแพลตฟอร์มเดียว IDE ยอดนิยมบางรายการสำหรับการเขียนโปรแกรม C++ มีดังต่อไปนี้:

Visual Studio: ดาวน์โหลด Visual Studio จากเว็บไซต์อย่างเป็นทางการ

และทำตามขั้นตอนต่อไปนี้ตามตารางด้านล่าง:

CLion: การติดตั้งและการตั้งค่า:

CLion ซึ่งเป็น Integrated Development Environment (IDE) ที่ใช้กันอย่างแพร่หลาย ดำเนินงานภายใต้การดูแลของ JetBrains แต่จำเป็นต้องสมัครสมาชิกแบบชำระเงิน อย่างไรก็ตาม มันยังเสนอช่วงทดลองใช้งานฟรีอีกด้วย

ให้ทดลองใช้ฟรี

โค้ด Visual Studio: ติดตั้งและตั้งค่าส่วนขยายสำหรับการพัฒนา C++

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

ใช้ตัวจัดการแพ็คเกจเพื่อติดตั้งไลบรารีที่จำเป็น เช่น OpenSSL สำหรับฟังก์ชันการเข้ารหัส ด้านล่างนี้เป็นขั้นตอนและไลบรารีต่างๆ สำหรับระบบปฏิบัติการที่แตกต่างกันและคำสั่ง การสร้างแอปพลิเคชัน Blockchain ด้วย C++

ไชโย! คุณได้กำหนดค่าสภาพแวดล้อมการเขียนโปรแกรมของคุณอย่างมีประสิทธิภาพแล้ว ตอนนี้คุณสามารถเริ่มรันโค้ดของคุณใน Integrated Development Environment (IDE) ที่เหมาะกับคุณที่สุดได้แล้ว

2.การสร้างบล็อกเชนอย่างง่ายด้วย C++

มาทำความคุ้นเคยกับองค์ประกอบที่ประกอบเป็นคลาสบล็อกก่อนที่จะเริ่มเขียนโค้ด

ส่วนประกอบของ Blockclass

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

ลองใช้ฟีเจอร์ทั้งหมดในโค้ดตอนนี้:

คลาสบล็อก {
สาธารณะ:
ดัชนี int;
std::ประทับเวลาสตริง;
ธุรกรรม std::vector;
std::สตริง PreviousHash;
std::สตริงแฮช;
ไม่มีเลย; // สำหรับ PoW

// Constructor
Block(int idx, std::string time , std::vector txs, std::string prevHash) {
index = idx;
การประทับเวลา = เวลา;
ธุรกรรม = txs;
previousHash = prevHash;
ไม่มีค่า = 0;
แฮช = คำนวณแฮช; // แฮชของบล็อกปัจจุบัน
}
    // วิธีคำนวณแฮชของบล็อก
std::string คำนวณ Hash {
std::stringstream ss;
ss << ดัชนี << ประทับเวลา << แฮชก่อนหน้า << nonce;
// เพิ่มข้อมูลธุรกรรมและรายละเอียดเพิ่มเติมใด ๆ ในการคำนวณแฮช
return sha256(ss.str); // ตัวยึดตำแหน่งสำหรับฟังก์ชันแฮชจริง
}

// วิธีการขุดบล็อก
เป็นโมฆะ mineBlock(ความยาก int) {
std::string target (ความยาก, ‘0’); // สร้างสตริงแฮชเป้าหมาย
ในขณะที่ (hash.substr(0, ความยาก) != เป้าหมาย) {
nonce++;
แฮช = คำนวณแฮช;

}
};

ในฐานะนักลงทุน crypto เมื่อฉันตั้งค่าบล็อกคลาสของฉันด้วยคุณสมบัติที่จำเป็นแล้ว ฉันจะดำเนินการสร้าง Genesis Block Genesis Block เป็นบล็อกแรกในบล็อกเชนที่ต้องเริ่มต้นและมีดัชนีเป็นศูนย์ หลังจากกำหนด Genesis Block แล้ว ฉันดำเนินการต่อโดยเพิ่มบล็อกต่อมาใน blockchain ของฉันโดยใช้วิธี ‘addblock’ นี่คือรหัส:

คลาส Blockchain {
สาธารณะ:
std::vector chain;
    บล็อคเชน {
chain.push_back(createGenesisBlock);
}
    บล็อก createGenesisBlock {
ส่งคืนบล็อก (0, “01/01/2024”, “บล็อกปฐมกาล”, “0”);
}
    บล็อก getLatestBlock {
ส่งคืน chain.back;
}
    ถือเป็นโมฆะ addBlock(บล็อก newBlock) {
newBlock.previousHash = getLatestBlock.hash;
newBlock.hash = newBlock.calculateHash;
chain.push_back(บล็อกใหม่);
}
};

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

ธุรกรรมคลาส {สาธารณะ:
std::string sender;
std::สตริงผู้รับ;
จำนวนสองเท่า;
std::string TransactionID;

// ตัวสร้าง    ธุรกรรม (std::string snd, std::string rcp, amt สองเท่า, std::string txID) {
sender = snd;
ผู้รับ = rcp;
จำนวนเงิน = จำนวนเงิน;
รหัสธุรกรรม = txID;
}
    // วิธีการตรวจสอบธุรกรรม
bool validateTransaction {
// การใช้ตรรกะการตรวจสอบความถูกต้อง
คืนค่าเป็นจริง; // ตัวยึดตำแหน่ง
}
};

3.การใช้กลไกฉันทามติใน C++

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

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

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

ในขอบเขตของการเขียนโปรแกรม C++ คุณสามารถสร้างระบบ Proof of Work ได้โดยการรวมแอตทริบิวต์ ‘proof’ และฟังก์ชัน ‘proofOfWork’ ไว้ในคลาส Block ของคุณ นี่เป็นวิธีหนึ่งในการทำสิ่งนี้ให้สำเร็จ:

#include
#include
#include
#include
#include
#include
ใช้เนมสเปซ std;

สตริง sha256 (const string str) {
แฮชถ่านที่ไม่ได้ลงชื่อ[SHA256_DIGEST_LENGTH];
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, str.c_str, str.length);
SHA256_Final(แฮช, &sha256);
สตริงสตรีม เอสเอส;
สำหรับ(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
ss << hex << setw(2) << setfill( ‘0’) << (int)แฮช[i];
}
ส่งคืน ss.str;
}
คลาสบล็อก {
สาธารณะ:
ดัชนี int;
ข้อมูลสตริง;
สตริง PreviousHash;
สตริงแฮช;
หลักฐานยาว;
การประทับเวลา time_t;

Block(int idx, string d, string prevHash) {
ดัชนี = idx;
ข้อมูล = d;
previousHash = prevHash;
ประทับเวลา = เวลา (nullptr);
พิสูจน์ = 0;
แฮช = คำนวณแฮช;
}
    string คำนวณHash const {
stringstream ss;
ss << ดัชนี << ประทับเวลา << ข้อมูล << แฮชก่อนหน้า << พิสูจน์;
ส่งคืน sha256(ss.str);
}
    ถือเป็นโมฆะ proofOfWork (ความยาก int) {
เป้าหมายสตริง (ความยาก ‘0’) ;
ทำ {
พิสูจน์++;
แฮช = คำนวณแฮช;
} ในขณะที่ (hash.substr(0, ความยาก) != เป้าหมาย);
}
};
คลาสบล็อคเชน {
สาธารณะ:
เวกเตอร์<บล็อก> เชน;
ความยาก int;

Blockchain(int diff) {
ความยาก = ความแตกต่าง;
chain.emplace_back(บล็อก(0, “บล็อกปฐมกาล”, “0”));
}
    ถือเป็นโมฆะ addBlock (ข้อมูลสตริง) {
บล็อก newBlock (chain.size, ข้อมูล, chain.back.hash);
newBlock.proofOfWork(ความยาก);
if (isValidProof(newBlock)) {
chain.push_back(newBlock);
}
}
    บูล isValidProof(const บล็อก& บล็อก) const {
return block.hash.substr(0, ความยาก) == string(ความยาก,
‘0’);
}
};

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

4.การสร้าง Blockchain API อย่างง่ายด้วย C++

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

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

ติดตั้งและกำหนดค่าเครื่องมือที่จำเป็นสำหรับการสร้าง API ด้วย C++ ตามที่ระบุในตารางด้านล่าง:

การสร้าง API

#include
#include
#include “blockchain.h”

ใช้เว็บเนมสเปซ;
ใช้เนมสเปซ http;
การใช้ยูทิลิตี้เนมสเปซ;
การใช้เนมสเปซ http::experimental::listener;

Blockchain blockchain( 4); // ระดับความยาก 4

void handleGet(http_request request) {
json::value response = json::value:: อาร์เรย์;
ฉัน = 0;
สำหรับ (อัตโนมัติ& บล็อก : blockchain.chain) {
json::value block_json;
block_json[U(“index”)] = json::value::number(block.index);
block_json[U(“ข้อมูล”)] = json::value::string(block.data);
block_json[U(“previousHash”)] =
json::value::string(block.previousHash);
block_json[U(“แฮช”)] = json::value::string(block.hash);
block_json[U(“พิสูจน์”)] = json::value::number(block.proof);
block_json[U(“การประทับเวลา”)] = json::value::number(block.timestamp);
ตอบกลับ[i++] = block_json;
}
request.reply(status_codes::OK, ตอบกลับ);
}ถือเป็นโมฆะ handlePost(http_request คำขอ) {
request.extract_json.then([&](json::value requestData) {
ข้อมูลอัตโนมัติ = requestData[U(“data”)].as_string;
blockchain.addBlock(data);
request.reply(status_codes ::ตกลง U(“เพิ่มบล็อกเรียบร้อยแล้ว”));
}).รอ;
}
int main {
http_listener Listener(U(“http://localhost :8080”));

listener.support(methods::GET, handleGet);
listener.support(methods::POST, handlePost);

ลอง {
listener.open.wait;
cout << “Listening on http://localhost:8080” << endl;
While (true);
} catch ( ข้อยกเว้น const& e) {
cerr << e.what << endl;

return 0;
}

handleGet ดึงข้อมูล blockchain ทั้งหมดในรูปแบบ JSON

handlePost เพิ่มบล็อกใหม่ให้กับ blockchain โดยใช้ข้อมูลจากคำขอ POST

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

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

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

คอมไพล์โค้ด:
g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprest

เรียกใช้ไฟล์ปฏิบัติการ:.
/blockchain_api

รหัสข้างต้นเริ่มต้นเซิร์ฟเวอร์ API บน http://localhost:8080

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

ทดสอบจุดสิ้นสุด API โดยใช้บุรุษไปรษณีย์หรือ Curl:
เพิ่มบล็อก:
วิธีการ: โพสต์
URL: http://localhost:8080
เนื้อหา: รูปแบบ JSON

{
“data”: “นี่คือบล็อกใหม่”
}

ดูบล็อกเชน:

วิธีการ: GET
URL: http://localhost:8080

ตัวอย่างการเพิ่มบล็อกและการดูบล็อกเชนโดยใช้ API ที่สร้างด้วย C++

void handleGet(คำขอ http_request) {
json::value response = json::value::array;
ฉัน = 0;
สำหรับ (อัตโนมัติ& บล็อก : blockchain.chain) {
json::value block_json;
block_json[U(“index”)] = json::value::number(block.index);
block_json[U(“ข้อมูล”)] = json::value::string(block.data);
block_json[U(“previousHash”)] =
json::value::string(block.previousHash);
block_json[U(“แฮช”)] = json::value::string(block.hash);
block_json[U(“พิสูจน์”)] = json::value::number(block.proof);
block_json[U(“การประทับเวลา”)] = json::value::number(block.timestamp);
ตอบกลับ[i++] = block_json;
}
request.reply(status_codes::OK, ตอบกลับ);
}ถือเป็นโมฆะ handlePost(http_request คำขอ) {
request.extract_json.then([&](json::value requestData) {
ข้อมูลอัตโนมัติ = requestData[U(“data”)].as_string;
blockchain.addBlock(data);
request.reply(status_codes ::ตกลง U(“เพิ่มบล็อกเรียบร้อยแล้ว”))
}).รอ;
}

ฟังก์ชัน handlePost จัดการกระบวนการเพิ่มบล็อกในบล็อกเชนโดยการดึงข้อมูลจากเนื้อหา JSON ที่ให้มาและต่อท้ายบล็อกใหม่เข้ากับเชน

ฟังก์ชัน handleGet จะดึงข้อมูล blockchain ทั้งหมดและส่งกลับเป็นการตอบกลับ JSON

6.ตัวอย่างสดของการสร้างแอปพลิเคชันบล็อกเชนด้วย C++

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

ขั้นตอนที่ 1: สร้างคลาส Block ด้วยแอตทริบิวต์ที่จำเป็นโดยใช้ไวยากรณ์ C++

#include
#include
#include
#include
#include
#include

ใช้เนมสเปซ std;

คลาสบล็อก {
สาธารณะ:
ดัชนี int;
ข้อมูลสตริง;
สตริง PreviousHash;
สตริงแฮช;
หลักฐานยาว;
การประทับเวลา time_t;

Block(int idx, const string& data, const string& prevHash)
: ดัชนี(idx), ข้อมูล(ข้อมูล), PreviousHash(prevHash), พิสูจน์(0),
ประทับเวลา(เวลา(nullptr)) {
แฮช = คำนวณแฮช;
}
    string คำนวณHash const {
stringstream ss;
ss << ดัชนี << การประทับเวลา << ข้อมูล << แฮชก่อนหน้า << พิสูจน์;
ส่งคืน sha256(ss.str);

เป็นโมฆะ proofOfWork (ความยาก int) {
เป้าหมายสตริง (ความยาก ‘0’) ;
ทำ {
พิสูจน์++;
แฮช = คำนวณแฮช;
} ในขณะที่ (hash.substr(0, ความยาก) != เป้าหมาย);
}

ส่วนตัว:
string sha256(const string& input) const {
แฮชถ่านที่ไม่ได้ลงนาม[SHA256_DIGEST_LENGTH];
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, input.c_str, input.size);
SHA256_Final(แฮช, &sha256);

stringstream SS;
สำหรับ (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
ss << hex << setw(2) << setfill( ‘0’) << (int)แฮช[i];
}
ส่งคืน ss.str;
}
};

ขั้นตอนที่ 2: ใช้วิธีคำนวณ Hash

#include
#include
#include
#include

บล็อกคลาส {
สาธารณะ:
ดัชนี int;
std::ข้อมูลสตริง;
std::สตริง PreviousHash;
std::สตริงแฮช;
หลักฐานยาว;
ประทับเวลา time_t;

บล็อก(int idx, const std::string& data, const std ::string& prevHash)
: ดัชนี(idx), ข้อมูล(ข้อมูล), PreviousHash(prevHash), พิสูจน์(0),
ประทับเวลา( เวลา(nullptr)) {
hash = คำนวณHash;
}
std::string คำนวณHash const {
std::stringstream ss;
ss << ดัชนี << ประทับเวลา << ข้อมูล << แฮชก่อนหน้า << พิสูจน์;
ส่งคืน sha256(ss.str);
}

ส่วนตัว:
std::string sha256(const std:: สตริง & อินพุต) const {
แฮชถ่านที่ไม่ได้ลงชื่อ[SHA256_DIGEST_LENGTH];
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, input.c_str, input.size);
SHA256_Final(hash, &sha256);

std::stringstream ss;
สำหรับ (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
ss << std::hex << std::setw( 2) << std::setfill(‘0’) << (int)แฮช[i];

ส่งคืน ss.str;

};

ขั้นตอนที่ 3: กำหนดคลาส Blockchain และเริ่มต้นด้วย genesis block

คลาส Blockchain {
สาธารณะ:
Blockchain(int ความยาก)
: ความยาก(ความยาก ) {
chain.emplace_back(Block(0, “Genesis Block”, “0”));
}
    ถือเป็นโมฆะ addBlock(const string& data) {
บล็อก newBlock(chain.size, data , chain.back.hash);
newBlock.proofOfWork(ความยาก);
chain.push_back(บล็อกใหม่);
}
    const Block& latestBlock const {
ส่งคืน chain.back;
}
     vector chain;

ส่วนตัว:
ความยากง่าย;
};

ขั้นตอนที่ 4: ใช้วิธีคำนวณ Hash

#include
#include
#include
#include

บล็อกคลาส {
สาธารณะ:
ดัชนี int;
std::ข้อมูลสตริง;
std::สตริง PreviousHash;
std::สตริงแฮช;
หลักฐานยาว;    time_t การประทับเวลา

Block(int idx, const std::string& data, const std::string& prevHash)
: ดัชนี(idx), ข้อมูล(ข้อมูล), PreviousHash(prevHash), พิสูจน์(0),
ประทับเวลา(เวลา(nullptr)) {        < br/>แฮช = คำนวณแฮช;
}
    std::string คำนวณHash const {
std::stringstream ss;
ss << ดัชนี << ประทับเวลา << ข้อมูล << แฮชก่อนหน้า << พิสูจน์;
ส่งคืน sha256(ss.str);
}
ส่วนตัว:
std::string sha256(const std::string& input) const {
แฮชถ่านที่ไม่ได้ลงชื่อ[SHA256_DIGEST_LENGTH];
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, input.c_str, input.size);
SHA256_Final(hash, &sha256);

std::stringstream ss;
สำหรับ (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
ss << std::hex << std::setw( 2) << std::setfill(‘0’) <<
(int)แฮช[i];
}
ส่งคืน ss.str;
}
};

ขั้นตอนที่ 5: กำหนดคลาส Blockchain และเริ่มต้นด้วย genesis block

คลาส Blockchain {
สาธารณะ:
Blockchain(int ความยาก)
: ความยาก(ความยาก ) {
chain.emplace_back(Block(0, “Genesis Block”, “0”));
}

เป็นโมฆะ addBlock (สตริง const& ข้อมูล) {
บล็อก newBlock(chain.size, ข้อมูล, chain.back.hash);
newBlock.proofOfWork(ความยาก);
chain.push_back(บล็อกใหม่);
}
    const Block& latestBlock const {
ส่งคืน chain.back;

vector chain;

ส่วนตัว:
ความยาก int;};

ขั้นตอนที่ 6: ตั้งค่าสภาพแวดล้อม API เพื่อจัดการคำขอโดยใช้ไลบรารี C++ ที่เหมาะสม

#include
#include

การใช้เนมสเปซเว็บ;
การใช้เนมสเปซเว็บ::http;
การใช้เนมสเปซเว็บ::http:: ทดลอง::listener;

คลาส BlockchainAPI {สาธารณะ:
BlockchainAPI(const string& address, Blockchain& blockchain) < br/>: ผู้ฟัง(http_listener(U(ที่อยู่))), blockchain(blockchain) {
listener.support(methods::GET,
std::bind(&BlockchainAPI::handleGet, this, std::placeholders::_1));
listener.support(methods::POST, std::bind (&BlockchainAPI::handlePost, this, std::placeholders::_1));

การเริ่มต้นเป็นโมฆะ {listener.open.wait; ศาล << “Blockchain API ทำงาน…” << endl;
ส่วนตัว:http_listener Listener; Blockchain& blockchain;void handleGet (คำขอ http_request) {json::value response = json::value::array;int i = 0;for (const auto& block : blockchain.chain) {json::value block_json;block_json[U( “index”)] = json::value::number(block.index);block_json[U(“data”)] = json::value::string(block.data);block_json[U(“previousHash”) ] = json::value::string(block.previousHash);block_json[U(“hash”)] = json::value::string(block.hash);block_json[U(“พิสูจน์”)] = json: :value::number(block.proof);block_json[U(“timestamp”)] = json::value::number(block.timestamp);response[i++] = block_json; request.reply(status_codes::OK, ตอบกลับ); } void handlePost(คำขอ http_request) {request.extract_json.then([&](json::value requestData) {string data = requestData[U(“data”)].as_string;blockchain.addBlock(data);request.reply (status_codes::OK, U(“เพิ่มบล็อกเรียบร้อยแล้ว”));}) รอ ; }} ;

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

หลัก:
int main {
Blockchain blockchain(4); // ระดับความยาก

BlockchainAPI api(“http://localhost:8080”, blockchain);
api.start;

ส่งคืน 0;

}

การทดสอบ:
curl -X POST http://localhost:8080 -H “เนื้อหา- ประเภท: application/json” -d ‘{“data”:”นี่คือบล็อกใหม่”}’

การเริ่มต้นการพัฒนาบล็อคเชนโดยใช้ C++ เกี่ยวข้องมากกว่าการเขียนโค้ด เป็นเรื่องเกี่ยวกับการสร้างองค์ประกอบพื้นฐานของระบบการกระจายอำนาจ ซึ่งสัญญาว่าจะเปลี่ยนแปลงภาคส่วนต่างๆ มากมายอย่างมาก

โดยสรุป เราได้เจาะลึกถึงสิ่งสำคัญของการเขียนโปรแกรม C++ เมื่อนำไปใช้กับเทคโนโลยีบล็อกเชน และก้าวไปสู่กระบวนการปรับใช้และทดสอบแอปพลิเคชันที่พัฒนาขึ้นของเรา

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

ฝึกฝนความกระหายความรู้ นำกรอบความคิดในการเรียนรู้ตลอดชีวิต และอย่าหยุดเขียนโค้ด ขอให้นวัตกรรมของคุณกำหนดทิศทางของความก้าวหน้าทางเทคโนโลยี!

Sorry. No data so far.

2024-09-17 10:54