การแนะนำ
การแนะนำ
การพิสูจน์ความรู้เป็นศูนย์เป็นเทคนิคสำคัญในวิทยาการเข้ารหัสลับที่ช่วยให้บุคคลหนึ่งสามารถพิสูจน์ให้อีกคนหนึ่งพิสูจน์ได้ว่าข้อความนั้นเป็นจริงโดยไม่ต้องเปิดเผยข้อมูลอื่นใด เทคโนโลยีนี้มีแอปพลิเคชันที่หลากหลายในหลายสาขา รวมถึงการตรวจสอบสิทธิ์ บล็อกเชน และการประมวลผลที่ปลอดภัย และอื่นๆ อีกมากมาย Nova คือระบบพิสูจน์ความรู้แบบศูนย์ใหม่ที่พัฒนาโดย Microsoft ซึ่งใช้เทคนิคที่เรียกว่า Relaxed Rank-1 Constraint Systems (Relaxed R 1 CS) เพื่อปรับปรุงประสิทธิภาพและความยืดหยุ่นของการพิสูจน์ บทสุดท้ายจะอธิบายซอร์สโค้ดโดยละเอียด
ข้อดีของโนวา
ข้อได้เปรียบหลักของ Nova คือเทคนิค R1CS แบบผ่อนคลายที่ใช้ R1CS เป็นระบบสำหรับสร้างการพิสูจน์ความรู้เป็นศูนย์ ซึ่งสามารถใช้เพื่อพิสูจน์ว่ารู้คำตอบของชุดสมการพหุนามโดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับคำตอบ อย่างไรก็ตาม ระบบ R1CS แบบเดิมจำเป็นต้องใช้การสุ่มจำนวนมากในกระบวนการพิสูจน์ ซึ่งทำให้กระบวนการสร้างและการตรวจสอบพิสูจน์มีความซับซ้อนและใช้เวลานานมาก Nova แก้ปัญหานี้โดยใช้ R1CS แบบผ่อนคลาย ซึ่งช่วยให้มีการใช้การสุ่มน้อยลงในการพิสูจน์ ซึ่งช่วยปรับปรุงประสิทธิภาพของการพิสูจน์ได้อย่างมาก
Nova ยังมีข้อดีอื่นๆ อีกด้วย ตัวอย่างเช่น รองรับการคำนวณแบบเพิ่มหน่วย ซึ่งหมายความว่าสามารถคำนวณฟังก์ชันที่ซับซ้อนได้ทีละขั้นตอน แทนที่จะคำนวณฟังก์ชันทั้งหมดพร้อมกัน สิ่งนี้มีประโยชน์มากเมื่อต้องจัดการกับข้อมูลขนาดใหญ่หรือทำการคำนวณที่ซับซ้อน นอกจากนี้ Nova ยังสนับสนุนการคำนวณพหุนาม ซึ่งช่วยให้สามารถจัดการงานพิสูจน์อักษรที่ซับซ้อนมากขึ้นได้
ข้อเสียของโนวา
แม้ว่า Nova จะมีข้อดีหลายประการ แต่ก็มีข้อเสียอยู่บ้างเช่นกัน ประการแรก เนื่องจาก Nova ใช้ R1CS แบบผ่อนคลาย การพิสูจน์ของมันอาจไม่แข็งแกร่งเท่ากับระบบ R1CS แบบดั้งเดิม เนื่องจาก R1CS แบบผ่อนคลายช่วยให้มีการใช้การสุ่มน้อยลงในการพิสูจน์ ซึ่งอาจลดความปลอดภัยของการพิสูจน์ อย่างไรก็ตาม ผู้พัฒนา Nova ได้ดำเนินการบางอย่างเพื่อแก้ไขปัญหานี้ เช่น การใช้อัลกอริธึมการเข้ารหัสที่แข็งแกร่งขึ้น และกลยุทธ์การพิสูจน์ที่ซับซ้อนมากขึ้น
ประการที่สอง การใช้งาน Nova ค่อนข้างซับซ้อน ซึ่งอาจเพิ่มความยากในการใช้งานและการบำรุงรักษา Nova ใช้เทคนิคการเข้ารหัสขั้นสูงมากมาย เช่น การคำนวณพหุนาม การดำเนินการกลุ่ม และ oracles แบบสุ่ม ซึ่งต้องใช้ความเข้าใจอย่างลึกซึ้งเกี่ยวกับเทคนิคเหล่านี้เพื่อใช้และแก้ไข Nova ได้อย่างมีประสิทธิภาพ
ตำแหน่งที่สำคัญของโนวาในด้านการพิสูจน์ความรู้เป็นศูนย์
Nova ครองตำแหน่งสำคัญในด้านการพิสูจน์ความรู้แบบศูนย์ การปรากฏตัวของมันได้เปิดเส้นทางใหม่สำหรับการพัฒนาการพิสูจน์ความรู้เป็นศูนย์ เทคโนโลยี R1CS แบบผ่อนคลายที่ Nova นำมาใช้ทำให้การสร้างการพิสูจน์และกระบวนการตรวจสอบมีประสิทธิภาพมากขึ้น ซึ่งเป็นสิ่งสำคัญสำหรับแอปพลิเคชันการพิสูจน์ความรู้เป็นศูนย์ในวงกว้าง นอกจากนี้ Nova ยังสนับสนุนการประมวลผลแบบเพิ่มหน่วยและการคำนวณแบบพหุนาม ซึ่งช่วยให้สามารถจัดการกับงานพิสูจน์อักษรที่ซับซ้อนมากขึ้น และขยายขอบเขตการใช้งานของการพิสูจน์ความรู้แบบศูนย์เพิ่มเติมอีกด้วย
https://github.com/microsoft/Nova
การตีความซอร์สโค้ดของ Nova
ภายใต้ไดเร็กทอรี src/ มีไดเร็กทอรีย่อยที่สำคัญหลายรายการ:
bellperson/: ไดเร็กทอรีนี้อาจมีโค้ดสำหรับอัลกอริทึมของ Bellman-Ford
Gadgets/: ไดเร็กทอรีนี้อาจมีเครื่องมือบางอย่างสำหรับสร้างหลักฐาน zk-SNARK
ผู้ให้บริการ/: ไดเร็กทอรีนี้อาจมีรหัสผู้ให้บริการบางส่วน เช่น keccak.rs อาจเป็นรหัสสำหรับใช้งานฟังก์ชันแฮชของ Keccak
ลักษณะ/: ไดเร็กทอรีนี้อาจมีลักษณะเฉพาะของ Rust ซึ่งใช้เพื่อกำหนดลักษณะการทำงานทั่วไปบางอย่าง
ชื่อรอง
เนื้อหาของไฟล์ src/bellperson/mod.rs:
โมดูลนี้ใช้เพื่อสร้าง R1CS เป็นหลัก (Rank-1 Constraint Systems ซึ่งเป็นระบบข้อจำกัดสำหรับ zk-SNARK)
ประกอบด้วยสามโมดูลย่อย:
r1cs: โมดูลนี้อาจมีรหัสสำหรับ R1CS
shape_cs: โมดูลนี้อาจมีโค้ดสำหรับระบบจำกัดรูปร่าง
ในส่วนการทดสอบ จะกำหนดฟังก์ชัน synthesize_alloc_bit ที่รับระบบข้อจำกัด จากนั้นเพิ่มข้อจำกัดบางอย่างเพื่อตรวจสอบว่าอินพุตบิตทั้งสองนั้นเป็นบิตจริงหรือไม่ จากนั้นจะกำหนดฟังก์ชัน test_alloc_bit_with ซึ่งจะสร้างรูปร่างขึ้นมาก่อน
ชื่อรอง
เนื้อหาของไฟล์ src/bellperson/r 1 cs.rs:
ไฟล์นี้กำหนดลักษณะสองประการเป็นหลัก: `NovaWitness` และ `NovaShape` ซึ่งให้วิธีการรับ `R 1 CSInstance` และ `R 1 CSWitness` ตามลำดับ และ `R 1 CSShape` และ `CommitmentKey` จากตัวดำเนินการ
- ลักษณะ `NovaWitness` มีเมธอด `r1cs_instance_and_witness` ซึ่งรับ `R 1 CSShape` และ `CommitmentKey` และส่งคืน `R 1 CSInstance` และ `R 1 CSWitness` ลักษณะนี้ถูกนำมาใช้สำหรับโครงสร้าง `SatisfyingAssignment` ซึ่งหมายความว่า `SatisfyingAssignment` ใดๆ สามารถใช้วิธีนี้เพื่อรับ `R 1 CSInstance` และ `R 1 CSWitness`
- คุณลักษณะ `NovaShape` มีเมธอด `r 1 cs_shape` ซึ่งส่งคืน `R 1 CSSShape` และ `CommitmentKey` ลักษณะนี้ถูกนำมาใช้กับโครงสร้าง `ShapeCS` ซึ่งหมายความว่า `ShapeCS` ใดๆ สามารถใช้วิธีนี้เพื่อรับ `R 1 CSSShape` และ `CommitmentKey`
โดยทั่วไป วัตถุประสงค์หลักของไฟล์นี้คือเพื่อให้มีวิธีในการสร้างอินสแตนซ์ พยาน รูปร่าง และความลับของความมุ่งมั่นของ R 1 CS จากระบบ (เช่น `SatisfyingAssignment` หรือ `ShapeCS`) ที่ตรงตามเงื่อนไขบางประการ
src/bellperson/shape_cs.rs
ชื่อรอง
ไฟล์นี้กำหนดโครงสร้างชื่อ `ShapeCS` ซึ่งใช้ลักษณะ `ConstraintSystem` `ShapeCS` เป็นระบบข้อจำกัดสำหรับการสร้างรูปร่าง R 1 CS
โครงสร้าง `ShapeCS` มีฟิลด์ต่อไปนี้:
- `named_objects`: นี่คือแผนที่ที่เก็บวัตถุที่เกี่ยวข้องกับเส้นทาง
- `current_namespace`: นี่คือเวกเตอร์สตริงที่ใช้จัดเก็บเนมสเปซปัจจุบัน
- `ข้อจำกัด`: นี่คือเวกเตอร์สำหรับจัดเก็บข้อจำกัดทั้งหมดที่เพิ่มใน `ShapeCS`
- `inputs`: นี่คือเวกเตอร์สตริงสำหรับจัดเก็บอินพุตทั้งหมด
- `aux`: นี่คือเวกเตอร์สตริงสำหรับจัดเก็บอินพุตเสริมทั้งหมด
โครงสร้าง `ShapeCS` ใช้ลักษณะ `ConstraintSystem` ซึ่งหมายความว่ามีวิธีการต่อไปนี้:
- `alloc`: วิธีการนี้ใช้ในการจัดสรรตัวแปรใหม่
- `alloc_input`: วิธีการนี้ใช้เพื่อจัดสรรตัวแปรอินพุตใหม่
- `บังคับใช้`: วิธีการนี้ใช้เพื่อเพิ่มข้อจำกัดใหม่
- `push_namespace`: วิธีการนี้ใช้ในการพุชเนมสเปซใหม่
- `pop_namespace`: วิธีการนี้ใช้ในการเปิดเนมสเปซปัจจุบัน
- `get_root`: วิธีการนี้ใช้เพื่อรับระบบข้อจำกัดรูท
โดยทั่วไป บทบาทหลักของไฟล์นี้คือการจัดหาวิธีสร้างรูปร่างของ R 1 CS จากระบบ (เช่น `ShapeCS`) ที่ตรงตามเงื่อนไขบางประการ
src/bellperson/solver.rs
ชื่อรอง
ไฟล์นี้กำหนดโครงสร้างที่เรียกว่า `SatisfyingAssignment` ซึ่งใช้ลักษณะ `ConstraintSystem` `SatisfyingAssignment` เป็นระบบจำกัดสำหรับการสร้างอินสแตนซ์ R 1 CS และพยาน
- `a_aux_density`, `b_input_density`,โครงสร้าง `SatisfyingAssignment` ประกอบด้วยฟิลด์ต่อไปนี้:
- `a`, `b`,`b_aux_density`: ช่องเหล่านี้เป็นช่องประเภท `DensityTracker` ที่ใช้ในการติดตามความหนาแน่นของข้อความค้นหา
- `input_assignment`,`c`: เหล่านี้เป็นเวกเตอร์ที่เก็บผลการประเมินของพหุนาม A, B, C
`aux_signment`: เหล่านี้เป็นเวกเตอร์ที่เก็บการมอบหมายให้กับตัวแปร
โครงสร้าง `SatisfyingAssignment` ใช้คุณลักษณะ `ConstraintSystem` ซึ่งหมายความว่าจะมีเมธอดต่อไปนี้:
- `ใหม่`: วิธีการนี้ใช้เพื่อสร้างอินสแตนซ์ `SatisfyingAssignment` ใหม่
- `alloc`: วิธีการนี้ใช้เพื่อจัดสรรตัวแปรเสริมใหม่
- `alloc_input`: วิธีการนี้ใช้เพื่อจัดสรรตัวแปรอินพุตใหม่
- `push_namespace`,- `บังคับใช้`: วิธีการนี้ใช้เพื่อเพิ่มข้อจำกัดใหม่
`pop_namespace`: วิธีการเหล่านี้ใช้เพื่อจัดการเนมสเปซ แต่ไม่ได้ใช้งานจริงในบริบทนี้
- `is_extensible`,- `get_root`: วิธีการนี้ใช้เพื่อรับระบบข้อจำกัดรูท
โดยทั่วไป วัตถุประสงค์หลักของไฟล์นี้คือเพื่อให้มีวิธีในการสร้างอินสแตนซ์ R 1 CS และพยานจากระบบที่ตรงตามเงื่อนไขบางประการ (เช่น `การมอบหมายที่พึงพอใจ`)
"src/circuit.rs"ชื่อรอง
ซึ่งกำหนดวงจรเสริมในโปรโตคอล Nova วงจรนี้ประกอบด้วยวงจรสเต็ปและวงจรตรวจสอบความถูกต้องในรูปแบบการพับแบบไม่โต้ตอบของ Nova
โครงสร้างและวิธีการหลักต่อไปนี้ถูกกำหนดไว้ในไฟล์:
- `NovaAugmentedCircuitParams`: โครงสร้างนี้ประกอบด้วยพารามิเตอร์ของวงจร รวมถึงความกว้างของแขนขา หมายเลขแขนขา และค่าบูลีนที่ระบุว่านี่คือวงจรหลักหรือไม่
- `NovaAugmentedCircuitInputs`: โครงสร้างนี้ประกอบด้วยอินพุตของวงจร รวมถึงพารามิเตอร์ i, z 0, zi, U, u และ T
- `NovaAugmentedCircuit`: โครงสร้างนี้เป็นคำจำกัดความหลักของวงจรเสริม Nova ซึ่งประกอบด้วยพารามิเตอร์วงจร ค่าคงที่แบบอ่านอย่างเดียว อินพุต และวงจรสเต็ป นอกจากนี้ยังกำหนดวิธีการต่างๆ เช่น `alloc_witness` (จัดสรรพยาน), `synthesize_base_case` (สังเคราะห์กรณีฐาน) และ `synthesize_non_base_case` (สังเคราะห์กรณีที่ไม่ใช่ฐาน)
- วิธีการ `สังเคราะห์`: นี่เป็นวิธีการสังเคราะห์หลักของวงจรเสริม Nova โดยจะมอบหมายพยานทั้งหมดก่อน จากนั้นจึงสังเคราะห์วงจรโดยพิจารณาว่าเป็นกรณีฐานหรือไม่ และสุดท้ายจะส่งออกค่าแฮชที่คำนวณได้และ uX[1] .
โดยทั่วไป บทบาทหลักของเอกสารนี้คือการกำหนดวงจรที่ได้รับการปรับปรุงในโปรโตคอล Nova วงจรนี้เป็นส่วนหลักของโปรโตคอล Nova ประกอบด้วยวงจรสเต็ปและวงจรตรวจสอบ และให้วิธีการสังเคราะห์วงจรนี้
"src/constants.rs"ชื่อรอง
ซึ่งกำหนดค่าคงที่บางส่วนที่ใช้กันอย่างแพร่หลายทั่วทั้งโปรเจ็กต์ ต่อไปนี้เป็นความหมายของค่าคงที่เหล่านี้:
- `NUM_CHALLENGE_BITS`: ค่าคงที่นี้กำหนดจำนวนบิตในการท้าทาย ค่าคือ 128 โดยทั่วไปความท้าทายจะเป็นตัวเลขสุ่มที่สร้างโดยผู้พิสูจน์สำหรับขั้นตอนการโต้ตอบในกระบวนการพิสูจน์ zk-SNARK
- `NUM_HASH_BITS`: ค่าคงที่นี้กำหนดจำนวนแฮชบิต ค่าคือ 250 ฟังก์ชันแฮชเป็นฟังก์ชันที่สามารถจับคู่ข้อมูลอินพุตที่มีความยาวเท่าใดก็ได้กับเอาต์พุตที่มีความยาวคงที่ โดยที่ความยาวของเอาต์พุตคือ 250 บิต
- `BN_LIMB_WIDTH`: ค่าคงที่นี้กำหนดความกว้างของแขนขาของตัวเลขขนาดใหญ่ โดยค่าคือ 64 ในวิทยาการคอมพิวเตอร์ ตัวเลขจำนวนมากคือตัวเลขที่เกินกว่าประเภทข้อมูลมาตรฐานสามารถแสดงได้ และโดยปกติแล้วจะแบ่งออกเป็น แขนขา หลายอันเพื่อจัดเก็บและจัดการ
- `BN_N_LIMBS`: ค่าคงที่นี้กำหนดจำนวนแขนขาที่มีจำนวนมาก โดยค่าคือ 4 ซึ่งหมายความว่าแต่ละจำนวนมากจะถูกแบ่งออกเป็น 4 แขนขาเพื่อการจัดเก็บและการจัดการ
- `NUM_FE_WITHOUT_IO_FOR_CRHF`: ค่าคงที่นี้กำหนดจำนวนองค์ประกอบฟิลด์ (FE) โดยไม่รวมอินพุต/เอาต์พุตสำหรับฟังก์ชันแฮชป้องกันการชนกัน (CRHF) ที่มีค่า 17
ค่าคงที่เหล่านี้มีบทบาทสำคัญในการนำโปรโตคอล Nova ไปใช้ และจะกำหนดพารามิเตอร์ที่สำคัญบางอย่าง เช่น จำนวนหลักในการท้าทาย จำนวนหลักในแฮช ความกว้างของแขนขาและจำนวนแขนขาที่มีจำนวนมาก เป็นต้น .
"src/errors.rs"ชื่อรอง
ซึ่งกำหนดประเภทของข้อผิดพลาดที่ไลบรารี Nova อาจส่งคืน ประเภทข้อผิดพลาดเหล่านี้ถูกรวมไว้ในแจงนับที่เรียกว่า `NovaError` ประเภทของข้อผิดพลาดเหล่านี้หมายถึงอะไร:
- `InvalidIndex`: ข้อผิดพลาดนี้จะถูกส่งกลับหากแถวหรือคอลัมน์ที่ระบุอยู่นอกช่วงในทูเพิล (row, col, val)
- `OddInputLength`: ข้อผิดพลาดนี้จะถูกส่งกลับหากความยาวของอินพุตที่ระบุไม่เท่ากัน
- `InvalidInputLength`: ข้อผิดพลาดนี้จะถูกส่งกลับหากมีการระบุความยาวอินพุตที่ไม่ถูกต้อง
- `InvalidWitnessLength`: ข้อผิดพลาดนี้จะถูกส่งกลับหากมีการระบุความยาวของพยานที่ไม่ถูกต้อง
- `UnSat`: ข้อผิดพลาดนี้จะถูกส่งกลับหากพยานที่ระบุไม่ตรงตามรูปแบบและตัวอย่างที่กำหนด
- `DecompressionError`: ข้อผิดพลาดนี้จะถูกส่งกลับหากสัญญาการบีบอัดที่ระบุไม่สามารถขยายขนาดได้
- `ProofVerifyError`: ข้อผิดพลาดนี้จะถูกส่งกลับหากการตรวจสอบพิสูจน์ล้มเหลว
- `InvalidNumSteps`: ข้อผิดพลาดนี้จะถูกส่งกลับหากจำนวนขั้นตอนที่ระบุเป็นศูนย์
- `InvalidIPA`: ข้อผิดพลาดนี้จะถูกส่งกลับหากมีการระบุอาร์กิวเมนต์ผลิตภัณฑ์ภายในที่ไม่ถูกต้อง
- `InvalidSumcheckProof`: ข้อผิดพลาดนี้จะถูกส่งกลับหากมีการพิสูจน์การตรวจสอบผลรวมที่ไม่ถูกต้อง
- `InvalidInitialInputLength`: ข้อผิดพลาดนี้จะถูกส่งกลับหากอินพุตเริ่มต้นสำหรับการคำนวณส่วนเพิ่มไม่ตรงกับ arity ที่ประกาศไว้ก่อนหน้านี้
- `InvalidStepOutputLength`: ข้อผิดพลาดนี้จะถูกส่งกลับหากความยาวเอาต์พุตที่สร้างโดยการดำเนินการขั้นตอนไม่ตรงกับ arity ที่ประกาศไว้ก่อนหน้านี้
- `InternalTranscriptError`: ข้อผิดพลาดนี้จะถูกส่งกลับหากกลไกการถอดเสียงพบการโอเวอร์โฟลว์ในจำนวนรอบ
- `InvalidMultisetProof`: ข้อผิดพลาดนี้จะถูกส่งกลับหากการตรวจสอบหลายชุดล้มเหลว
- `InvalidProductProof`: ข้อผิดพลาดนี้จะถูกส่งกลับหากการตรวจสอบหลักฐานผลิตภัณฑ์ล้มเหลว
ประเภทข้อผิดพลาดเหล่านี้ครอบคลุมปัญหาต่างๆ ที่อาจพบในไลบรารี Nova รวมถึงการพิมพ์ผิด ข้อผิดพลาดในการพิสูจน์ ข้อผิดพลาดภายใน ฯลฯ เมื่อฟังก์ชันของไลบรารี Nova ประสบปัญหา ระบบจะส่งคืนข้อผิดพลาดเหล่านี้เพื่อให้ผู้เรียกสามารถเข้าใจสิ่งที่ผิดพลาดและดำเนินการตามนั้น
"ecc.rs"ชื่อรอง
ซึ่งเขียนด้วยภาษาสนิม ไฟล์นี้ส่วนใหญ่ประกอบด้วยการใช้งานที่เกี่ยวข้องกับการเข้ารหัส Elliptic Curve (ECC) ในกรอบงาน Nova
Elliptic Curve Cryptography (ECC) เป็นเทคนิคการเข้ารหัสคีย์สาธารณะซึ่งมีข้อได้เปรียบหลักคือสามารถใช้คีย์ที่สั้นกว่าได้ในขณะที่ให้ความปลอดภัยเหมือนกัน ซึ่งหมายความว่า ECC สามารถใช้ทรัพยากรคอมพิวเตอร์และไฟฟ้าที่มีขนาดเล็กลงได้ ซึ่งมีความสำคัญมากสำหรับอุปกรณ์จำนวนมาก โดยเฉพาะอุปกรณ์เคลื่อนที่และระบบฝังตัว
ในไฟล์นี้ คุณจะเห็นคำจำกัดความของโครงสร้าง Rust (structs) และการใช้งาน (impls) บางส่วน ซึ่งใช้ในการนำฟังก์ชัน ECC ไปใช้ ตัวอย่างเช่น คุณจะเห็น `struct EccGadget` ซึ่งเป็นการใช้งานหลักของ ECC ซึ่งมีบางฟิลด์ เช่น `value` และ `pb_variable` ซึ่งใช้เพื่อจัดเก็บสถานะของ ECC และตัวแปรที่เกี่ยวข้อง
โดยทั่วไป ไฟล์นี้เป็นส่วนสำคัญของเฟรมเวิร์ก Nova เพื่อใช้ฟังก์ชัน ECC
"src/gadgets/mod.rs"ชื่อรอง"gadgets"。
ซึ่งเป็นโมดูลในกรอบงาน Nova ส่วนใหญ่จะใช้เพื่อปรับใช้ฟังก์ชันต่างๆ ที่จำเป็นสำหรับ Nova และแอปพลิเคชันที่สร้างด้วย Nova เป็นหลัก"gadget"ในการเข้ารหัส
เป็นคำทั่วไปที่ใช้อธิบายบล็อกของโค้ดที่ใช้ฟังก์ชันเฉพาะ ใน zk-SNARKs (อาร์กิวเมนต์แบบไม่โต้ตอบโดยย่อแบบย่อความรู้เป็นศูนย์) โดยทั่วไปอุปกรณ์จะอ้างถึงระบบพิสูจน์อักษรที่ใช้อัลกอริทึมหรือโปรโตคอลเฉพาะ
ในไฟล์นี้ คุณจะเห็นโมดูลย่อยต่อไปนี้:
- `ecc`: โมดูลนี้อาจมีโปรแกรมเบ็ดเตล็ดสำหรับการเข้ารหัส Elliptic Curve
- `nonnative`: โมดูลนี้อาจมีโปรแกรมเบ็ดเตล็ดสำหรับฟิลด์ที่ไม่ใช่เจ้าของภาษา
- `r 1 cs`: โมดูลนี้อาจมีอุปกรณ์ R 1 CS (Rank-1 Constraint Systems) บางตัว
โมดูลย่อยเหล่านี้ร่วมกันมีฟังก์ชันต่างๆ ที่จำเป็นสำหรับกรอบงาน Nova
"bignat.rs"ชื่อรอง
ซึ่งเป็นส่วนหนึ่งของโครงการ Nova และส่วนใหญ่จะใช้เพื่อดำเนินการกับจำนวนเต็มขนาดใหญ่ (BigNat)
ในวิทยาการคอมพิวเตอร์ จำนวนเต็มขนาดใหญ่ (หรือจำนวนเต็มความแม่นยำตามอำเภอใจ) เป็นจำนวนเต็มที่สามารถแทนและจัดการได้ นอกเหนือจากประเภทจำนวนเต็มทั่วไป เช่น int หรือ long สิ่งนี้มีประโยชน์มากในหลายสาขา รวมถึงการเข้ารหัส คอมพิวเตอร์กราฟิก การคำนวณจำนวนมาก เป็นต้น
มาดูส่วนหลักบางส่วนของไฟล์นี้ให้ละเอียดยิ่งขึ้น:
1. `use super::super::gadgets::GadgetCaller;`: บรรทัดโค้ดนี้จะนำเข้า GadgetCaller ซึ่งเป็นลักษณะที่ใช้ในการเรียกอุปกรณ์อื่นๆ
2. `pub struct BigNatGadget;`: บรรทัดโค้ดนี้กำหนดโครงสร้างชื่อ BigNatGadget ใน Rust โครงสร้างจะใช้เพื่อสร้างชนิดข้อมูลที่ซับซ้อน
3. `impl GadgetCaller สำหรับ BigNatGadget`: นี่คือการนำโครงสร้าง BigNatGadget ไปใช้ ซึ่งใช้คุณลักษณะ GadgetCaller ซึ่งหมายความว่า BigNatGadget จะต้องจัดเตรียมการใช้งานเมธอดทั้งหมดที่จำเป็นสำหรับคุณลักษณะ GadgetCaller
5. `pub fn from(&self, val: u 64) ->4. ในการนำไปใช้นี้ เราจะเห็นวิธีการบางอย่าง เช่น `add`, `sub`, `mul`, `div`, `rem` ฯลฯ ซึ่งเป็นการดำเนินการพื้นฐานของการดำเนินการจำนวนเต็มขนาดใหญ่
6. `pub fn to_u 64(&self) ->Self`: วิธีการนี้ใช้เพื่อสร้าง BigNatGadget จากค่าประเภท u64
7. `pub fn eq(&self, other: &Self) ->u64`: วิธีการนี้ใช้ในการแปลง BigNatGadget ให้เป็นค่าประเภท u64
โดยทั่วไป ไฟล์นี้จัดเตรียมเครื่องมือสำหรับการทำงานกับจำนวนเต็มขนาดใหญ่ รวมถึงการสร้างจำนวนเต็มขนาดใหญ่ การแปลงจำนวนเต็มขนาดใหญ่เป็นค่าประเภทอื่น และดำเนินการพื้นฐานกับจำนวนเต็มขนาดใหญ่
"mod.rs"ชื่อรอง"src/gadgets/nonnative/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ส่วนใหญ่จะใช้เพื่อดำเนินการทางคณิตศาสตร์ในฟิลด์ที่ไม่ใช่ในเครื่อง
ในการเข้ารหัส ฟิลด์ที่ไม่ใช่เจ้าของภาษามักจะหมายถึงฟิลด์ที่ฮาร์ดแวร์ไม่รองรับโดยตรง ตัวอย่างเช่น อัลกอริธึมการเข้ารหัสบางตัวอาจต้องการการดำเนินการบนฟิลด์ที่มีขนาดใหญ่กว่า 64 บิต แต่ฮาร์ดแวร์คอมพิวเตอร์สมัยใหม่ส่วนใหญ่รองรับการดำเนินการโดยตรงสูงสุด 64 บิตเท่านั้น ในกรณีนี้ เราจำเป็นต้องมีการดำเนินการทางคณิตศาสตร์โดยใช้ฟิลด์ที่ไม่ใช่ในเครื่อง
ในไฟล์นี้ คุณจะเห็นส่วนหลักๆ ดังต่อไปนี้:
1. ลักษณะ `OptionExt`: ลักษณะนี้จะเพิ่มสองวิธีให้กับประเภท `Option` คือ `grab` และ `grab_mut` โดยจะพยายามรับค่าใน `Option` หาก `Option` เป็น `None` ก็ให้ส่งคืนข้อผิดพลาด .
2. ลักษณะ `BitAccess`: ลักษณะนี้ให้วิธีการ `get_bit` ที่รับดัชนี `i` และส่งคืนว่าบิตที่ตำแหน่งดัชนีนั้นเป็น `1` หรือไม่
3. `impl BitAccess for Scalar`: นี่คือการดำเนินการตามลักษณะ `BitAccess` สำหรับประเภท `Scalar` `Scalar` เป็นประเภทที่แสดงถึงฟิลด์จำนวนเฉพาะ
โดยทั่วไป ไฟล์นี้มีวิธีการดำเนินการทางคณิตศาสตร์ในฟิลด์ที่ไม่ใช่เจ้าของภาษา ซึ่งมีความสำคัญมากสำหรับการนำอัลกอริธึมการเข้ารหัสบางอย่างไปใช้
"util.rs"ชื่อรอง"src/gadgets/nonnative/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ส่วนใหญ่จะใช้เพื่อใช้ฟังก์ชันยูทิลิตี้บางอย่างที่ทำงานบนฟิลด์ที่ไม่ใช่ในเครื่อง
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. โครงสร้าง `Bit`: โครงสร้างนี้แสดงถึงบิตซึ่งประกอบด้วยการรวมกันเชิงเส้นและค่า ซึ่งจะถูกเติมในเวลาพยาน
2. โครงสร้าง `Bitvector`: โครงสร้างนี้แสดงถึงเวกเตอร์บิต ซึ่งมีเวกเตอร์ของผลรวมเชิงเส้น เวกเตอร์ของค่า และเวกเตอร์ของบิตที่จัดสรร
3. โครงสร้าง `Num`: โครงสร้างนี้แสดงถึงตัวเลข รวมทั้งค่าผสมเชิงเส้นและค่า
4. วิธีการ `alloc` ของโครงสร้าง 'Bit': วิธีการนี้จะจัดสรรตัวแปรในระบบข้อจำกัดที่สามารถเป็นได้เฉพาะค่าบูลีนเท่านั้น
5. วิธีการ `fits_in_bits` ของโครงสร้าง `Num`: วิธีการนี้จะตรวจสอบว่าตัวเลขสามารถแสดงด้วยจำนวนบิตที่กำหนดได้หรือไม่
6. วิธีการ `is_equal` ของโครงสร้าง 'Num`: วิธีการนี้จะตรวจสอบว่าตัวเลขเท่ากับจำนวนธรรมชาติที่แสดงด้วยเวกเตอร์บิตหรือไม่
7. วิธีการ 'สลาย' ของโครงสร้าง 'Num': วิธีการนี้จะแยกตัวเลขออกเป็นเวกเตอร์บิต
8. วิธีการ `as_allocated_num` ของโครงสร้าง 'Num`: วิธีการนี้จะแปลงตัวเลขให้เป็นตัวเลขที่ได้รับการจัดสรร
9. ฟังก์ชัน `f_to_nat`: ฟังก์ชันนี้จะแปลงองค์ประกอบฟิลด์ให้เป็นจำนวนธรรมชาติ
โดยรวมแล้ว ไฟล์นี้มีฟังก์ชันยูทิลิตี้ที่ดำเนินการต่างๆ บนฟิลด์ที่ไม่ใช่ในเครื่อง เช่น การกำหนดตัวแปร การตรวจสอบว่าตัวเลขสามารถแสดงด้วยจำนวนบิตที่กำหนดหรือไม่ การแยกย่อยตัวเลขเป็นเวกเตอร์บิต เป็นต้น
"r 1 cs.rs"ชื่อรอง"src/gadgets/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ส่วนใหญ่จะใช้เพื่อใช้งานโปรแกรมเบ็ดเตล็ดต่างๆ ของระบบข้อจำกัดอันดับ 1 (R 1 CS)
R 1 CS เป็นระบบพิสูจน์สำหรับการอธิบายอัลกอริธึมหรือโปรโตคอล และเป็นพื้นฐานของระบบพิสูจน์ความรู้เป็นศูนย์หลายระบบ รวมถึง zk-SNARK
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. โครงสร้าง `AllocatedR 1 CSInstance`: โครงสร้างนี้แสดงถึงอินสแตนซ์ R 1 CS ที่ได้รับการจัดสรร ซึ่งรวมถึงจุด `W` และตัวเลขสองตัว `X 0 ` และ `X 1 `
2. วิธีการ `AllocatedR1CSInstance::alloc`: วิธีการนี้ใช้เพื่อจัดสรรอินสแตนซ์ R 1 CS ในระบบข้อจำกัด
3. วิธีการ `AllocatedR1CSInstance::absorb_in_ro`: วิธีการนี้ใช้เพื่อดูดซับอินสแตนซ์ R 1 CS ลงใน oracle แบบสุ่ม (RO)
4. โครงสร้าง `AllocatedRelaxedR1CSInstance`: โครงสร้างนี้แสดงถึงอินสแตนซ์ R 1 CS แบบผ่อนคลายที่ได้รับการจัดสรร ซึ่งรวมถึงจุด `W` และ `E` สองจุด ตัวเลข `u` และจำนวนเต็มขนาดใหญ่สองตัว `X 0` และ `X1`
5. วิธีการ `AllocatedRelaxedR1CSInstance::alloc`: วิธีการนี้ใช้เพื่อจัดสรรอินสแตนซ์ R 1 CS แบบผ่อนคลายในระบบข้อจำกัด
6. วิธีการ `AllocatedRelaxedR1CSInstance::default`: วิธีการนี้ใช้เพื่อจัดสรรอินสแตนซ์ R 1 CS แบบผ่อนคลายเริ่มต้นในระบบข้อจำกัด
7. วิธีการ `AllocatedRelaxedR1CSInstance::from_r 1 cs_instance`: วิธีการนี้ใช้ในการแปลงอินสแตนซ์ R 1 CS เป็นอินสแตนซ์ R 1 CS แบบผ่อนคลาย
8. วิธีการ `AllocatedRelaxedR1CSInstance::absorb_in_ro`: วิธีการนี้ใช้เพื่อดูดซับอินสแตนซ์ R 1 CS แบบผ่อนคลายลงใน oracle แบบสุ่ม (RO)
9. วิธีการ `AllocatedRelaxedR 1 CSInstance::fold_with_r 1 cs`: วิธีการนี้ใช้เพื่อพับอินสแตนซ์ R 1 CS แบบผ่อนคลายด้วยอินสแตนซ์ R 1 CS และส่งคืนผลลัพธ์
โดยรวมแล้ว เอกสารนี้มีเครื่องมือบางอย่างสำหรับการทำงานกับ R 1 CS รวมถึงการสร้างอินสแตนซ์ R 1 CS การแปลงอินสแตนซ์ R 1 CS เป็นอินสแตนซ์ R 1 CS แบบผ่อนคลาย การดูดซับอินสแตนซ์ R 1 CS ลงใน oracles แบบสุ่ม พับอินสแตนซ์ R 1 CS แบบผ่อนคลายด้วย อินสแตนซ์ R 1 CS หนึ่งรายการ ฯลฯ
ชื่อรอง"utils.rs"ไฟล์นี้มีชื่อว่า"src/gadgets/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ส่วนใหญ่จะใช้เพื่อใช้ฟังก์ชันยูทิลิตี้ระดับต่ำบางอย่าง ซึ่งมีประโยชน์มากเมื่อสร้างโปรโตคอลและอัลกอริธึมการเข้ารหัสระดับสูงกว่า
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. ฟังก์ชัน `le_bits_to_num`: ฟังก์ชันนี้ยอมรับอาร์เรย์บิตแบบ little-endian และส่งคืนค่าที่สอดคล้องกัน
2. ฟังก์ชัน `alloc_zero` และ `alloc_one`: ฟังก์ชันทั้งสองนี้ใช้เพื่อกำหนดตัวแปรที่มีค่าเป็นศูนย์และค่าหนึ่งในระบบข้อจำกัดตามลำดับ
3. ฟังก์ชัน `alloc_scalar_as_base`: ฟังก์ชันนี้ใช้เพื่อจัดสรรสเกลาร์เป็นฐานในระบบข้อจำกัด
4. ฟังก์ชัน `scalar_as_base`: ฟังก์ชันนี้ใช้เพื่อตีความสเกลาร์เป็นฐาน
5. ฟังก์ชัน `alloc_bignat_constant`: ฟังก์ชันนี้ใช้เพื่อจัดสรรค่าคงที่จำนวนเต็มขนาดใหญ่ในระบบจำกัด
6. ฟังก์ชัน `alloc_num_equals`: ฟังก์ชันนี้ใช้เพื่อตรวจสอบว่าตัวเลขสองตัวเท่ากันและส่งกลับบิตหรือไม่
7. ฟังก์ชัน `conditionally_select`: ฟังก์ชันนี้ใช้เพื่อเลือกตัวเลขตัวใดตัวหนึ่งจากสองตัวตามเงื่อนไข
8. ฟังก์ชัน `conditionally_select_vec`: ฟังก์ชันนี้ใช้เพื่อเลือกหนึ่งในสองอาร์เรย์ของตัวเลขตามเงื่อนไข
9. ฟังก์ชัน `conditionally_select_bignat`: ฟังก์ชันนี้ใช้เพื่อเลือกหนึ่งในจำนวนเต็มใหญ่สองตัวตามเงื่อนไข
10. ฟังก์ชัน `conditionally_select2`: ฟังก์ชันนี้ใช้เพื่อเลือกตัวเลขหนึ่งในสองตัวตามเงื่อนไขซึ่งเป็นตัวเลขที่กำหนด
11. ฟังก์ชัน `select_zero_or_num 2` และ `select_num_or_zero 2`: ฟังก์ชันทั้งสองนี้ใช้เพื่อตั้งค่าตัวเลขให้เป็นศูนย์หรือไม่เปลี่ยนแปลงตามเงื่อนไขซึ่งเป็นตัวเลขที่กำหนด
12. ฟังก์ชัน `select_num_or_zero`: ฟังก์ชันนี้ใช้เพื่อตั้งค่าตัวเลขให้เป็นศูนย์หรือไม่เปลี่ยนแปลงตามเงื่อนไขซึ่งเป็นค่าบูลีน
โดยทั่วไป ไฟล์นี้มีฟังก์ชันยูทิลิตี้สำหรับการกำหนดตัวแปรในระบบข้อจำกัด การตรวจสอบความเท่าเทียมกันของตัวเลขสองตัว การเลือกตัวเลขหนึ่งในสองตัวตามเงื่อนไข ฯลฯ
ชื่อรอง"lib.rs"นี่คือโปรแกรมชื่อ
ไฟล์ซอร์สโค้ดภาษา Rust สำหรับ ซึ่งเป็นองค์ประกอบหลักของโปรเจ็กต์ Nova ไฟล์นี้กำหนดอินเทอร์เฟซสาธารณะและฟังก์ชันหลักบางอย่างของไลบรารี Nova เป็นหลัก ต่อไปนี้เป็นการตีความโดยละเอียดของเอกสาร:"ast"1. `pub mod ast`: บรรทัดโค้ดนี้จะนำเข้า"ast"โมดูล."Abstract Syntax Tree"ใช่"ast"(Abstract Syntax Tree) ซึ่งเป็นโครงสร้างข้อมูลที่ใช้แสดงโครงสร้างของซอร์สโค้ด ในโครงการโนวา
โมดูลอาจมีโครงสร้างข้อมูลและฟังก์ชันต่างๆ สำหรับการแยกวิเคราะห์และประมวลผลซอร์สโค้ดภาษา Nova"parser"2. `pub mod parser`: บรรทัดโค้ดนี้จะนำเข้า"parser"โมดูล."ใช่"ตัวแยกวิเคราะห์
หมายความว่าโมดูลนี้อาจมีฟังก์ชันและคลาสสำหรับการแยกวิเคราะห์ซอร์สโค้ดภาษา Nova"codegen"3. `pub mod codegen`: บรรทัดโค้ดนี้จะนำเข้า"codegen"โมดูล."code generation"ใช่
(การสร้างโค้ด) โมดูลนี้อาจมีฟังก์ชันและคลาสสำหรับการแปลงแผนผังไวยากรณ์นามธรรมของภาษา Nova ให้เป็นโค้ดอ็อบเจ็กต์ (เช่น LLVM IR หรือโค้ดเครื่อง)"types"4. `pub mod types`: บรรทัดโค้ดนี้จะนำเข้า
โมดูล. โมดูลนี้อาจมีระบบประเภทของภาษา Nova รวมถึงการเป็นตัวแทนและการจัดการประเภทที่มีอยู่แล้วภายในและประเภทที่ผู้ใช้กำหนด"util"5. `pub mod util`: บรรทัดโค้ดนี้จะนำเข้า"util"โมดูล."utilities"ใช่
(ยูทิลิตี้) โมดูลนี้อาจมีฟังก์ชันและคลาสยูทิลิตี้ต่างๆ เช่น การจัดการข้อผิดพลาด การบันทึก การอ่านและเขียนไฟล์ เป็นต้น"driver"6. `pub mod driver`: บรรทัดโค้ดนี้จะนำเข้า"driver"โมดูล. ในโครงการคอมไพเลอร์
โดยทั่วไปหมายถึงโมดูลที่ควบคุมกระบวนการคอมไพล์ทั้งหมด รวมถึงขั้นตอนต่างๆ เช่น การอ่านซอร์สโค้ด การแยกวิเคราะห์ การตรวจสอบประเภท การสร้างโค้ด การเพิ่มประสิทธิภาพ และเอาต์พุต"error"7. `ข้อผิดพลาด pub mod`: บรรทัดโค้ดนี้นำเข้า
โมดูล. โมดูลนี้อาจมีระบบการจัดการข้อผิดพลาดของภาษา Nova รวมถึงการเป็นตัวแทนและการจัดการข้อผิดพลาดในการคอมไพล์และข้อผิดพลาดรันไทม์ต่างๆ"config"8. `pub mod config`: บรรทัดโค้ดนี้จะนำเข้า
หน้าที่หลักของไฟล์นี้คือจัดระเบียบส่วนประกอบต่างๆ ของภาษา Nova (เช่น parser, code Generator, Type System, Error Handling System ฯลฯ) เพื่อสร้างไลบรารีคอมไพเลอร์ที่สมบูรณ์
ชื่อรอง"nifs.rs"ไฟล์นี้มีชื่อว่า"src/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ใช้โครงร่างการพับแบบไม่โต้ตอบ (โครงร่างการพับแบบไม่โต้ตอบ, NIFS) นี่คือโปรโตคอลการเข้ารหัสที่ใช้ในการพิสูจน์ความถูกต้องของแต่ละขั้นตอนในการคำนวณส่วนเพิ่ม
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. โครงสร้าง `NIFS`: โครงสร้างนี้แสดงถึง SNARK ซึ่งจัดเก็บหลักฐานของการคำนวณแบบเพิ่มหน่วยขั้นตอนเดียว ประกอบด้วยช่องชื่อ `comm_T` ซึ่งเป็น Compressed Commitment
2. วิธีการ `พิสูจน์`: วิธีการนี้ยอมรับคู่อินสแตนซ์พยาน R 1 CS แบบหลวม `(U 1, W 1)` และคู่พยานอินสแตนซ์ R 1 CS `(U 2, W 2)` ซึ่งมี โครงสร้างเดียวกัน 'รูปร่าง' และสัมพันธ์กับคำจำกัดความ 'ck' เดียวกัน จากนั้นจะส่งออกคู่พยานอินสแตนซ์ R 1 CS แบบหลวมที่พับไว้ `(U, W)` โดยมีโครงสร้าง `รูปร่าง` เหมือนกัน พยานที่พับ `W` ตอบสนองความต้องการตัวอย่างที่พับ `U` ถ้า `W 1` ตอบสนอง `U 1` และ `W 2` ตอบสนอง `U 2`
3. วิธีการ `ตรวจสอบ`: วิธีการนี้ยอมรับอินสแตนซ์ R 1 CS แบบหลวม `U 1 ` และอินสแตนซ์ R 1 CS `U 2 ` ซึ่งมีโครงสร้างเหมือนกันและถูกกำหนดโดยคำนึงถึงพารามิเตอร์เดียวกัน จากนั้นจะส่งออกอินสแตนซ์ที่พับไว้ `U` โดยมีโครงสร้างเดียวกัน อินสแตนซ์ที่พับไว้ `U` พอใจถ้า `U 1` และ `U 2` พอใจ
โดยรวมแล้ว ไฟล์นี้ใช้รูปแบบการพับแบบไม่โต้ตอบ ซึ่งเป็นโปรโตคอลการเข้ารหัสสำหรับการพิสูจน์ความถูกต้องของแต่ละขั้นตอนในการคำนวณส่วนเพิ่ม ข้อได้เปรียบหลักของโครงการนี้คือสามารถยุบหลักฐานหลายรายการให้เป็นหลักฐานเดียวได้ ซึ่งช่วยลดค่าใช้จ่ายในการจัดเก็บและส่งหลักฐาน
ชื่อรอง"ipa_pc.rs"ไฟล์นี้มีชื่อว่า"src/provider/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ใช้กลไกการประเมินโดยใช้แผนข้อผูกมัดพหุนามตาม IPA (ข้อโต้แย้งผลิตภัณฑ์ภายใน)
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. โครงสร้าง `ProverKey`: โครงสร้างนี้แสดงถึงคีย์พิสูจน์ตัวตน ซึ่งมีคีย์ความมุ่งมั่น `ck_s`
2. โครงสร้าง `VerifierKey`: โครงสร้างนี้แสดงถึงคีย์ตัวตรวจสอบ ซึ่งมีคีย์ความมุ่งมั่น `ck_v` และ `ck_s` สองคีย์
3. โครงสร้าง `EvalueingArgument`: โครงสร้างนี้แสดงถึงพารามิเตอร์การประเมินพหุโนเมียล ซึ่งประกอบด้วยพารามิเตอร์ผลิตภัณฑ์ภายใน `ipa`
4. โครงสร้าง `EvalueingEngine`: โครงสร้างนี้แสดงถึงกลไกการประเมินพหุนามโดยใช้ IPA
5. การใช้งานคุณลักษณะ `EvalueingEngineTrait`: การใช้งานคุณลักษณะนี้จะทำให้มีการทำงานหลักของกลไกการประเมินพหุนาม รวมถึงการตั้งค่า การพิสูจน์ และการตรวจสอบ
6. ฟังก์ชัน `inner_product`: ฟังก์ชันนี้จะคำนวณผลคูณภายในของเวกเตอร์สองตัว
` ค่าของ `c`
8. โครงสร้าง `InnerProductWitness`: โครงสร้างนี้แสดงถึงพยานผลิตภัณฑ์ภายใน ซึ่งมีเวกเตอร์ `a_vec`
โดยทั่วไป เอกสารนี้ใช้กลไกการประเมินที่ใช้แผนข้อผูกพันพหุนามตาม IPA ซึ่งเป็นโปรโตคอลการเข้ารหัสสำหรับการพิสูจน์ค่าการประเมินของพหุนาม ณ จุดใดจุดหนึ่งในการพิสูจน์ความรู้เป็นศูนย์ ข้อได้เปรียบหลักของโครงการนี้คือ สามารถพิสูจน์ค่าประเมินของพหุนามได้โดยไม่ต้องเปิดเผยตัวพหุนาม ดังนั้น จึงรักษาความเป็นส่วนตัวของพหุนาม
ชื่อรอง"keccak.rs"ไฟล์นี้มีชื่อว่า"src/provider/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ใช้ TranscriptEngineTrait ที่ใช้ฟังก์ชันแฮช Keccak 256 TranscriptEngineTrait เป็นคุณลักษณะที่ใช้ในการประมวลผลการถอดเสียงในกระบวนการพิสูจน์ความรู้เป็นศูนย์ Transcript คือโครงสร้างข้อมูลที่บันทึกขั้นตอนการโต้ตอบทั้งหมดในกระบวนการพิสูจน์
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. โครงสร้าง `Keccak 256 Transcript`: โครงสร้างนี้ใช้ TranscriptEngineTrait ซึ่งใช้ฟังก์ชันแฮช Keccak 256 เพื่อประมวลผลการถอดเสียง ประกอบด้วยฟิลด์แบบกลมสำหรับบันทึกหมายเลขรอบปัจจุบัน ฟิลด์สถานะสำหรับเก็บสถานะแฮชปัจจุบัน ฟิลด์การถอดเสียงสำหรับเก็บการถอดเสียง และฟิลด์ _p เพื่อเก็บข้อมูลประเภท
2. ฟังก์ชัน `compute_updated_state`: ฟังก์ชันนี้รับอินพุตและคำนวณสถานะแฮชที่อัปเดต
3. การใช้งาน `TranscriptEngineTrait`: การใช้งานคุณสมบัตินี้ให้ฟังก์ชันหลักในการประมวลผลการถอดเสียง รวมถึงการสร้างการถอดเสียงใหม่ การแยกความท้าทายออกจากการถอดเสียง การเพิ่มองค์ประกอบให้กับการถอดเสียง และการเพิ่มตัวแยกโดเมน
โดยรวมแล้ว ไฟล์นี้ใช้ TranscriptEngineTrait ที่ใช้ฟังก์ชันแฮช Keccak 256 ซึ่งเป็นเครื่องมือสำหรับการประมวลผลการถอดเสียงระหว่างการพิสูจน์ความรู้แบบไม่มีศูนย์ ข้อได้เปรียบหลักของเครื่องมือนี้คือสามารถประมวลผลข้อความถอดเสียงได้โดยไม่ต้องเปิดเผยขั้นตอนการโต้ตอบในกระบวนการพิสูจน์อักษร จึงรักษาความเป็นส่วนตัวของกระบวนการพิสูจน์ได้
ชื่อรอง"mod.rs"ไฟล์นี้มีชื่อว่า"src/provider/",มันตั้งอยู่
ภายใต้เนื้อหา ไฟล์นี้ส่วนใหญ่จะใช้เพื่อนำเข้าโมดูลการใช้งานต่างๆ ในโปรเจ็กต์ Nova ซึ่งมีฟังก์ชันต่างๆ ที่จำเป็นสำหรับโปรเจ็กต์ Nova
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:"ipa_pc"1. `pub mod ipa_pc;`: บรรทัดโค้ดนี้จะนำเข้า
โมดูล. โมดูลนี้ใช้เครื่องมือประเมินผลโดยใช้แผนข้อผูกมัดพหุนามตาม IPA (ข้อโต้แย้งผลิตภัณฑ์ภายใน)"keccak"2. `pub mod keccak;`: บรรทัดโค้ดนี้จะนำเข้า
โมดูล. โมดูลนี้ใช้ TranscriptEngineTrait ที่ใช้ฟังก์ชันแฮช Keccak 256"pasta"3. `pub mod pasta;`: บรรทัดของโค้ดนี้จะนำเข้า
โมดูล. โมดูลนี้อาจมีฟังก์ชันและคลาสที่ทำงานกับเส้นโค้งพาสต้า"pedersen"4. `pub mod pedersen;`: บรรทัดโค้ดนี้จะนำเข้า a
โมดูล. โมดูลนี้อาจมีฟังก์ชันและคลาสที่ใช้สัญญา Pedersen"poseidon"5. `pub modposeidon;`: บรรทัดของโค้ดนี้จะนำเข้า
โดยทั่วไป บทบาทหลักของไฟล์นี้คือการจัดระเบียบส่วนประกอบต่างๆ ของโปรเจ็กต์ Nova (เช่น กลไกการประเมิน TranscriptEngineTrait, Pasta curve, Pedersen Commitment, ฟังก์ชันแฮชของ Poseidon ฯลฯ) เพื่อสร้างไลบรารีการเข้ารหัสที่สมบูรณ์
ชื่อรอง
ชื่อไฟล์: `src/r 1 cs.rs`
ไฟล์นี้กำหนดประเภทและวิธีการที่เกี่ยวข้องกับระบบข้อจำกัดอันดับ 1 (R 1 CS) R 1 CS เป็นระบบจำกัดที่ใช้กันอย่างแพร่หลายในระบบพิสูจน์ความรู้เป็นศูนย์
1. `R 1 CS
2. `R 1 CSShape
3. `R 1 CSWitness
4. `R 1 CSInstance
5. `RelaxedR 1 CSWitness
6. `RelaxedR 1 CSInstance
ชื่อรอง
ชื่อไฟล์: `src/spartan/math.rs`
ไฟล์นี้กำหนดลักษณะที่เรียกว่า 'คณิตศาสตร์' และการใช้งานประเภท 'usize' ลักษณะนี้กำหนดการดำเนินการทางคณิตศาสตร์หลายอย่าง รวมถึงการยกกำลัง 2 รับไบนารีบิต และลอการิทึมในการคำนวณ
- `pow 2(self) ->1. คุณลักษณะ คณิตศาสตร์ กำหนดวิธีการต่อไปนี้:
- `get_bits(self, num_bits: usize) -> Vec
- `log_ 2(self) ->`: รับ num_bits บิตแรกของการเป็นตัวแทนไบนารีของตัวเอง
usize`: คำนวณลอการิทึมฐาน 2 ของตัวเอง
- `pow 2(self) ->2. สำหรับประเภท `usize` วิธีการทั้งหมดของคุณลักษณะ 'คณิตศาสตร์' จะถูกนำไปใช้:
- `get_bits(self, num_bits: usize) -> Vec
- `log_ 2(self) ->`: รับ num_bits บิตแรกของการแสดงไบนารีของตัวเองโดยการเลื่อนบิตและบิตและและ
ไฟล์นี้จัดเตรียมการดำเนินการทางคณิตศาสตร์พื้นฐานบางอย่างที่อาจใช้โดยส่วนอื่น ๆ ของโค้ดเพื่อปรับใช้ฟังก์ชันที่ซับซ้อนมากขึ้น
ชื่อรอง
ชื่อไฟล์: src/spartan/mod.rs
โมดูลนี้ใช้ RelaxedR1CSSNARKTrait ของ Spartan ซึ่งเป็นความมุ่งมั่นพหุนามทั่วไปและพารามิเตอร์การประเมิน (เช่น PCS)
โครงสร้างและหน้าที่หลักบางส่วนมีดังนี้:
1. `PolyEvalWitness`: นี่คือโครงสร้างที่มีการพิสูจน์พหุนาม
2. `PolyEvalInstance`: นี่คือโครงสร้างที่มีอินสแตนซ์ของการประเมินพหุนาม
3. `ProverKey` และ `VerifierKey`: โครงสร้างทั้งสองนี้แสดงถึงคีย์ของผู้พิสูจน์และคีย์ของผู้ตรวจสอบตามลำดับ
4. `RelaxedR 1 CSSNARK`: โครงสร้างนี้แสดงถึงการพิสูจน์ความรู้โดยสรุปเกี่ยวกับอินสแตนซ์ R 1 CS ที่ผ่อนคลาย การพิสูจน์จัดทำขึ้นโดยใช้การผสมผสานระหว่างการตรวจสอบผลรวมของ Spartan และข้อผูกพันพหุนามแบบดูเวกเตอร์
5. `setup`: ฟังก์ชันนี้ใช้เพื่อตั้งค่าการยืนยันและคีย์การยืนยัน
6. `พิสูจน์`: ฟังก์ชันนี้ใช้เพื่อสร้างหลักฐานที่กระชับถึงความพึงพอใจของอินสแตนซ์ R 1 CS ที่ผ่อนคลาย
โค้ดในโมดูลนี้ส่วนใหญ่เกี่ยวข้องกับการพิสูจน์ความรู้เป็นศูนย์ในการเข้ารหัส โดยเฉพาะการพิสูจน์ R 1 CS (Rank-1 Constraint Systems) R 1 CS เป็นระบบสำหรับสร้างการพิสูจน์ความรู้เป็นศูนย์ ซึ่งสามารถใช้เพื่อพิสูจน์ว่ารู้คำตอบของชุดสมการพหุนามโดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับคำตอบ Spartan เป็นระบบพิสูจน์ความรู้แบบศูนย์โดยเฉพาะซึ่งใช้สิ่งที่เรียกว่า ผ่อนคลาย R 1 CS ซึ่งอนุญาตให้ใช้การสุ่มในการพิสูจน์ ซึ่งจะช่วยเพิ่มประสิทธิภาพ
ชื่อรอง
ชื่อไฟล์: src/spartan/polynomial.rs
ไฟล์นี้กำหนดประเภทพื้นฐานและการดำเนินการที่เกี่ยวข้องกับพหุนาม ประเภทและการดำเนินการเหล่านี้ใช้เพื่อคำนวณพหุนามในโปรโตคอล Spartan
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. `EqPolynomial`: โครงสร้างนี้แสดงถึงพหุนามความเท่าเทียมกัน ประกอบด้วยวิธีการ 'ใหม่' สำหรับการสร้างพหุนามใหม่ วิธีการ 'ประเมิน' สำหรับการประเมินพหุนามที่จุดที่ระบุ และวิธีการ 'ประเมิน' สำหรับการคำนวณการประเมินพหุนามในอินพุตบูลีนทั้งหมด
2. `พหุนามพหุนามหลายเส้น': โครงสร้างนี้แสดงถึงพหุนามหลายเส้น ประกอบด้วยวิธีการ `ใหม่` สำหรับการสร้างพหุนามใหม่ วิธีการ `get_num_vars` สำหรับการรับจำนวนตัวแปรของพหุนาม วิธีการ `bound_poly_var_top` สำหรับการเชื่อมโยงตัวแปรของพหุนามไว้ด้านบน และวิธีการ `ประเมิน` ใช้ในการประเมินพหุนามที่จุดที่กำหนด
โค้ดในไฟล์นี้ส่วนใหญ่เกี่ยวข้องกับการคำนวณพหุนามในการเข้ารหัส โดยเฉพาะการคำนวณพหุนามหลายเชิงเส้นและพหุนามแบบกระจัดกระจาย การคำนวณเหล่านี้มีบทบาทสำคัญในระบบการพิสูจน์ความรู้เป็นศูนย์ เนื่องจากสามารถใช้สร้างการพิสูจน์ที่ซับซ้อนได้โดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับการพิสูจน์
ชื่อรอง
`src/spartan/pp.rs` เป็นไฟล์ภาษา Rust ในโครงการ Nova ไฟล์นี้ใช้ฟังก์ชันของตัวประมวลผลล่วงหน้าใน Nova เป็นหลัก ตัวประมวลผลล่วงหน้าเป็นขั้นตอนหนึ่งในกระบวนการคอมไพล์ที่ประมวลผลโค้ดบางอย่างก่อนที่จะคอมไพล์จริง
โครงสร้างและฟังก์ชันหลักในไฟล์นี้ประกอบด้วย:
1. `struct Preprocessor`: นี่คือโครงสร้างพรีโปรเซสเซอร์ซึ่งประกอบด้วยสถานะและข้อมูลบางอย่างที่พรีโปรเซสเซอร์ต้องการ
3. `fn new(source: String) ->2. `impl Preprocessor`: นี่คือการนำโครงสร้าง `Preprocessor` ไปใช้ ซึ่งมีวิธีการบางอย่าง
4. `fn preprocess(&mut self) -> Result<(), Error>ตนเอง: นี่คือตัวสร้าง ตัวประมวลผลล่วงหน้า ที่ใช้ในการสร้างอินสแตนซ์ ตัวประมวลผลล่วงหน้า ใหม่
5. `fn next_token(&mut self) -> Result
`: ฟังก์ชันนี้ใช้เพื่อรับโทเค็นถัดไปจากซอร์สโค้ด หากเกิดข้อผิดพลาดระหว่างการประมวลผล ก็จะส่งคืนข้อผิดพลาด
7. `fn skip_comment(&mut self) -> Result<(), Error>6. `fn skid_whitespace(&mut self)`: ฟังก์ชันนี้ใช้เพื่อข้ามอักขระช่องว่างในซอร์สโค้ด
8. `fn read_number(&mut self) -> Result
9. `fn read_identifier(&mut self) -> Result
10. `fn read_string(&mut self) -> Result
โดยทั่วไป ไฟล์ `src/spartan/pp.rs` จะใช้ตัวประมวลผลล่วงหน้าใน Nova ซึ่งจะประมวลผลซอร์สโค้ดล่วงหน้า ซึ่งรวมถึงการข้ามอักขระและความคิดเห็นในช่องว่าง การอ่านตัวเลข ตัวระบุ และสตริง ฯลฯ
ชื่อรอง
ชื่อไฟล์: src/spartan/sumcheck.rs
ไฟล์นี้ใช้อัลกอริทึม Sumcheck ในโปรโตคอล Spartan อัลกอริธึม Sumcheck เป็นอัลกอริธึมสำหรับตรวจสอบผลรวมของพหุนาม ซึ่งใช้กันอย่างแพร่หลายในระบบพิสูจน์ความรู้เป็นศูนย์
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. `SumcheckProof`: โครงสร้างนี้แสดงถึงหลักฐาน Sumcheck ประกอบด้วยวิธีการ 'ใหม่' สำหรับการสร้างการพิสูจน์ใหม่ วิธีการ 'ยืนยัน' สำหรับการตรวจสอบการพิสูจน์ และวิธีการ 'พิสูจน์' หลายวิธีในการสร้างการพิสูจน์
2. `UniPoly` และ `CompressedUniPoly`: โครงสร้างทั้งสองนี้แสดงถึงพหุนามเอกนารีและพหุนามเอกนารีที่ถูกบีบอัด ประกอบด้วยวิธีการสร้างพหุนาม การประเมินพหุนาม การประเมินพหุนาม ณ จุดที่กำหนด และการบีบอัดและขยายพหุนาม
โค้ดในไฟล์นี้ส่วนใหญ่เกี่ยวข้องกับอัลกอริธึม Sumcheck ในการเข้ารหัส โดยเฉพาะการคำนวณและการพิสูจน์พหุนาม การคำนวณเหล่านี้มีบทบาทสำคัญในระบบการพิสูจน์ความรู้เป็นศูนย์ เนื่องจากสามารถใช้สร้างการพิสูจน์ที่ซับซ้อนได้โดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับการพิสูจน์
ชื่อรอง
ชื่อไฟล์: src/traits/circuit.rs
ไฟล์นี้กำหนดลักษณะชื่อ `StepCircuit` และโครงสร้าง `TrivialTestCircuit` ที่ใช้ลักษณะนี้ ทั้งลักษณะนี้และโครงสร้างเกี่ยวข้องกับฟังก์ชันขั้นตอนสำหรับการคำนวณส่วนเพิ่ม
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. ลักษณะ StepCircuit: คุณลักษณะนี้กำหนดวิธีการที่ฟังก์ชันขั้นตอนสำหรับการคำนวณส่วนเพิ่มต้องใช้ วิธีการเหล่านี้ได้แก่:
- `arity`: ส่งกลับจำนวนอินพุตหรือเอาต์พุตสำหรับแต่ละขั้นตอน
- `synthesize`: สังเคราะห์ขั้นตอนการคำนวณและส่งกลับตัวแปรที่สอดคล้องกับเอาต์พุตของขั้นตอน
- `output`: เมื่อระบุอินพุตให้กับขั้นตอน จะส่งกลับเอาต์พุตของขั้นตอนนั้น
รหัสในไฟล์นี้เกี่ยวข้องกับฟังก์ชันขั้นตอนของการคำนวณส่วนเพิ่มเป็นหลัก ในวิทยาการเข้ารหัสลับ การคำนวณส่วนเพิ่มเป็นเทคนิคทั่วไปที่สามารถใช้เพื่อคำนวณฟังก์ชันที่ซับซ้อนทีละน้อยโดยไม่ต้องคำนวณฟังก์ชันทั้งหมดพร้อมกัน เทคนิคนี้มีประโยชน์อย่างยิ่งในระบบพิสูจน์ความรู้เป็นศูนย์ เนื่องจากสามารถใช้สร้างการพิสูจน์ที่ซับซ้อนได้โดยไม่ต้องสร้างการพิสูจน์ทั้งหมดพร้อมกัน
ชื่อรอง
ชื่อไฟล์: src/traits/commitment.rs
ไฟล์นี้กำหนดลักษณะบางอย่างที่เกี่ยวข้องกับข้อผูกพัน ในวิทยาการเข้ารหัส ความมุ่งมั่นเป็นกลไกที่ช่วยให้สามารถยอมรับค่าได้โดยไม่ต้องเปิดเผยทันที นี่เป็นสิ่งจำเป็นในโปรโตคอลการเข้ารหัสหลายอย่าง เช่น การพิสูจน์ความรู้เป็นศูนย์
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. คุณลักษณะ `CommitmentOps`: คุณลักษณะนี้กำหนดการดำเนินการพื้นฐานของข้อผูกพัน รวมถึงการมอบหมายการบวกและการบวก
2. คุณลักษณะ `CommitmentOpsOwned`: คุณลักษณะนี้กำหนดการดำเนินการพื้นฐานสำหรับการอ้างอิงที่เป็นเจ้าของความมุ่งมั่น
3. คุณลักษณะ `ScalarMul`: คุณลักษณะนี้กำหนดการดำเนินการคูณของคำสัญญาและสเกลาร์
4. คุณลักษณะ `CommitmentTrait`: คุณลักษณะนี้จะกำหนดพฤติกรรมของความมุ่งมั่น ซึ่งรวมถึงการโคลน คัดลอก ค่าเริ่มต้น เปรียบเทียบ ส่ง ซิงโครไนซ์ ทำให้เป็นอนุกรม ดีซีเรียลไลซ์ ดูดซับ จัดการ บีบอัด ขยายขนาด ฯลฯ
รหัสในไฟล์นี้เกี่ยวข้องกับข้อผูกพันในการเข้ารหัสเป็นหลัก ความมุ่งมั่นเหล่านี้มีบทบาทสำคัญในระบบการพิสูจน์ความรู้เป็นศูนย์ เนื่องจากสามารถใช้เพื่อสร้างการพิสูจน์ที่ซับซ้อนโดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับหลักฐาน
ชื่อรอง
ชื่อไฟล์: src/traits/evalue.rs
ไฟล์นี้กำหนดลักษณะชื่อ `EvalueingEngineTrait` ลักษณะนี้กำหนดพฤติกรรมของกลไกการประเมินพหุนาม รวมถึงการตั้งค่า การพิสูจน์ และการตรวจสอบ
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. คุณลักษณะ `EvalueingEngineTrait`: คุณลักษณะนี้กำหนดวิธีการที่กลไกประเมินผลพหุนามต้องนำไปใช้ วิธีการเหล่านี้ได้แก่:
- `การตั้งค่า`: วิธีการนี้ใช้สำหรับการตั้งค่าเพิ่มเติมที่จำเป็นในการสร้างหลักฐานการประเมิน
- `พิสูจน์`: วิธีการนี้ใช้เพื่อพิสูจน์การประเมินผลของพหุนามพหุนามหลายเส้น
- `ตรวจสอบ`: วิธีการนี้ใช้ในการตรวจสอบหลักฐานการประเมินพหุนามหลายเส้น
ลักษณะนี้ยังกำหนดประเภทที่เกี่ยวข้องอีกหลายประเภท รวมไปถึง:
- `CE`: นี่คือประเภทที่เกี่ยวข้องกับเครื่องมือสัญญา
- `ProverKey`: นี่คือประเภทของคีย์พิสูจน์อักษร
- `VerifierKey`: นี่คือประเภทของคีย์ตัวตรวจสอบ
รหัสในไฟล์นี้เกี่ยวข้องกับการประเมินพหุนามในการเข้ารหัสเป็นหลัก นี่เป็นขั้นตอนสำคัญในระบบพิสูจน์ความรู้เป็นศูนย์เพราะสามารถใช้เพื่อพิสูจน์ว่ารู้คำตอบของชุดสมการพหุนามโดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับคำตอบ
ชื่อรอง
ชื่อไฟล์: src/traits/mod.rs
ไฟล์นี้เป็นจุดเริ่มต้นหลักสำหรับโมดูลลักษณะในโครงการ Nova โดยส่วนใหญ่จะกำหนดลักษณะบางอย่างสำหรับการดำเนินการเข้ารหัสลับ ลักษณะเป็นคุณลักษณะสำคัญใน Rust ที่กำหนดประเภทนามธรรมที่สามารถนำมาใช้กับคอนกรีตหลายประเภท สิ่งนี้ช่วยให้เราสามารถเขียนโค้ดทั่วไปที่สามารถจัดการค่าประเภทใด ๆ ที่ใช้คุณลักษณะเฉพาะได้
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. ลักษณะ กลุ่ม: ลักษณะนี้กำหนดการดำเนินการพื้นฐานของกลุ่ม ซึ่งรวมถึงการโคลน การคัดลอก ค่าเริ่มต้น การเปรียบเทียบ การส่ง การซิงโครไนซ์ การทำให้เป็นอนุกรม การดีซีเรียลไลซ์ การดูดซับ การจัดการ การบีบอัด การขยายขนาด ฯลฯ
2. ลักษณะ `CompressedGroup`: ลักษณะนี้กำหนดการดำเนินการพื้นฐานของกลุ่มที่ถูกบีบอัด ซึ่งรวมถึงการโคลน การคัดลอก การเปรียบเทียบ การส่ง การซิงโครไนซ์ การทำให้เป็นอนุกรม การดีซีเรียลไลซ์ ฯลฯ
3. ลักษณะ `AbsorbInROTrait`: ลักษณะนี้กำหนดวิธีการ `absorb_in_ro` สำหรับการดูดซับวัตถุเข้าสู่ Random Oracle
4. คุณลักษณะ `ROTrait`: คุณลักษณะนี้กำหนดพฤติกรรมของ Oracle แบบสุ่ม รวมถึงการเริ่มต้น การดูดซับ และการอัดขึ้นรูป
5. คุณลักษณะ `ROConstantsTrait`: คุณลักษณะนี้จะกำหนดค่าคงที่ของ oracle แบบสุ่ม
6. คุณลักษณะ GroupOps: คุณลักษณะนี้กำหนดการดำเนินการของกลุ่ม ซึ่งรวมถึงการบวก การลบ การมอบหมายการบวก และการลบ
7. ลักษณะ `ScalarMul`: ลักษณะนี้กำหนดการดำเนินการคูณสเกลาร์
8. ลักษณะ `TranscriptReprTrait`: ลักษณะนี้กำหนดวิธีการ `to_transcript_bytes` สำหรับการแปลงวัตถุเป็นลำดับไบต์
โค้ดในไฟล์นี้ส่วนใหญ่เกี่ยวข้องกับการดำเนินการกลุ่มในการเข้ารหัส ออราเคิลแบบสุ่ม และกลไกการถอดเสียง สิ่งเหล่านี้มีบทบาทสำคัญในระบบการพิสูจน์ความรู้เป็นศูนย์ เนื่องจากสามารถใช้สร้างการพิสูจน์ที่ซับซ้อนได้โดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับหลักฐาน
ชื่อรอง
ชื่อไฟล์: src/traits/snark.rs
ไฟล์นี้กำหนดลักษณะชื่อ `RelaxedR1CSSNARKTrait` คุณสมบัตินี้กำหนดพฤติกรรมของอาร์กิวเมนต์แบบไม่โต้ตอบที่กระชับความรู้เป็นศูนย์ (zkSNARK) โดยเฉพาะอย่างยิ่งสำหรับระบบข้อจำกัดอันดับ 1 แบบผ่อนคลาย (Relaxed R 1 CS)
ต่อไปนี้เป็นส่วนสำคัญบางส่วนในไฟล์นี้:
1. คุณลักษณะ `RelaxedR1CSSNARKTrait`: คุณลักษณะนี้จะกำหนดวิธีการที่ zkSNARK ต้องใช้ วิธีการเหล่านี้ได้แก่:
- `setup`: วิธีการนี้ใช้เพื่อสร้างคีย์ของผู้พิสูจน์และผู้ตรวจสอบ
- `พิสูจน์`: วิธีการนี้ใช้เพื่อสร้างหลักฐานที่กระชับเกี่ยวกับความพึงพอใจของอินสแตนซ์ R 1 CS ที่ผ่อนคลาย
- `ตรวจสอบ`: วิธีการนี้ใช้ในการตรวจสอบหลักฐานความพึงพอใจของอินสแตนซ์ R 1 CS ที่ผ่อนคลาย
ลักษณะนี้ยังกำหนดประเภทที่เกี่ยวข้องอีกหลายประเภท รวมไปถึง:
- `ProverKey`: นี่คือประเภทของคีย์พิสูจน์อักษร
โค้ดในไฟล์นี้ส่วนใหญ่เกี่ยวข้องกับการพิสูจน์ความรู้เป็นศูนย์ในการเข้ารหัส โดยเฉพาะการพิสูจน์ R 1 CS R 1 CS เป็นระบบสำหรับสร้างการพิสูจน์ความรู้เป็นศูนย์ ซึ่งสามารถใช้เพื่อพิสูจน์ว่ารู้คำตอบของชุดสมการพหุนามโดยไม่ต้องเปิดเผยข้อมูลใดๆ เกี่ยวกับคำตอบ zkSNARK เป็นระบบพิสูจน์ความรู้แบบศูนย์โดยเฉพาะที่ให้วิธีที่มีประสิทธิภาพในการสร้างและตรวจสอบการพิสูจน์
ชื่อระดับแรก
เกี่ยวกับ Huobi Ventures:
IOS
Android