บิตคอยน์: ระบบเงินสดอิเล็กทรอนิกส์แบบเพียร์ทูเพียร์

Abstract

ระบบเงินสดอิเล็กทรอนิกส์แบบ peer-to-peer อย่างแท้จริงจะช่วยให้การชำระเงินออนไลน์สามารถส่งตรงจากฝ่ายหนึ่งไปยังอีกฝ่ายหนึ่งโดยไม่ต้องผ่านสถาบันการเงิน ลายเซ็นดิจิทัลเป็นส่วนหนึ่งของคำตอบ แต่ประโยชน์หลักจะสูญเสียไปหากยังคงต้องการบุคคลที่สามที่เชื่อถือได้เพื่อป้องกัน double-spending เราเสนอวิธีแก้ปัญหา double-spending โดยใช้เครือข่าย peer-to-peer เครือข่ายประทับเวลาธุรกรรมโดยการ hash เข้าไปในห่วงโซ่ proof-of-work แบบต่อเนื่องที่ใช้ hash เป็นพื้นฐาน สร้างเป็นบันทึกที่ไม่สามารถเปลี่ยนแปลงได้โดยไม่ทำ proof-of-work ใหม่ ห่วงโซ่ที่ยาวที่สุดไม่เพียงทำหน้าที่เป็นหลักฐานของลำดับเหตุการณ์ที่ได้เห็น แต่ยังเป็นหลักฐานว่ามันมาจากกลุ่มพลังงาน CPU ที่ใหญ่ที่สุด ตราบใดที่พลังงาน CPU ส่วนใหญ่ถูกควบคุมโดย node ที่ไม่ร่วมมือกันโจมตีเครือข่าย พวกเขาจะสร้างห่วงโซ่ที่ยาวที่สุดและแซงหน้าผู้โจมตีได้ ตัวเครือข่ายเองต้องการโครงสร้างน้อยที่สุด ข้อความถูกประกาศแบบพยายามอย่างดีที่สุด และ node สามารถออกจากและกลับเข้าร่วมเครือข่ายได้ตามต้องการ โดยยอมรับห่วงโซ่ proof-of-work ที่ยาวที่สุดเป็นหลักฐานของสิ่งที่เกิดขึ้นขณะที่พวกเขาไม่อยู่

Introduction

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

สิ่งที่จำเป็นคือระบบการชำระเงินอิเล็กทรอนิกส์ที่อิงหลักฐานการเข้ารหัสแทนความไว้วางใจ ซึ่งอนุญาตให้สองฝ่ายที่เต็มใจทำธุรกรรมโดยตรงกับกันโดยไม่ต้องการบุคคลที่สามที่เชื่อถือได้ ธุรกรรมที่ไม่สามารถย้อนกลับได้ในทางคอมพิวเตอร์จะปกป้องผู้ขายจากการฉ้อโกง และกลไก escrow ตามปกติสามารถนำมาใช้ได้อย่างง่ายดายเพื่อปกป้องผู้ซื้อ ในบทความนี้ เราเสนอวิธีแก้ปัญหา double-spending โดยใช้เซิร์ฟเวอร์ประทับเวลาแบบกระจาย peer-to-peer เพื่อสร้างหลักฐานทางการคำนวณของลำดับเวลาของธุรกรรม ระบบจะปลอดภัยตราบใดที่ node ที่ซื่อสัตย์ร่วมกันควบคุมพลังงาน CPU มากกว่ากลุ่ม node ผู้โจมตีใดๆ ที่ร่วมมือกัน

Transactions

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

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

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

Timestamp Server

วิธีแก้ปัญหาที่เราเสนอเริ่มต้นด้วยเซิร์ฟเวอร์ประทับเวลา เซิร์ฟเวอร์ประทับเวลาทำงานโดยการนำ hash ของบล็อกรายการที่จะถูกประทับเวลาและเผยแพร่ hash อย่างกว้างขวาง เช่น ในหนังสือพิมพ์หรือโพสต์ Usenet [^2] [^3] [^4] [^5] การประทับเวลาพิสูจน์ว่าข้อมูลต้องมีอยู่ในเวลานั้น อย่างเห็นได้ชัด เพื่อที่จะเข้าไปใน hash ได้ แต่ละการประทับเวลารวมการประทับเวลาก่อนหน้าไว้ใน hash ของมัน สร้างเป็นห่วงโซ่ โดยแต่ละการประทับเวลาเพิ่มเติมจะเสริมความแข็งแกร่งให้กับการประทับเวลาก่อนหน้า

Proof-of-Work

ในการนำเซิร์ฟเวอร์ประทับเวลาแบบกระจายมาใช้บนพื้นฐาน peer-to-peer เราจะต้องใช้ระบบ proof-of-work ที่คล้ายกับ Hashcash ของ Adam Back [^6] แทนที่จะใช้หนังสือพิมพ์หรือโพสต์ Usenet proof-of-work เกี่ยวข้องกับการสแกนหาค่าที่เมื่อถูก hash เช่น ด้วย SHA-256 แล้ว hash จะเริ่มต้นด้วยจำนวนบิตศูนย์ที่กำหนด งานเฉลี่ยที่ต้องการจะเพิ่มขึ้นแบบเลขยกกำลังตามจำนวนบิตศูนย์ที่ต้องการ และสามารถตรวจสอบได้โดยการรัน hash เพียงครั้งเดียว

สำหรับเครือข่ายประทับเวลาของเรา เรานำ proof-of-work มาใช้โดยการเพิ่ม nonce ในบล็อกจนกว่าจะพบค่าที่ให้ hash ของบล็อกมีจำนวนบิตศูนย์ที่ต้องการ เมื่อใช้ความพยายามของ CPU ไปเพื่อให้ตรงตาม proof-of-work แล้ว บล็อกจะไม่สามารถเปลี่ยนแปลงได้โดยไม่ทำงานใหม่ เมื่อบล็อกถัดไปถูกเชื่อมต่อหลังจากมัน งานในการเปลี่ยนแปลงบล็อกจะรวมถึงการทำใหม่ทั้งหมดของบล็อกหลังจากมัน

Proof-of-work ยังแก้ปัญหาการกำหนดตัวแทนในการตัดสินใจแบบเสียงข้างมากด้วย หากเสียงข้างมากใช้พื้นฐานหนึ่ง-IP-หนึ่ง-เสียง มันสามารถถูกบ่อนทำลายโดยใครก็ตามที่สามารถจัดสรร IP จำนวนมากได้ Proof-of-work โดยพื้นฐานคือหนึ่ง-CPU-หนึ่ง-เสียง การตัดสินใจของเสียงข้างมากถูกแทนด้วยห่วงโซ่ที่ยาวที่สุด ซึ่งมีความพยายาม proof-of-work มากที่สุดที่ลงทุนไว้ หากพลังงาน CPU ส่วนใหญ่ถูกควบคุมโดย node ที่ซื่อสัตย์ ห่วงโซ่ที่ซื่อสัตย์จะเติบโตเร็วที่สุดและแซงหน้าห่วงโซ่คู่แข่งใดๆ ในการแก้ไขบล็อกในอดีต ผู้โจมตีจะต้องทำ proof-of-work ของบล็อกนั้นและบล็อกทั้งหมดหลังจากมันใหม่ แล้วจึงไล่ตามและแซงหน้างานของ node ที่ซื่อสัตย์ เราจะแสดงในภายหลังว่าความน่าจะเป็นที่ผู้โจมตีที่ช้ากว่าจะไล่ทันจะลดลงแบบเลขยกกำลังเมื่อบล็อกถัดไปถูกเพิ่มเข้ามา

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

Network

ขั้นตอนในการดำเนินเครือข่ายมีดังนี้:

1. ธุรกรรมใหม่ถูกประกาศไปยัง node ทั้งหมด
2. แต่ละ node รวบรวมธุรกรรมใหม่เข้าไปในบล็อก
3. แต่ละ node ทำงานเพื่อหา proof-of-work ที่ยากสำหรับบล็อกของตน
4. เมื่อ node หนึ่งพบ proof-of-work มันจะประกาศบล็อกไปยัง node ทั้งหมด
5. Node ยอมรับบล็อกเฉพาะเมื่อธุรกรรมทั้งหมดในนั้นถูกต้องและยังไม่ถูกใช้จ่าย
6. Node แสดงการยอมรับบล็อกโดยการทำงานสร้างบล็อกถัดไปในห่วงโซ่ โดยใช้ hash ของบล็อกที่ยอมรับเป็น hash ก่อนหน้า

Node จะถือว่าห่วงโซ่ที่ยาวที่สุดเป็นห่วงโซ่ที่ถูกต้องเสมอ และจะทำงานต่อไปเพื่อขยายมัน หากสอง node ประกาศเวอร์ชันที่แตกต่างกันของบล็อกถัดไปพร้อมกัน node บางตัวอาจได้รับเวอร์ชันหนึ่งหรืออีกเวอร์ชันก่อน ในกรณีนั้น พวกเขาทำงานบนเวอร์ชันที่ได้รับก่อน แต่บันทึกสาขาอื่นไว้ในกรณีที่มันยาวกว่า สถานการณ์เสมอกันจะถูกทำลายเมื่อ proof-of-work ถัดไปถูกพบและสาขาหนึ่งยาวกว่า node ที่ทำงานบนสาขาอื่นจะเปลี่ยนไปยังสาขาที่ยาวกว่า

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

Incentive

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

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

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

Reclaiming Disk Space

เมื่อธุรกรรมล่าสุดในเหรียญถูกฝังอยู่ใต้บล็อกจำนวนมากเพียงพอ ธุรกรรมที่ถูกใช้จ่ายก่อนหน้านั้นสามารถถูกทิ้งเพื่อประหยัดพื้นที่ดิสก์ เพื่ออำนวยความสะดวกในเรื่องนี้โดยไม่ทำลาย hash ของบล็อก ธุรกรรมถูก hash ใน Merkle Tree [^7] [^2] [^5] โดยมีเฉพาะ root เท่านั้นที่ถูกรวมไว้ใน hash ของบล็อก บล็อกเก่าสามารถถูกบีบอัดโดยการตัดกิ่งของต้นไม้ออก hash ภายในไม่จำเป็นต้องถูกจัดเก็บ

ส่วนหัวบล็อกที่ไม่มีธุรกรรมจะมีขนาดประมาณ 80 ไบต์ หากเราสมมติว่าบล็อกถูกสร้างทุก 10 นาที 80 ไบต์ * 6 * 24 * 365 = 4.2MB ต่อปี ด้วยระบบคอมพิวเตอร์ที่มักจะขายพร้อม RAM 2GB ณ ปี 2008 และกฎของมัวร์ที่คาดการณ์การเติบโตปัจจุบันที่ 1.2GB ต่อปี การจัดเก็บไม่ควรเป็นปัญหาแม้ว่าส่วนหัวบล็อกจะต้องถูกเก็บไว้ในหน่วยความจำ

Simplified Payment Verification

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

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

Combining and Splitting Value

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

ควรสังเกตว่า fan-out ที่ธุรกรรมขึ้นอยู่กับหลายธุรกรรม และธุรกรรมเหล่านั้นขึ้นอยู่กับอีกมากมาย ไม่ใช่ปัญหาที่นี่ ไม่จำเป็นต้องแยกสำเนาประวัติธุรกรรมที่สมบูรณ์แบบแยกต่างหาก

Privacy

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

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

Calculations

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

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

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

p = ความน่าจะเป็นที่ node ที่ซื่อสัตย์จะพบบล็อกถัดไป
q = ความน่าจะเป็นที่ผู้โจมตีจะพบบล็อกถัดไป
q = ความน่าจะเป็นที่ผู้โจมตีจะไล่ทันจาก z บล็อกที่ตามหลัง
``````

\[
qz =
\begin{cases}
1 & \text{if } p \leq q \\
\left(\frac{q}{p}\right) z & \text{if } p > q
\end{cases}
\]

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

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

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

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

\[
\lambda = z\frac{q}{p}
\]

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

\[
\sum_{k=0}^{\infty} \frac{\lambda^k e^{-\lambda}}{k!} \cdot \left\{
\begin{array}{cl}
\left(\frac{q}{p}\right)^{(z-k)} & \text{if } k \leq z \\
1 & \text{if } k > z
\end{array}
\right.
\]

จัดเรียงใหม่เพื่อหลีกเลี่ยงการรวมหางอนันต์ของการแจกแจง...

\[
1 - \sum_{k=0}^{z} \frac{\lambda^k e^{-\lambda}}{k!} \left(1-\left(\frac{q}{p}\right)^{(z-k)}\right)
\]

แปลงเป็นโค้ด C...

```c
#include math.h

double AttackerSuccessProbability(double q, int z)
{
    double p = 1.0 - q;
    double lambda = z * (q / p);
    double sum = 1.0;
    int i, k;
    for (k = 0; k = z; k++)
    {
        double poisson = exp(-lambda);
        for (i = 1; i = k; i++)
            poisson *= lambda / i;
        sum -= poisson * (1 - pow(q / p, z - k));
    }
    return sum;
}

เมื่อรันผลลัพธ์บางส่วน เราจะเห็นว่าความน่าจะเป็นลดลงแบบเลขยกกำลังตาม z

q=0.1
z=0 P=1.0000000
z=1 P=0.2045873
z=2 P=0.0509779
z=3 P=0.0131722
z=4 P=0.0034552
z=5 P=0.0009137
z=6 P=0.0002428
z=7 P=0.0000647
z=8 P=0.0000173
z=9 P=0.0000046
z=10 P=0.0000012

q=0.3
z=0 P=1.0000000
z=5 P=0.1773523
z=10 P=0.0416605
z=15 P=0.0101008
z=20 P=0.0024804
z=25 P=0.0006132
z=30 P=0.0001522
z=35 P=0.0000379
z=40 P=0.0000095
z=45 P=0.0000024
z=50 P=0.0000006

แก้สมการสำหรับ P น้อยกว่า 0.1%...

P  0.001
q=0.10 z=5
q=0.15 z=8
q=0.20 z=11
q=0.25 z=15
q=0.30 z=24
q=0.35 z=41
q=0.40 z=89
q=0.45 z=340

Conclusion

เราได้เสนอระบบสำหรับธุรกรรมอิเล็กทรอนิกส์โดยไม่ต้องพึ่งพาความไว้วางใจ เราเริ่มต้นด้วยกรอบการทำงานปกติของเหรียญที่สร้างจากลายเซ็นดิจิทัล ซึ่งให้การควบคุมความเป็นเจ้าของที่แข็งแกร่ง แต่ไม่สมบูรณ์หากไม่มีวิธีป้องกัน double-spending เพื่อแก้ปัญหานี้ เราเสนอเครือข่าย peer-to-peer ที่ใช้ proof-of-work เพื่อบันทึกประวัติสาธารณะของธุรกรรม ซึ่งกลายเป็นสิ่งที่ไม่สามารถทำได้ในทางคำนวณสำหรับผู้โจมตีที่จะเปลี่ยนแปลงอย่างรวดเร็ว หาก node ที่ซื่อสัตย์ควบคุมพลังงาน CPU ส่วนใหญ่ เครือข่ายมีความแข็งแกร่งในความเรียบง่ายที่ไม่มีโครงสร้าง Node ทำงานพร้อมกันทั้งหมดโดยมีการประสานงานเพียงเล็กน้อย พวกเขาไม่จำเป็นต้องถูกระบุตัวตน เนื่องจากข้อความไม่ได้ถูกส่งไปยังสถานที่ใดสถานที่หนึ่งโดยเฉพาะ และเพียงแค่ต้องถูกส่งมอบบนพื้นฐานความพยายามอย่างดีที่สุด Node สามารถออกจากและกลับเข้าร่วมเครือข่ายได้ตามต้องการ โดยยอมรับห่วงโซ่ proof-of-work เป็นหลักฐานของสิ่งที่เกิดขึ้นขณะที่พวกเขาไม่อยู่ พวกเขาลงคะแนนด้วยพลังงาน CPU ของพวกเขา แสดงการยอมรับบล็อกที่ถูกต้องโดยการทำงานขยายมัน และปฏิเสธบล็อกที่ไม่ถูกต้องโดยปฏิเสธที่จะทำงานบนมัน กฎและแรงจูงใจที่จำเป็นใดๆ สามารถบังคับใช้ด้วยกลไกฉันทามตินี้

References