สิ่งที่คุณต้องการ:
- ภูมิหลังของวิทยาการคอมพิวเตอร์
- พื้นฐานของ Ethereum
- พื้นฐานของแคลคูลัส (การเพิ่มประสิทธิภาพข้อจำกัด)
สิ่งที่คุณจะได้รับ:
- พื้นฐานของ SNARKs ที่ไม่มีความรู้
- พื้นฐานของต้นไม้ Merkle
- วิธีที่ Ethereum สามารถปรับขนาดเป็นธุรกรรมนับพันต่อวินาทีด้วย SNARKs
SNARKs อนุญาตให้ผู้พิสูจน์พิสูจน์ให้ผู้ตรวจสอบเห็นว่าเธอ/เขามีวิธีแก้ปัญหา W สำหรับปัญหา F ด้วยอินพุตที่ใช้ร่วมกัน/ที่ทราบ X โดยไม่เปิดเผย W
การค้นหาวิธีแก้ปัญหาอาจต้องใช้พลังในการคำนวณและหน่วยความจำจำนวนมาก
ดังนั้นโดยพื้นฐานแล้วผู้ตรวจสอบสามารถแน่ใจได้ 100% ว่าผู้พิสูจน์ทำงานอย่างถูกต้อง (และพบวิธีแก้ไข) โดยไม่ได้ทำงานใหม่ด้วยตัวเองเพื่อตรวจสอบวิธีแก้ปัญหาหรือไม่รู้วิธีแก้ปัญหาเลย มันวิเศษมาก!
กระบวนการนี้มี 3 ขั้นตอน:
- ติดตั้ง — ปัญหา F (ที่ต้องแสดงเป็นโปรแกรมเลขคณิตกำลังสอง ดูด้านล่าง) เตรียมไว้สำหรับ SNARK กระบวนการนี้มีหน่วยความจำสูงมากและใช้การประมวลผลสูง ขึ้นอยู่กับความซับซ้อนของปัญหา (→ จำนวนของอินพุตและข้อจำกัด → ขนาดของเมทริกซ์ของปัญหาความพึงพอใจจากข้อจำกัด) ผู้เล่นที่ทำการตั้งค่า (อาจเป็นตัวตรวจสอบเอง) จะต้องได้รับความไว้วางใจจากทุกฝ่าย เนื่องจากผลลัพธ์ของการตั้งค่าจะถูกใช้ในระยะต่อไป โดยปกติการตั้งค่าจะทำโดยใช้ ลิบส์นาร์กไลบรารี C++ ซึ่งเป็นการใช้งานที่ได้รับความนิยมมากที่สุดสำหรับ zkSNARK
- พิสูจน์ — The Prover ซึ่งมีวิธีแก้ปัญหา W สำหรับปัญหา F ที่มีอินพุตที่ใช้ร่วมกัน X (บางทีเธอ/เขา/เธออาจใช้ CPU และหน่วยความจำจำนวนมากเพื่อค้นหามัน!) ใช้ ลิบส์นาร์ก และผลลัพธ์ของ การติดตั้ง ขั้นตอนการสร้างหลักฐาน 𝚷. กระบวนการนี้ต้องใช้หน่วยความจำและการประมวลผลสูง (ขึ้นอยู่กับความซับซ้อนของปัญหาดังที่กล่าวไว้ข้างต้น) ขนาดของผลลัพธ์ (เช่น หลักฐาน 𝚷) นั้นกระชับและคงที่โดยไม่ขึ้นกับความซับซ้อนของปัญหา ผู้พิสูจน์ต้องเชื่อว่าใครเป็นผู้ทำขั้นตอนการตั้งค่า เนื่องจากเธอ/เขาใช้ผลลัพธ์...
- กำลังตรวจสอบ — A Verifier — ให้เป็นอินพุตเอาต์พุตของเฟส Setup, อินพุตที่ใช้ร่วมกัน X และ proof 𝚷 – ตรวจสอบการพิสูจน์ หากการตรวจสอบสำเร็จ ผู้พิสูจน์สามารถพิสูจน์ให้ผู้ตรวจสอบเห็นว่าเธอพบวิธีแก้ปัญหา W ต่อปัญหา F... โดยไม่เปิดเผย W! ส่วนที่ดีคือไม่เพียงแต่การพิสูจน์จะกระชับและมีความยาวเท่ากันเสมอ.. กระบวนการตรวจสอบนั้นรวดเร็วและไม่ใช้หน่วยความจำ/การคำนวณอย่างเข้มข้นเลย ต่างจากสองขั้นตอนก่อนหน้านี้… การยืนยันทำได้อย่างง่ายดายด้วยสมาร์ทโฟนในไม่กี่วินาที!
บทสรุปที่ดี (แหล่ง):
สิ่งนี้เกิดขึ้นได้อย่างไร? มันคือเวทมนตร์ของเมอร์ลิน! หากคุณต้องการได้รับคณิตศาสตร์เบื้องหลังสิ่งนี้ เริ่มต้นจากที่นี่.
ฉันจะแปลงซอฟต์แวร์ของฉันเป็นโปรแกรมเลขคณิตกำลังสองได้อย่างไร
ดังที่กล่าวไว้ข้างต้น ปัญหาของเฟสการตั้งค่า F ต้องเป็นโปรแกรมเลขคณิตกำลังสอง กฎของเกมนั้นยาก:
- อินพุตซอฟต์แวร์ของคุณควรเป็นตัวเลข แปลงข้อมูลของคุณ (อาร์เรย์ สตริง ฯลฯ) เป็นตัวเลข นั่นเป็นเรื่องเล็กน้อย
- “ระบบสมการที่มีข้อจำกัดกำลังสอง” หมายถึง:
โดยที่ x คือเวกเตอร์ n มิติของอินพุตของคุณ m คือจำนวนของข้อจำกัด (เช่น จำนวนสมการของระบบของคุณ) C คือสัมประสิทธิ์ n-by-n เมทริกซ์ และ q คือเวกเตอร์สัมประสิทธิ์ n มิติ หากคุณไม่ชอบเมทริกซ์และเวกเตอร์ นี่คือกรณี n = 3 และ m = 2 (อินพุต 3 รายการ 2 ข้อจำกัด):
- การดำเนินการเป็นวงจรเลขคณิตซึ่งหมายความว่าผลลัพธ์คือ แก้ไขปัญหา (แก้ระบบแล้ว คือ พหุนามทั้งหมดมีค่าเท่ากับ 0) หรือ แก้ปัญหาไม่ได้ (กรณีอื่นๆ ทั้งหมด) กล่าวอีกนัยหนึ่ง: “ปัจจัยการผลิตเหล่านี้/ไม่ใช่หนึ่งในวิธีแก้ไขปัญหานี้”
- C₁, C₂, …, C𝚖, q₁, q₂, …, q𝚖 สัมประสิทธิ์คือข้อจำกัดของระบบ นี่คือสิ่งที่กำหนดซอฟต์แวร์ของคุณโดยพื้นฐาน เปลี่ยนมัน... แล้วคุณจะได้ซอฟต์แวร์อื่น! ย้อนกลับไปยังวิธีการทำงานของ SNARK: C₁, C₂, …, C𝚖, q₁, q₂, …, q𝚖 เป็นอินพุตของเฟสการตั้งค่า ผลลัพธ์ของขั้นตอนการตั้งค่า (ที่คุณต้องการสำหรับการพิสูจน์และยืนยัน) จึงเกี่ยวข้องอย่างเคร่งครัดกับ C₁, C₂, …, C𝚖, q₁, q₂, …, q𝚖 และใช้ได้กับปัญหานั้นเท่านั้น หากคุณเปลี่ยนแปลง แสดงว่าคุณกำลังกำหนดซอฟต์แวร์/ปัญหาอื่น และคุณจำเป็นต้องเรียกใช้ขั้นตอนการตั้งค่าอีกครั้ง! x₁, x₂, …, x𝗇 เป็นตัวแปร (เช่น สิ่งที่คุณต้องเดาเพื่อให้ได้วิธีแก้ปัญหาของระบบ) ดังนั้นเมื่อเราพูดว่า “Dear Prover คุณช่วยกรุณาค้นหาวิธีแก้ปัญหาลับ W สำหรับปัญหา F ด้วยอินพุตที่ใช้ร่วมกัน/สาธารณะ X” เราหมายถึงเช่น “Dear Prover คุณสามารถหาค่า x₁, x₂, …, x𝗇 ที่แก้ปัญหาระบบได้หรือไม่ เช่น x₇ = 2393, x₅₂₆ = 5647?” คุณสามารถทำสิ่งที่คุณต้องการด้วย x𝗇 ทั้งหมด ยกเว้น x₇ และ x₅₂₆ ซึ่งจำกัดอยู่ที่อินพุตที่ใช้ร่วมกัน/สาธารณะ
มันเป็นชีวิตที่ยากลำบาก แต่คุณสามารถเอาชีวิตรอดได้… หากคุณต้องการลูป คุณสามารถเปิดลูปซ้ำได้หลายครั้ง หรือหากคุณต้องการ เช่น x₁⁴ x₂⁵ คุณต้องกำหนดอินพุตใหม่ x₃ = x₁⁴ x₂⁵ และใช้ x₃ ในข้อจำกัดของคุณ มันคือทั้งหมดที่เกี่ยวกับการเพิ่มตัวแปรและข้อจำกัด... แม้แต่ซอฟต์แวร์ที่ค่อนข้างธรรมดา ก็ยังสามารถเข้าถึงอินพุตและข้อจำกัดนับร้อยล้านหรือพันล้านได้อย่างง่ายดาย!
ต้องการทราบข้อมูลเพิ่มเติม? อ่าน โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม. และยังตรวจสอบพื้นฐานนี้ code_to_r1cs.py จาก ethereum/การวิจัย
ต้นไม้ Merkle คืออะไร?
ฟังก์ชันแฮชคือกฎที่แมปอินพุตของขนาดที่กำหนดเองกับเอาต์พุตที่มีขนาดคงที่ เราสามารถประดิษฐ์ฟังก์ชันแฮชที่ไร้ประโยชน์ "เชื่อมสองตัวแรกกับสองตัวอักษรสุดท้าย" ซึ่งเปลี่ยน "Woody Allen" เป็น "Woen" และ "Paul McCartney" เป็น "Paey"
Merkle tree เป็นโครงสร้างข้อมูลที่ผู้ปกครองทุกคนเป็นแฮชของลูกชายสองคน ที่ด้านบนสุด คุณจะพบรูท ซึ่งเป็นแฮชของลูกชายสองคนของระดับ 1 ที่ด้านล่าง ทุกลีฟคือแฮชของอินพุตภายนอก
การใช้ฟังก์ชันแฮช "Woody Allen" → "Woen" ในนิยายของเรา:
เมื่อใบไม้เปลี่ยน การดัดแปลงจะขยายไปถึงราก หาก ANTHONY เปลี่ยนไป ANNY (ใบไม้), CENY และ CECO (Root) ก็เปลี่ยนไปด้วย ใบไม้ใบไหนเปลี่ยน รากก็เปลี่ยนด้วย
คุณไม่จำเป็นต้องมีต้นไม้ทั้งต้นเพื่อคำนวณรากใหม่ ในตัวอย่างของเรา หากแอนโธนีเปลี่ยนแปลงและคุณรู้จักทั้ง JACO และ CECILY คุณจะสามารถคำนวณรูทใหม่ได้อย่างง่ายดาย แม้ว่าคุณจะเพิกเฉยต่อ JAMES, MARCO, JAES และ MACO โดยสิ้นเชิง ประหยัดเวลาได้มากสำหรับต้นไม้ใหญ่!
ดังนั้นสิ่งที่?
Merkle tree เหมาะสำหรับการตรวจสอบความสมบูรณ์ของข้อมูล โดยปกติ: คุณรู้ว่ารูทใดถูกต้อง และคุณตรวจสอบว่าข้อมูลที่ได้รับตรงกับรูทนั้นหรือไม่ ตัวอย่างเช่น: บุคคลที่น่าเชื่อถือซึ่งไม่สามารถให้ชุดข้อมูลทั้งหมดแก่คุณเกี่ยวกับชื่อแรกของผู้คนบนโลก (ไม่มีเวลา ไม่มีแบนด์วิดท์ หรือบางทีเธอ/เขาอาจไม่มีข้อมูลเลย) ให้คุณเพียงรูท (เช่น “ซีอีโค”). Afterwords: คุณได้รับชื่อนับล้านโดยอ้างอิงถึงหมายเลขลีฟโดยบุคคลที่ไม่น่าเชื่อถือหลายพันคน เนื่องจากคุณมีรูทที่ถูกต้อง คุณสามารถตรวจสอบได้ว่าใครที่คุณไว้ใจได้ ใครเป็นผู้ให้ข้อมูลปลอมแก่คุณ...
ต้นไม้ Merkle ก็เป็นส่วนหนึ่งของชีวิตคุณเช่นกัน! เมื่อคุณดาวน์โหลดไฟล์ Torrent ขนาด 3GB ไฟล์ของคุณจะถูกแบ่งออกเป็นส่วนย่อยๆ นับล้าน แฮชของทุกอันจะถูกเก็บไว้ในใบไม้ เนื่องจากคุณรู้ว่ารูทใดเป็นรูทของแผนผังที่ถูกต้อง ทุกครั้งที่คุณได้รับไฟล์จากใครซักคน คุณสามารถตรวจสอบได้ว่าไฟล์นั้นถูกต้องหรือไม่ ถ้าไม่ใช่ คุณสามารถขอส่วนเดียวกันนี้กับคนอื่นได้
คุณสามารถทำเช่นนั้นได้แม้ว่าคุณจะยังไม่ได้ดาวน์โหลดต้นไม้ทั้งหมด/ใบไม้ทั้งหมด ถ้าคุณรู้ว่ารูทคือ CECO และคุณไว้วางใจ JACO… เมื่อคุณได้รับก้อน ANTHONY คุณสามารถตรวจสอบได้แม้ว่าคุณจะไม่ได้ดาวน์โหลด ทว่าชิ้นส่วนของ MARCO และ JAMES
เหตุใด Merkle tree จึงมีประโยชน์ในเทคโนโลยีบัญชีแยกประเภทแบบกระจายอย่างตรงไปตรงมา: คุณใช้โปรโตคอลที่เป็นเอกฉันท์ (ช้าและมีราคาแพง) เพื่อเข้าถึงฉันทามติบนรูทเท่านั้น จากนั้นโหนดที่ไม่น่าเชื่อถือของเครือข่ายสามารถแบ่งปันข้อมูลได้อย่างมีประสิทธิภาพและโดยตรง… และสามารถนอนหลับได้อย่างปลอดภัยและมีเสียงด้วยการตรวจสอบความสมบูรณ์ด้วยรูท
เมื่อพระเจ้าขอให้ Ethereum เลือก 2 มหาอำนาจระหว่างความปลอดภัย ความสามารถในการขยายและการกระจายอำนาจ… Ethereum เสียสละ Scalability อันที่จริง ไม่มีขีดจำกัดที่ชัดเจนใน "ธุรกรรมต่อวินาที": ขีดจำกัดเกี่ยวข้องกับปริมาณก๊าซของแต่ละบล็อก ซึ่งก็คือการลดความซับซ้อนของจำนวนการดำเนินการที่ฉันสามารถทำได้ในแต่ละบล็อก ขีดจำกัดนี้คือ 8 ล้านแก๊ส นั่นอาจหมายถึงธุรกรรม "เล็ก" จำนวนมาก (ไม่มีข้อมูลแนบกับธุรกรรม ไม่มีการดำเนินการกับข้อมูลนั้น) หรือธุรกรรมขนาดใหญ่เพียงไม่กี่รายการ ขึ้นอยู่กับโหนดของ Ethereum ซึ่งส่งธุรกรรม และสำหรับผู้ขุดของ Ethereum ที่รวมในบล็อกธุรกรรมที่จ่ายมากกว่า
บล็อกถูกขุด ทุกๆ ~15 วินาที นั่นหมายถึง 32 ล้านแก๊สต่อนาที ซึ่งไม่เพียงพอแน่นอนหากเราต้องการให้ DApp ของ Ethereum กลายเป็นกระแสหลัก
โดยวิธีการ: หยุดการเปรียบเทียบที่น่าเบื่อระหว่าง Ethereum และ Visa ระบบส่วนกลางจะ เสมอ เร็วกว่า Ethereum… ด้วยการออกแบบ! พวกเขาทำสิ่งต่าง ๆ และคุณต้องการพวกเขาในสถานการณ์ที่แตกต่างกัน หากคุณไม่ต้องการการกระจายอำนาจและสภาพแวดล้อมที่ไม่ไว้วางใจ... คุณควรเลือก Visa ในระยะสั้น: การที่เครื่องปั่นหมุนได้เร็วกว่าเครื่องซักผ้าไม่ได้หมายความว่าคุณจะทำความสะอาดกางเกงในเครื่องปั่น!
มาไขปริศนากัน! ลองนึกภาพว่าคุณสามารถ "บีบอัด" ธุรกรรมเล็กๆ จำนวนมากในธุรกรรมขนาดใหญ่เพียงรายการเดียวได้ ต้องขอบคุณ SNARK หากก๊าซที่ใช้ไปในการทำธุรกรรมขนาดใหญ่นี้มีค่าน้อยกว่าผลรวมของก๊าซที่ใช้ไปในการทำธุรกรรมเล็กๆ น้อยๆ นั่นหมายความว่าคุณกำลังประหยัดน้ำมัน
และการประหยัดน้ำมันหมายถึง:
- ผู้ใช้ใช้จ่ายน้อยลงสำหรับการทำธุรกรรมโดยรวม → นี่จะเป็นการผลักดันสำหรับระบบนิเวศทั้งหมด
- ความสามารถในการใส่สิ่งของในบล็อกได้มากขึ้น → Ethereum หมุนเร็วกว่าเครื่องปั่นของคุณ!
มันทำงานอย่างไร?
มีผู้ใช้ ผู้ส่งต่อ (หรือผู้ส่งต่อมากกว่า) ที่รวบรวมธุรกรรมและสัญญาอัจฉริยะ
- ผู้ใช้ที่ยินดีเล่นเกมนี้จะส่ง Ether (หรือโทเค็น) ไปยังสัญญาอัจฉริยะที่ตรวจสอบโดยสาธารณะ สำหรับผู้เล่นใหม่ทุกคน ใบไม้ใหม่ในแผนภูมิ Merkle จะถูกสร้างขึ้น ลีฟประกอบด้วยข้อมูลเกี่ยวกับเจ้าของอีเธอร์ (ที่อยู่ของเธอ/ของเขา ซึ่งเป็นกุญแจสาธารณะด้วย) จำนวนอีเธอร์และ nonce (ตัวนับธุรกรรมของบัญชีนั้น ซึ่งเท่ากับ 0 เมื่อมีการเพิ่มลีฟ)
- เมื่อ A ต้องการส่ง Ether ไปยัง B (ทั้งคู่จำเป็นต้องมีใบ/บัญชีในสัญญาอัจฉริยะ) A จะแพ็คธุรกรรม ซึ่งรวมถึงที่อยู่ของ ราคาเริ่มต้นที่บัญชี ไปยัง บัญชี เอกอัครสมณทูต ของจากบัญชี the จำนวน ของอีเธอร์ที่จะโอนและ ลายเซ็น ของการทำธุรกรรม (ลงนามด้วยรหัสส่วนตัวของบัญชี "จาก" อย่างชัดเจน) จากนั้นเธอก็ส่งธุรกรรมที่บรรจุไปยังผู้ส่งต่อ
- ผู้ส่งต่อจะรวบรวมธุรกรรมทั้งหมดที่ได้รับในช่วงเวลาที่กำหนด (เช่น หนึ่งชั่วโมง) อัปเดตแผนภูมิ Merkle ด้วยยอดดุลใหม่ และสร้างหลักฐาน SNARK ซึ่งพิสูจน์ว่าลายเซ็นทั้งหมดและรูทของ Merkle tree ใหม่นั้นถูกต้อง ในที่สุดผู้ถ่ายทอดจะส่งสถานะใหม่และหลักฐานไปยังสัญญาอัจฉริยะ
- สัญญาอัจฉริยะตรวจสอบ Proof on-chain หากถูกต้อง ระบบจะบันทึก Merkle tree root ของสถานะใหม่ไว้ในหน่วยความจำภายในของสัญญา
โดยพื้นฐานแล้ว รากของต้นไม้ Merkle แสดงถึงสถานะทั้งหมดของบัญชีทั้งหมด และคุณไม่สามารถเปลี่ยนแปลงได้ (= ขโมยเงิน) เว้นแต่คุณจะสามารถพิสูจน์ความถูกต้องของลายเซ็นที่มีการทำธุรกรรมนำไปสู่สถานะใหม่ที่สรุปโดยรูทใหม่ที่คุณกำลังส่ง
สรุป: ผู้ใช้มีธุรกรรมที่รวดเร็วและเกือบจะฟรีมาก เช่นบน Coinbase โดยไม่จำเป็นต้องเชื่อถือผู้ส่งต่อ ซึ่งไม่สามารถทำอะไรได้ ต่างจาก Coinbase หากไม่มีลายเซ็นของคุณ
เป็นห่วงโซ่ด้านที่ไม่ใช่การดูแลซึ่งรัฐสรุปโดยรากของต้น Merkle
มาเชื่อมโยงสิ่งที่เราเรียนรู้ข้างต้นเกี่ยวกับ SNARK กับสิ่งที่เราเพิ่งพูดถึงเกี่ยวกับการปรับขนาด มีหลายวิธีในการทำเช่นนั้น เปรียบเทียบ 2 สูตร: Vitalik's รุ่น และ barryWhiteHat's รุ่น.
SETUP ทำได้โดย...
คนที่เริ่มโปรเจ็กต์ ผู้สร้างสัญญาอัจฉริยะด้วย ยิ่งตรวจสอบได้ยิ่งดี คุณควรเชื่อใจเธอ/เขา… มันคือ การตั้งค่าที่เชื่อถือได้!
สัญญาอัจฉริยะช่วยประหยัด...
2 Merkle root (ค่าไบต์ 32): ทรีแรกมีที่อยู่ของบัญชี (ลายเซ็นสาธารณะ) ยอดคงเหลือและ nonces ของบัญชีที่สอง
การพิสูจน์ทำได้โดย...
รีเลย์
รีเลย์ส่งไปยังสัญญาอัจฉริยะ...
- ราก Merkle 2 แห่งของรัฐใหม่ (กล่าวถึงต้นไม้และยอดคงเหลือ + ต้นไม้ nonces)
- รายการธุรกรรมที่ไม่มีลายเซ็น “แต่ละรายการมีค่าใช้จ่าย 68 ก๊าซต่อไบต์ ดังนั้น สำหรับการโอนปกติ เราคาดว่าต้นทุนส่วนเพิ่มจะเท่ากับ 68 * 3 (จาก) + 68 * 3 (เป็น) + 68 * 1 (ค่าธรรมเนียม) + 68 * 4 + 4 * 2 (จำนวนเงิน) + 68 * 2 (nonce) หรือ 892 แก๊ส”
อินพุตที่ทราบของกระบวนการพิสูจน์แล้วคือ...
- 2 รัฐเก่า Merkle ราก
- 2 รัฐใหม่ Merkle root
- รายการธุรกรรม
กระบวนการพิสูจน์พิสูจน์ว่า...
ให้
- ราก Merkle 2 สถานะเก่า (เก็บไว้ในสัญญาแล้ว)
- ราก Merkle ใหม่ 2 สถานะ (ส่งในธุรกรรม agr)
- รายการธุรกรรม (ส่งในธุรกรรม aggr)
… ผู้ถ่ายทอดมีลายเซ็นที่ถูกต้องเพื่อย้ายจากสถานะด้วย 2 รูทเก่าไปยังสถานะด้วย 2 รูทใหม่กับธุรกรรมเหล่านั้น
การยืนยันทำได้โดย...
สัญญาที่ชาญฉลาด (เข้ารหัสในความแข็งแกร่ง, vyper ตามที่คุณต้องการ!)
การตรวจสอบอินพุตที่ทราบของกระบวนการคือ...
กระบวนการพิสูจน์เดียวกันรู้อินพุตชัดเจน…!
ข้อจำกัดในการขยายขนาด
ทุกธุรกรรมรวมใช้ก๊าซ 650k สำหรับการตรวจสอบ SNARK (ต้นทุนคงที่) บวก ~ 900 แก๊สของ ต้นทุนส่วนเพิ่ม ต่อธุรกรรม (ค่าใช้จ่ายในการส่งข้อมูล!) ดังนั้นการใช้ทั้งบล็อก รีเลย์สามารถรวมได้มากที่สุด:
ซึ่งหมายความว่า ~544 tx ต่อวินาที
barryWhiteHat's รุ่น
SETUP ทำได้โดย...
คนที่เริ่มโครงการ
สัญญาอัจฉริยะช่วยประหยัด...
1 Merkle root กับสถานะปัจจุบัน ทุกใบเป็นสถานะที่แฮชของบัญชี
ต้องการที่จะ สร้าง บัญชี?
state = AccountState (pubkey, ยอดคงเหลือ, nonce)
state.index = self._tree.append(state.hash())
การพิสูจน์ทำได้โดย...
รีเลย์
รีเลย์ส่งไปยังสัญญาอัจฉริยะ...
- หลักฐาน 𝚷
- สถานะใหม่ Merkle root
- หลักฐาน 𝚷
อินพุตที่ทราบของกระบวนการพิสูจน์แล้วคือ...
- รัฐเก่า Merkle root
- สถานะใหม่ Merkle root
กระบวนการพิสูจน์พิสูจน์ว่า...
ให้
- Old Merkle root (เก็บไว้ในสัญญาแล้ว)
- รูท Merkle ใหม่ (senti ในธุรกรรม agr.)
… ผู้ถ่ายทอดมีรายการธุรกรรมที่มีลายเซ็นที่ถูกต้องเพื่อย้ายจากสถานะด้วยรูทเก่าไปยังสถานะด้วยรูทใหม่
การยืนยันทำได้โดย...
สัญญาที่ชาญฉลาด (เข้ารหัสในความแข็งแกร่ง, vyper ตามที่คุณต้องการ!)
การตรวจสอบอินพุตที่ทราบของกระบวนการคือ...
กระบวนการพิสูจน์เดียวกันรู้อินพุตชัดเจน…!
ข้อจำกัดในการขยายขนาด
ผู้ถ่ายทอดไม่ได้ส่งข้อมูลของธุรกรรมไปยังสัญญาอัจฉริยะ (ซึ่งมีค่าใช้จ่ายสูง) ดังนั้น ขีด จำกัด จึงเป็นปริมาณก๊าซจริงในการตรวจสอบหลักฐาน SNARK
กล่าวถึง Howard Wu's งาน เกี่ยวกับการรันเฟส PROVING ของ SNARK บนระบบแบบกระจาย barryWhiteHat มองโลกในแง่ดี ระบุว่าเป็นไปได้ที่จะยืนยันธุรกรรม 16666 ใน SNARK ขนาดใหญ่ (ข้อจำกัด 1 พันล้าน!)
barryWhiteHat ด้วย คิดว่า เป็นไปได้ที่จะตรวจสอบการพิสูจน์ 𝚷 on-chain ด้วยน้ำมัน 500k ซึ่งหมายความว่าคุณสามารถใส่ 16 SNARK (8 ล้าน/500k) ต่อบล็อก ซึ่งก็คือ ~1.07 SNARKs ต่อวินาที… ซึ่งหมายถึง ~17,832 tx ต่อวินาที (16,666*1.07).
สู่ความเวิ้งว้างอันไกลโพ้น
- ทุกสิ่งที่เปล่งประกายไม่ใช่สีทอง / 1 ปริมาณพลังประมวลผลและหน่วยความจำที่คุณต้องการในระยะการพิสูจน์อาจทำให้คุณตกตะลึงได้อย่างแท้จริง โดยเฉพาะอย่างยิ่งในเวอร์ชันของ barryWhiteHat ซึ่งส่วนหนึ่งของความซับซ้อนถูกย้ายออกจากห่วงโซ่ แบร์รี่เขียน “ในแล็ปท็อปที่มี ram 7 GB และพื้นที่สว็อป 20 GB มันมีปัญหาในการรวม 20 ธุรกรรมต่อวินาที”. ถ้าเป้าหมายคือ 17,832 tx ต่อวินาที… LOL สิ่งนี้แนะนำความท้าทายในการคำนวณแบบขนานที่ไม่สำคัญ แต่ถ้าต้นทุนเฉลี่ย $ ต่อการทำธุรกรรมนั้นถูกกว่าตัวเลือกที่ไม่มี SNARK ทั่วไปมาก… เกมนั้นก็คุ้มค่ากับเทียนไข
- สิ่งที่แวววาวไม่ใช่ทอง / 2 มีปัญหาเกี่ยวกับความพร้อมของข้อมูลที่เกี่ยวข้อง! เนื่องจากมีเพียงรูทของทรีเท่านั้นที่บันทึกไว้ในสัญญา คุณต้องแน่ใจว่าเวอร์ชันทั้งหมดของทรี (หรือ ประวัติการทำธุรกรรมทั้งหมดจะเหมือนกัน) อยู่เสมอ หากข้อมูลไม่พร้อมใช้งาน ผู้ส่งต่อ แม้จะมีธุรกรรมที่ลงนามอย่างถูกต้องแล้ว ก็ไม่สามารถทำอะไรได้เพราะเธอ/เขาไม่สามารถพิสูจน์สถานะเก่า → ธุรกรรม → สถานะใหม่
- เพื่อให้รีเลย์ไม่น่าเชื่อถือและ Ethers ในสัญญามีค่าเท่ากับ Ethers ภายนอก (ปัญหาสภาพคล่อง)... ผู้ใช้ควรสามารถถอนเงินจากสัญญาอัจฉริยะได้เมื่อต้องการโดยไม่ต้องพึ่งพาตัวส่งต่อ (เฉพาะ) ยังไง? ไม่อยู่ในขอบเขตของโพสต์ 101 นี้ แต่คุณสามารถอ่านเกี่ยวกับเรื่องนี้ได้ในลิงก์ที่แนบมา
- ต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับวิธีการจัดการกับสถานะปัจจุบัน (ที่อยู่ ยอดคงเหลือ และ nonces) ด้วยต้นไม้ Merkle หรือไม่ เพิ่มใบ ปรับปรุงใบ ฯลฯ ? เช็คเอาท์ ห้องสมุดนี้ (ไฟล์ทดสอบ โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม) ซึ่งใช้พื้นฐานนี้ โมดูล. ขอบคุณ HarryR!
- ต้องการตั้งค่าสภาพแวดล้อม Ethereum-SNARK ส่วนตัวของคุณหรือไม่? เริ่มต้นนอกสายโซ่ด้วย C++ (ตั้งค่า พิสูจน์ ยืนยัน) โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม. จากนั้นคุณสามารถย้ายไปที่ Ethereum ได้ (อย่าลืมว่าการตรวจสอบเท่านั้นที่ทำบนเชน!) ด้วย Zokrates (repoที่ เอกสารในการเริ่มต้นใช้งาน).
- แล้วการใช้ RSA accumulators แทน Merkle tree ล่ะ? Google “rsa accumulators อีเธอเรียม” เริ่ม…
สนุก!
Twitter @marco_derossi ครับ
- 7
- ลงชื่อเข้าใช้
- ทั้งหมด
- ในหมู่
- ความพร้อมใช้งาน
- ข้อมูลพื้นฐานเกี่ยวกับ
- พันล้าน
- กรณี
- เปลี่ยนแปลง
- การตรวจสอบ
- coinbase
- การคำนวณ
- เอกฉันท์
- สัญญา
- ค่าใช้จ่าย
- ปัจจุบัน
- สถานะปัจจุบัน
- DApps
- ข้อมูล
- ชุดข้อมูล
- การกระจายอำนาจ
- Dimension
- บัญชีแยกประเภทกระจาย
- เทคโนโลยีบัญชีแยกประเภท
- สิ่งแวดล้อม
- อีเทอร์
- ethereum
- EU
- EV
- เทียม
- ในที่สุด
- ชื่อจริง
- ฟรี
- ฟังก์ชัน
- เกม
- GAS
- GitHub
- ให้
- ทองคำ
- ดี
- ยิ่งใหญ่
- ให้คำแนะนำ
- กัญชา
- โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม
- จุดสูง
- ประวัติ
- สรุป ความน่าเชื่อถือของ Olymp Trade?
- hr
- HTTPS
- ใหญ่
- ร้อย
- ia
- ดัชนี
- ข้อมูล
- IP
- IT
- การสัมภาษณ์
- คีย์
- แล็ปท็อป
- ใหญ่
- นำ
- บัญชีแยกประเภท
- ชั้น
- LG
- ห้องสมุด
- สภาพคล่อง
- รายการ
- หลัก
- แผนที่
- กลาง
- ล้าน
- คนงานเหมือง
- เงิน
- เดือน
- เป็นที่นิยม
- ย้าย
- ชื่อ
- เครือข่าย
- โหนด
- ตัวเลข
- การดำเนินการ
- ใบสั่ง
- อื่นๆ
- เจ้าของ
- ชำระ
- รูปแบบไฟล์ PDF
- คน
- ผู้เล่น
- ยอดนิยม
- อำนาจ
- ส่วนตัว
- คีย์ส่วนตัว
- โครงการ
- โครงการ
- พิสูจน์
- พิสูจน์
- สาธารณะ
- คีย์สาธารณะ
- ปะยางรถ
- อาร์เอส
- กฎระเบียบ
- วิ่ง
- ปลอดภัย
- ประหยัด
- scalability
- ขนาด
- ปรับ
- วิทยาศาสตร์
- ความปลอดภัย
- ชุด
- Share
- ที่ใช้ร่วมกัน
- สั้น
- ง่าย
- ขนาด
- นอนหลับ
- สมาร์ท
- สัญญาสมาร์ท
- มาร์ทโฟน
- So
- ซอฟต์แวร์
- ความแข็งแรง
- โซลูชัน
- แก้
- ช่องว่าง
- การใช้จ่าย
- เริ่มต้น
- ข้อความที่เริ่ม
- สถานะ
- สหรัฐอเมริกา
- ที่ประสบความสำเร็จ
- ระบบ
- ระบบ
- เทคโนโลยี
- ทดสอบ
- เวลา
- ราชสกุล
- ด้านบน
- ฝนตกหนัก
- การทำธุกรรม
- การทำธุรกรรม
- วางใจ
- การปรับปรุง
- ผู้ใช้
- ความคุ้มค่า
- การตรวจสอบ
- วีซ่า
- W
- WHO
- คำ
- งาน
- โรงงาน
- คุ้มค่า
- X