เราควรสร้างบล็อคเชนอย่างไร?

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

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

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

ดังนั้น เรามาจำไว้ว่าปัญหาใดบ้างที่บล็อคเชนได้รับการแก้ไขตั้งแต่แรก

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

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

ความท้าทายบล็อคเชน

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

ปัญหาที่บล็อคเชนแก้ไขได้

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

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

ในโลกอุดมคติ โครงการนี้ใช้ได้ผลดี แต่ปัญหาต่อไปนี้เกิดขึ้นกับเรา:

1. ปัญหาในการระบุผู้เข้าร่วมในด้านหนึ่งและความจำเป็นในการไม่เปิดเผยตัวตนของธุรกรรมในอีกด้านหนึ่ง เหล่านั้น. คุณต้องโอนเงินไปยังผู้รับเฉพาะและในลักษณะที่ไม่มีใครรู้เกี่ยวกับธุรกรรมนี้ ยกเว้นผู้เข้าร่วมในธุรกรรม ธนาคารมีหมายเลขบัญชีและบัตรธนาคารที่เชื่อมโยงกับบุคคลหรือนิติบุคคลที่เฉพาะเจาะจง และความลับของธนาคารจะปกป้องข้อมูลการทำธุรกรรม และใครเป็นผู้รับประกันว่า AnonymousWorldMoney แบบมีเงื่อนไขจะไม่ใช้ข้อมูลส่วนบุคคลและข้อมูลธุรกรรมเพื่อวัตถุประสงค์ของตนเอง
2. จะแน่ใจได้อย่างไรว่าผู้รับได้รับจำนวนเงินที่โอนไปให้เขาอย่างแน่นอน? ในทางกลับกัน ผู้ส่งโอนเงิน $100 และผู้รับได้รับ $10 ผู้ส่งมาที่สำนักงาน AnonymousWorldMoney พร้อมใบเสร็จรับเงิน และพนักงานก็แสดงเอกสารของเขา ซึ่งมีข้อความเขียนว่าผู้ส่งโอนเงินเพียง 10 ดอลลาร์เท่านั้น
3. ปัญหาสภาพแวดล้อมที่ไม่น่าเชื่อถือ เช่น การหลอกลวงที่เรียกว่าการใช้จ่ายซ้ำซ้อน ผู้เข้าร่วมที่ไร้ศีลธรรมสามารถใช้ยอดคงเหลือของเขาได้หลายครั้งจนกว่าการชำระเงินจะถูกจำลองไปยังเซิร์ฟเวอร์ทั้งหมด ทฤษฎีบทแคปแน่นอนว่าไม่มีใครยกเลิกและในที่สุดจะบรรลุข้อตกลง แต่บางคนจะไม่ได้รับเงินสำหรับบริการหรือสินค้าที่มอบให้ ดังนั้นหากไม่มีความไว้วางใจอย่างสมบูรณ์ในองค์กรการชำระเงินหรือผู้เข้าร่วมในการทำธุรกรรม ก็จำเป็นต้องสร้างเครือข่ายที่ไม่ขึ้นอยู่กับความไว้วางใจ แต่ขึ้นอยู่กับการเข้ารหัส
4. AnonymousWorldMoney แบบมีเงื่อนไขมีจำนวนเซิร์ฟเวอร์ที่จำกัดซึ่งอาจใช้งานไม่ได้โดยไม่ได้ตั้งใจหรือเนื่องมาจากเจตนาร้าย
5. AnonymousWorldMoney จะใช้ค่าคอมมิชชั่นที่จับต้องได้ของตัวเอง
6. ความเป็นไปได้ของการควบคุม ในระหว่างการดำเนินการของ Bitcoin ปรากฎว่าผู้คนไม่เพียงต้องการโอนเหรียญให้กันและกัน แต่ยังต้องตรวจสอบเงื่อนไขต่าง ๆ สำหรับการทำธุรกรรม สถานการณ์การทำงานของโปรแกรม ดำเนินการโดยอัตโนมัติตามเงื่อนไข ฯลฯ

blockchain แก้ปัญหาเหล่านี้ได้อย่างไร

1. การระบุตัวตนของผู้เข้าร่วมดำเนินการโดยใช้คีย์คู่หนึ่ง: ส่วนตัวและสาธารณะ และอัลกอริธึมลายเซ็นดิจิทัลจะระบุผู้ส่งและผู้รับโดยไม่ซ้ำกัน โดยไม่เปิดเผยตัวตน
2. ธุรกรรมจะถูกรวบรวมเป็นบล็อก แฮชของบล็อกจะถูกคำนวณและเขียนลงในบล็อกถัดไป ลำดับการบันทึกแฮชในบล็อกนี้ทำให้เทคโนโลยีบล็อกเชนมีชื่อ และยังทำให้เป็นไปไม่ได้ที่จะเปลี่ยนแปลง / ลบบล็อกหรือธุรกรรมแต่ละรายการจากบล็อกโดยไม่มีใครสังเกตเห็น ดังนั้นหากธุรกรรมรวมอยู่ในบล็อคเชน คุณสามารถมั่นใจได้ว่าข้อมูลจะไม่เปลี่ยนแปลง
3. การฉ้อโกงการใช้จ่ายซ้ำซ้อนได้รับการป้องกันการบรรลุข้อตกลงร่วมกันของเครือข่ายว่าข้อมูลใดที่จะพิจารณาว่าถูกต้องและข้อมูลใดควรละทิ้ง ในเครือข่าย Bitcoin ฉันทามติสามารถทำได้โดยการพิสูจน์การทำงาน (PoW)
4. ความน่าเชื่อถือของเครือข่ายนั้นเกิดขึ้นได้จากข้อเท็จจริงที่ว่าบล็อคเชนเป็นแบบสาธารณะ โดยที่ผู้เข้าร่วมแต่ละคนสามารถรันโหนดของตนเอง รับสำเนาบล็อคเชนที่สมบูรณ์ และยิ่งไปกว่านั้น เริ่มตรวจสอบธุรกรรมอย่างอิสระเพื่อความถูกต้อง ควรสังเกตว่าบล็อกเชนสมัยใหม่ทำให้สามารถสร้างได้ไม่เพียงแต่บล็อกสาธารณะ (เปิด) เท่านั้น แต่ยังรวมถึงบล็อกเชนส่วนตัว (ปิด) อีกด้วย เช่นเดียวกับการใช้รูปแบบที่รวมกัน
5. บล็อกเชนจะไม่กำจัดค่าคอมมิชชั่นออกไปโดยสิ้นเชิง เพราะ... คุณต้องจ่ายเงินให้กับผู้ที่สนับสนุนเครือข่าย แต่ในบล็อกเชนความต้องการค่าคอมมิชชั่นได้รับการพิสูจน์อย่างน่าเชื่อจนไม่มีข้อสงสัยเกี่ยวกับความจำเป็นของมัน
6. บล็อกเชนสมัยใหม่มีความสามารถในการนำตรรกะทางธุรกิจไปใช้ ซึ่งในบล็อกเชนเรียกว่าสัญญาอัจฉริยะ ตรรกะของสัญญาอัจฉริยะถูกนำไปใช้ในภาษาระดับสูงต่างๆ

ต่อไปเราจะพิจารณาวิธีแก้ปัญหาเหล่านี้โดยละเอียด

สถาปัตยกรรมบล็อคเชน

ส่วนประกอบบล็อคเชน

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

วงจรชีวิตของธุรกรรม

มาดูวงจรการทำธุรกรรมและแยกย่อยทีละชิ้น:

เทคโนโลยีบล็อกเชน

ให้เราดูรายละเอียดเพิ่มเติมเกี่ยวกับโซลูชันทางเทคนิคและการเชื่อมต่อระหว่างกัน

บัตรประจำตัว

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

Private key: 0a78194a8a893b8baac7c09b6a4a4b4b161b2f80a126cbb79bde231a4567420f
Public key: 0579b478952214d7cddac32ac9dc522c821a4489bc10aac3a81b9d1cd7a92e57ba
Address: 0x3814JnJpGnt5tB2GD1qfKP709W3KbRdfb27V

ในการสร้างลายเซ็นดิจิทัลในบล็อกเชน จะใช้อัลกอริธึมที่ใช้เส้นโค้งรูปไข่: Elliptic Curve Digital Signature Algorithm (ECDSA) เพื่อให้ใช้งานได้ โดยปกติคีย์ส่วนตัว (หมายเลข 256 บิต) จะถูกสุ่มเลือก จำนวนตัวเลือกคีย์คือ 2 ยกกำลัง 256 ดังนั้นเราจึงสามารถพูดคุยเกี่ยวกับความเป็นไปไม่ได้ในทางปฏิบัติในการจับคู่ค่าของคีย์ส่วนตัว

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

มีบทความมากมายที่มีรายละเอียดเกี่ยวกับการเข้ารหัสที่ใช้ในบล็อกเชน เช่น: โดยสรุป Bitcoin – การเข้ารหัส

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

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

การทำธุรกรรม

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

From: 0x48C89c341C5960Ca2Bf3732D6D8a0F4f89Cc4368 - цифровой адрес отправителя
To: 0x367adb7894334678b90аfe7882a5b06f7fbc783a - цифровой адрес получателя
Value: 0.0001 - сумма транзакции
Transaction Hash: 0x617ede331e8a99f46a363b32b239542bb4006e4fa9a2727a6636ffe3eb095cef - хэш транзакции

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

บล็อกธุรกรรม

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

000000000000000000000bf03212e7dd1176f52f816fa395fc9b93c44bc11f91

การค้นหาแฮชที่ประสบความสำเร็จถือเป็นข้อพิสูจน์การทำงาน (Proof-of-Work, PoW) สำหรับเครือข่าย Bitcoin หรือ Ethereum กระบวนการค้นหาแฮชเรียกว่าการขุด คล้ายกับการขุดทอง ชื่อค่อนข้างแม่นยำกำหนดสาระสำคัญของกระบวนการเพราะว่า มีการค้นหาตัวเลือกง่ายๆ และหากใครพบแฮชที่เหมาะสมแสดงว่าโชคดีจริงๆ มันเหมือนกับการหาก้อนทองคำแท้ ๆ ในหินขยะจำนวนมาก รางวัลบล็อคตอนนี้อยู่ที่ 12.5 BTC และหากคุณคูณด้วยอัตรา Bitcoin ปัจจุบันที่ $3900 คุณจะได้รับทองคำบริสุทธิ์มากกว่าหนึ่งกิโลกรัม มีเรื่องต้องสู้!

หลังจากค้นหาแฮชได้สำเร็จ บล็อกและแฮชที่พบนั้นจะถูกเขียนลงในบล็อกเชนเป็นบล็อกถัดไป รายละเอียดเพิ่มเติมเกี่ยวกับโครงสร้างของบล็อกสามารถพบได้ในบทความ Bitcoin โดยสรุป-Blockchainและด้านล่างเป็นไดอะแกรมอย่างง่าย:

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

ขนาดของบล็อกใน Bitcoin ถูกจำกัดไว้ที่ 1MB และด้วยจำนวนข้อมูลขั้นต่ำในธุรกรรมประมาณ 200 ไบต์ จำนวนธุรกรรมสูงสุดในบล็อกสามารถอยู่ที่ประมาณ 6000 จากที่นี่ ติดตามประสิทธิภาพของ Bitcoin ที่ทุกคนหัวเราะเยาะ: บล็อกจะถูกสร้างขึ้นประมาณหนึ่งครั้งทุกๆ 10 นาที * 60 วินาที = 600 วินาที ซึ่งให้ประสิทธิภาพอย่างเป็นทางการประมาณ 10 TPS แม้ว่าในความเป็นจริงแล้วนี่ไม่ใช่ประสิทธิภาพการทำงาน แต่เป็นอัลกอริธึมการทำงานที่จงใจนำไปใช้ สำหรับการแข่งขันใน Ethereum พวกเขาสร้างเวลาสร้างบล็อกเพียง 15 วินาที และผลผลิตก็เพิ่มสูงขึ้นอย่างเป็นทางการ ดังนั้นในบล็อกเชนที่ใช้ PoW เป็นเอกฉันท์ จึงไม่สมเหตุสมผลที่จะเปรียบเทียบประสิทธิภาพเลย เพราะ ขึ้นอยู่กับความซับซ้อนของการคำนวณแคชโดยตรงซึ่งสามารถกำหนดให้กับค่าใดก็ได้

ส้อม

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

จะเกิดอะไรขึ้นต่อไป? ถัดไป ส่วนหนึ่งของเครือข่ายเริ่มทำงานบนบล็อก N+2 จากเครือข่ายหนึ่ง และส่วนหนึ่งจากอีกเครือข่ายหนึ่ง:

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

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

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

ฉันทามติ

หากต้องการบันทึกบล็อกบนบล็อกเชน เครือข่ายจะต้องได้รับความเห็นพ้องต้องกัน จำภารกิจในการบรรลุฉันทามติในเครือข่ายการสื่อสารคอมพิวเตอร์ ปัญหาถูกกำหนดให้เป็นงานของนายพลไบแซนไทน์ BFT (ความทนทานต่อความผิดพลาดของไบแซนไทน์). หากละเว้นคำอธิบายที่งดงามของปัญหาของกองทัพไบแซนไทน์ ปัญหาสามารถกำหนดได้ดังนี้: โหนดเครือข่ายจะบรรลุผลร่วมกันได้อย่างไร หากโหนดเครือข่ายบางโหนดจงใจบิดเบือนโหนดเหล่านั้น อัลกอริธึมที่มีอยู่สำหรับการแก้ปัญหา BFT แสดงให้เห็นว่าเครือข่ายสามารถทำงานได้อย่างถูกต้องหากมีผู้ฉ้อโกงน้อยกว่า 1/3 เหตุใดจึงไม่ใช้ฉันทามติ BFT กับเครือข่าย Bitcoin เหตุใดจึงจำเป็นต้องใช้ PoW? มีสาเหตุหลายประการ:

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

นอกจาก PoW แล้ว ยังมีฉันทามติอื่นๆ อีกหลายประการที่ใช้ในบล็อกเชนสมัยใหม่ เช่น:

• PoS (หลักฐานการเดิมพัน) - บนบล็อกเชน Hyperledger
• DPoS (Delegated Proof-of-Stake) - บนบล็อกเชน BitShares
• การปรับเปลี่ยน BFT: SBFT (Siimple BFT) และ PBFT (Practical BFT) เช่นใน blockchain เอ็กโซนัม

เรามาอาศัยความเห็นพ้องต้องกันของ PoS กันสักหน่อย เพราะ... PoS และความหลากหลายที่แพร่หลายมากที่สุดในบล็อกเชนส่วนตัว ทำไมต้องเป็นการส่วนตัว? ประการหนึ่งลักษณะของ PoS นั้นดีกว่าเมื่อเปรียบเทียบกับ PoW เพราะ เพื่อให้บรรลุข้อตกลงร่วมกัน จำเป็นต้องใช้ทรัพยากรการประมวลผลน้อยลง ซึ่งหมายความว่าความเร็วในการเขียนข้อมูลไปยังบล็อกเชนจะเพิ่มขึ้น แต่ในทางกลับกัน PoS มีโอกาสมากขึ้นในการฉ้อโกง ดังนั้นเพื่อต่อต้านสิ่งนี้ ผู้เข้าร่วมทั้งหมดในบล็อกเชนจะต้องเป็นที่รู้จัก

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

• ฉันทามติ Delegated PoS (DPoS) แบ่งผู้เข้าร่วมออกเป็น “ผู้ลงคะแนน” และ “ผู้ตรวจสอบ” ผู้ถือเหรียญ (ผู้เข้าร่วมการลงคะแนนเสียง) มอบอำนาจของตนในการตรวจสอบและบันทึกธุรกรรมบนบล็อกเชนให้กับผู้เข้าร่วมรายอื่น ดังนั้นผู้ตรวจสอบความถูกต้องจึงทำงานด้านการคำนวณทั้งหมดและได้รับรางวัล และการมีผู้เข้าร่วมลงคะแนนรับประกันความซื่อสัตย์ของผู้ตรวจสอบ เนื่องจาก สามารถเปลี่ยนแปลงได้ตลอดเวลา
• ฉันทามติ LPoS (Leased Proof-of-Stake) ช่วยให้คุณสามารถเช่าเงินของคุณไปยังโหนดอื่นเพื่อให้มีโอกาสตรวจสอบบล็อกได้ดีขึ้น ที่. คุณสามารถรับค่าคอมมิชชั่นสำหรับการทำธุรกรรมโดยไม่ต้องเข้าร่วมในการตรวจสอบธุรกรรมจริงและการขุดบล็อก

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

• PoET (พิสูจน์เวลาที่ผ่านไป)
• PoC (พิสูจน์ความจุ)
• PoB (หลักฐานการเผาไหม้)
• PoWeight (พิสูจน์น้ำหนัก)
• PoA (พิสูจน์กิจกรรม) – PoW + PoS
• PoI (หลักฐานการนำเข้า)

รูปแบบความน่าเชื่อถือและการปรับใช้ของบล็อคเชน

บล็อกเชนสาธารณะ

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

บล็อกเชนส่วนตัว

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

สมาคมบล็อคเชน

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

สัญญาสมาร์ท

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

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

ตัวอย่างคลาสสิกของฟังก์ชันการทำงานที่นำมาใช้โดยใช้สัญญาอัจฉริยะคือการออกโทเค็นสำหรับ ICO ตัวอย่างเช่น ฉันใช้สัญญาอัจฉริยะเพื่อออก AlexToken จำนวน 500 AlexToken โดย ลิงค์ใน Etherscan เป็น

ซอร์สโค้ดของสัญญาอัจฉริยะในภาษา Solidity

pragma solidity ^0.4.23;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
**/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
**/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
**/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
**/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
**/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender account.
**/
constructor() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
**/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
**/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/**
* @title ERC20Basic interface
* @dev Basic ERC20 interface
**/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
**/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
**/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
**/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
**/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
**/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
**/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
**/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
**/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
**/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
**/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
/**
* @title Configurable
* @dev Configurable varriables of the contract
**/
contract Configurable {
uint256 public constant cap = 1000000000*10**18;
uint256 public constant basePrice = 100*10**18; // tokens per 1 ether
uint256 public tokensSold = 0;
uint256 public constant tokenReserve = 500000000*10**18;
uint256 public remainingTokens = 0;
}
/**
* @title CrowdsaleToken 
* @dev Contract to preform crowd sale with token
**/
contract CrowdsaleToken is StandardToken, Configurable, Ownable {
/**
* @dev enum of current crowd sale state
**/
enum Stages {
none,
icoStart, 
icoEnd
}
Stages currentStage;
/**
* @dev constructor of CrowdsaleToken
**/
constructor() public {
currentStage = Stages.none;
balances[owner] = balances[owner].add(tokenReserve);
totalSupply_ = totalSupply_.add(tokenReserve);
remainingTokens = cap;
emit Transfer(address(this), owner, tokenReserve);
}
/**
* @dev fallback function to send ether to for Crowd sale
**/
function () public payable {
require(currentStage == Stages.icoStart);
require(msg.value > 0);
require(remainingTokens > 0);
uint256 weiAmount = msg.value; // Calculate tokens to sell
uint256 tokens = weiAmount.mul(basePrice).div(1 ether);
uint256 returnWei = 0;
if(tokensSold.add(tokens) > cap){
uint256 newTokens = cap.sub(tokensSold);
uint256 newWei = newTokens.div(basePrice).mul(1 ether);
returnWei = weiAmount.sub(newWei);
weiAmount = newWei;
tokens = newTokens;
}
tokensSold = tokensSold.add(tokens); // Increment raised amount
remainingTokens = cap.sub(tokensSold);
if(returnWei > 0){
msg.sender.transfer(returnWei);
emit Transfer(address(this), msg.sender, returnWei);
}
balances[msg.sender] = balances[msg.sender].add(tokens);
emit Transfer(address(this), msg.sender, tokens);
totalSupply_ = totalSupply_.add(tokens);
owner.transfer(weiAmount);// Send money to owner
}
/**
* @dev startIco starts the public ICO
**/
function startIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
/**
* @dev endIco closes down the ICO 
**/
function endIco() internal {
currentStage = Stages.icoEnd;
// Transfer any remaining tokens
if(remainingTokens > 0)
balances[owner] = balances[owner].add(remainingTokens);
// transfer any remaining ETH balance in the contract to the owner
owner.transfer(address(this).balance); 
}
/**
* @dev finalizeIco closes down the ICO and sets needed varriables
**/
function finalizeIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
endIco();
}
}
/**
* @title LavevelToken 
* @dev Contract to create the Lavevel Token
**/
contract AlexToken is CrowdsaleToken {
string public constant name = "AlexToken";
string public constant symbol = "ALT";
uint32 public constant decimals = 18;
}

และการเป็นตัวแทนไบนารีตามที่เครือข่ายเห็น

60806040526000600355600060045533600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000600560146101000a81548160ff021916908360028111156200006f57fe5b0217905550620001036b019d971e4fe8401e74000000600080600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546200024a6401000000000262000b1d179091906401000000009004565b600080600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550620001986b019d971e4fe8401e740000006001546200024a6401000000000262000b1d179091906401000000009004565b6001819055506b033b2e3c9fd0803ce8000000600481905550600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef6b019d971e4fe8401e740000006040518082815260200191505060405180910390a362000267565b600081830190508281101515156200025e57fe5b80905092915050565b611cb880620002776000396000f300608060405260043610610112576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806306fdde03146104c7578063095ea7b31461055757806318160ddd146105bc57806323b872dd146105e7578063313ce5671461066c578063355274ea146106a3578063518ab2a8146106ce57806366188463146106f957806370a082311461075e57806389311e6f146107b55780638da5cb5b146107cc578063903a3ef61461082357806395d89b411461083a578063a9059cbb146108ca578063bf5839031461092f578063c7876ea41461095a578063cbcb317114610985578063d73dd623146109b0578063dd62ed3e14610a15578063f2fde38b14610a8c575b60008060008060006001600281111561012757fe5b600560149054906101000a900460ff16600281111561014257fe5b14151561014e57600080fd5b60003411151561015d57600080fd5b600060045411151561016e57600080fd5b3494506101a7670de0b6b3a764000061019968056bc75e2d6310000088610acf90919063ffffffff16565b610b0790919063ffffffff16565b9350600092506b033b2e3c9fd0803ce80000006101cf85600354610b1d90919063ffffffff16565b111561024c576101f66003546b033b2e3c9fd0803ce8000000610b3990919063ffffffff16565b915061022e670de0b6b3a764000061022068056bc75e2d6310000085610b0790919063ffffffff16565b610acf90919063ffffffff16565b90506102438186610b3990919063ffffffff16565b92508094508193505b61026184600354610b1d90919063ffffffff16565b6003819055506102886003546b033b2e3c9fd0803ce8000000610b3990919063ffffffff16565b6004819055506000831115610344573373ffffffffffffffffffffffffffffffffffffffff166108fc849081150290604051600060405180830381858888f193505050501580156102dd573d6000803e3d6000fd5b503373ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef856040518082815260200191505060405180910390a35b610395846000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b1d90919063ffffffff16565b6000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055503373ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef866040518082815260200191505060405180910390a361045184600154610b1d90919063ffffffff16565b600181905550600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc869081150290604051600060405180830381858888f193505050501580156104bf573d6000803e3d6000fd5b505050505050005b3480156104d357600080fd5b506104dc610b52565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561051c578082015181840152602081019050610501565b50505050905090810190601f1680156105495780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34801561056357600080fd5b506105a2600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610b8b565b604051808215151515815260200191505060405180910390f35b3480156105c857600080fd5b506105d1610c7d565b6040518082815260200191505060405180910390f35b3480156105f357600080fd5b50610652600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610c87565b604051808215151515815260200191505060405180910390f35b34801561067857600080fd5b50610681611041565b604051808263ffffffff1663ffffffff16815260200191505060405180910390f35b3480156106af57600080fd5b506106b8611046565b6040518082815260200191505060405180910390f35b3480156106da57600080fd5b506106e3611056565b6040518082815260200191505060405180910390f35b34801561070557600080fd5b50610744600480360381019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019092919050505061105c565b604051808215151515815260200191505060405180910390f35b34801561076a57600080fd5b5061079f600480360381019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506112ed565b6040518082815260200191505060405180910390f35b3480156107c157600080fd5b506107ca611335565b005b3480156107d857600080fd5b506107e16113eb565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561082f57600080fd5b50610838611411565b005b34801561084657600080fd5b5061084f6114ab565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561088f578082015181840152602081019050610874565b50505050905090810190601f1680156108bc5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b3480156108d657600080fd5b50610915600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506114e4565b604051808215151515815260200191505060405180910390f35b34801561093b57600080fd5b50610944611703565b6040518082815260200191505060405180910390f35b34801561096657600080fd5b5061096f611709565b6040518082815260200191505060405180910390f35b34801561099157600080fd5b5061099a611716565b6040518082815260200191505060405180910390f35b3480156109bc57600080fd5b506109fb600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050611726565b604051808215151515815260200191505060405180910390f35b348015610a2157600080fd5b50610a76600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050611922565b6040518082815260200191505060405180910390f35b348015610a9857600080fd5b50610acd600480360381019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506119a9565b005b600080831415610ae25760009050610b01565b8183029050818382811515610af357fe5b04141515610afd57fe5b8090505b92915050565b60008183811515610b1457fe5b04905092915050565b60008183019050828110151515610b3057fe5b80905092915050565b6000828211151515610b4757fe5b818303905092915050565b6040805190810160405280600981526020017f416c6578546f6b656e000000000000000000000000000000000000000000000081525081565b600081600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925846040518082815260200191505060405180910390a36001905092915050565b6000600154905090565b60008073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614151515610cc457600080fd5b6000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548211151515610d1157600080fd5b600260008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548211151515610d9c57600080fd5b610ded826000808773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b3990919063ffffffff16565b6000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610e80826000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b1d90919063ffffffff16565b6000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610f5182600260008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b3990919063ffffffff16565b600260008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a3600190509392505050565b601281565b6b033b2e3c9fd0803ce800000081565b60035481565b600080600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205490508083111561116d576000600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550611201565b6111808382610b3990919063ffffffff16565b600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546040518082815260200191505060405180910390a3600191505092915050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561139157600080fd5b60028081111561139d57fe5b600560149054906101000a900460ff1660028111156113b857fe5b141515156113c557600080fd5b6001600560146101000a81548160ff021916908360028111156113e457fe5b0217905550565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561146d57600080fd5b60028081111561147957fe5b600560149054906101000a900460ff16600281111561149457fe5b141515156114a157600080fd5b6114a9611b01565b565b6040805190810160405280600381526020017f414c54000000000000000000000000000000000000000000000000000000000081525081565b60008073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415151561152157600080fd5b6000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054821115151561156e57600080fd5b6115bf826000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b3990919063ffffffff16565b6000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550611652826000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b1d90919063ffffffff16565b6000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a36001905092915050565b60045481565b68056bc75e2d6310000081565b6b019d971e4fe8401e7400000081565b60006117b782600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b1d90919063ffffffff16565b600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546040518082815260200191505060405180910390a36001905092915050565b6000600260008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141515611a0557600080fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614151515611a4157600080fd5b8073ffffffffffffffffffffffffffffffffffffffff16600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a380600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6002600560146101000a81548160ff02191690836002811115611b2057fe5b021790555060006004541115611c0a57611ba5600454600080600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610b1d90919063ffffffff16565b600080600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc3073ffffffffffffffffffffffffffffffffffffffff16319081150290604051600060405180830381858888f19350505050158015611c89573d6000803e3d6000fd5b505600a165627a7a723058205bbef016cc7699572f944871cb6f05e69915ada3a92a1d9f03a3fb434aac0c2b0029

รายละเอียดเพิ่มเติมเกี่ยวกับสัญญาอัจฉริยะสามารถพบได้ในบทความ: สัญญาอัจฉริยะใน Ethereum คืออะไร.

ข้อสรุป

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

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

อนาคตของ blockchain จะเป็นอย่างไร? ตอนนี้เราสามารถคาดเดาได้เฉพาะวิธีที่เป็นไปได้สำหรับการพัฒนาเทคโนโลยีบล็อคเชนเท่านั้น:

• บล็อกเชนจะกลายเป็นเทคโนโลยีฐานข้อมูลทั่วไปแบบเดียวกับ ตัวอย่างเช่น SQL หรือ NoSQL สำหรับการแก้ปัญหาเฉพาะด้าน
• บล็อกเชนจะกลายเป็นโปรโตคอลที่แพร่หลาย เหมือนกับที่ HTTP เป็นโปรโตคอลสำหรับอินเทอร์เน็ต
• Blockchain จะกลายเป็นพื้นฐานสำหรับระบบการเงินและการเมืองใหม่บนโลกนี้!

ในส่วนถัดไป เราจะดูว่าปัจจุบันมีบล็อกเชนใดบ้าง และเหตุใดจึงถูกนำมาใช้ในอุตสาหกรรมต่างๆ

นี่เป็นเพียงจุดเริ่มต้น!

ที่มา: will.com