-- การแนะนำ--

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

มีเพื่อนเก่าที่สามารถรวม "ผู้พัฒนาสัญญา" และ "บล็อกเชน" ได้อย่างรวดเร็วหรือไม่?

อย่างที่เราทราบกันดีว่า Java เป็นภาษาการเขียนโปรแกรมเชิงวัตถุที่ใช้กันอย่างแพร่หลาย โดยมีคุณลักษณะข้ามแพลตฟอร์มคือ "เขียนครั้งเดียว ดำเนินการได้ทุกที่" ดังนั้นเราจึงเชิญ Java เข้าสู่แพลตฟอร์มบล็อกเชนของเรา และพัฒนาชุดของเอ็นจิ้นการดำเนินการ HVM ที่สามารถดำเนินการสัญญาอัจฉริยะของ Java ได้ การนำ Java smart contracts เข้าสู่ blockchain ส่วนใหญ่มีจุดประสงค์ดังต่อไปนี้:

*ลดต้นทุนของการพัฒนาสัญญาอัจฉริยะ ช่วยให้นักพัฒนาสัญญาสามารถมุ่งเน้นไปที่ตรรกะของสัญญามากกว่ารายละเอียดทางไวยากรณ์

* จัดเตรียมเครื่องมือและวิธีการที่คุ้นเคยซึ่งเหมาะสำหรับสถานการณ์ blockchain ให้กับนักพัฒนา หลีกเลี่ยง "การสร้างวงล้อ" ซ้ำๆ

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

ข้อความ

ข้อความ

จากมุมมองของผู้พัฒนาสัญญา กระบวนการใช้ Java smart contract มักจะมีสามขั้นตอนต่อไปนี้: การพัฒนาสัญญา การปรับใช้สัญญา และการเรียกใช้สัญญา

▲ การพัฒนาสัญญาจาวา

เมื่อเทียบกับสัญญาอัจฉริยะแบบดั้งเดิม การพัฒนาและการใช้สัญญาอัจฉริยะ Java นั้นง่ายและสะดวกกว่า โดยส่วนใหญ่สะท้อนให้เห็นใน:

1) การสร้างโครงการที่รวดเร็ว: นักพัฒนาเพียงแค่สร้างโครงการ Java ใหม่ใน IDE ภายในเครื่องและนำเข้าแพ็คเกจการพึ่งพาการพัฒนาสัญญาเพื่อพัฒนาสัญญา หลังจากเขียนโค้ดเสร็จแล้ว โค้ดจะถูกบรรจุลงในไฟล์ Jar ของสัญญาและสามารถนำไปใช้งานในห่วงโซ่ได้

2) มีเครื่องมือและวิธีการมากมาย: นักพัฒนาสามารถใช้คลาสและวิธีการใน JDK เพื่อหลีกเลี่ยงปัญหาในการ "สร้างวงล้อ" ซ้ำๆ

3) ต้นทุนการเรียนรู้ต่ำ: ภาษา Java ถูกใช้อย่างแพร่หลาย และนักพัฒนาส่วนใหญ่จำเป็นต้องเข้าใจอินเทอร์เฟซของแพ็คเกจการพึ่งพาการพัฒนาสัญญาเท่านั้นจึงจะสามารถใช้ Java smart contract ได้อย่างเชี่ยวชาญ

▲การปรับใช้สัญญา Java

สำหรับการปรับใช้ Java smart contract ผู้พัฒนาจะอัพโหลดแพ็คเกจ Jar ของสัญญาไปยังเชนผ่านธุรกรรม และบล็อกเชนจะเริ่มต้นสัญญา สร้างที่อยู่ของสัญญาเฉพาะ และส่งที่อยู่ของสัญญาไปยังผู้พัฒนาผ่านใบเสร็จธุรกรรม

▲โทรสัญญา Java

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

——คำอธิบายโดยละเอียดของ HVM——

▲ JVM เข้าถึง blockchain

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

"เมื่อ JVM เชื่อมต่อกับบล็อกเชน จะต้องทำอะไรอีกเพื่อให้ JVM เป็นเครื่องมือดำเนินการสัญญา Java ในบล็อกเชน"

▲การปรับความปลอดภัยของเครื่องเสมือน

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

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

2) แยกสภาพแวดล้อมการดำเนินการของสัญญา: Java smart contract ในแพลตฟอร์ม blockchain ต้องการสภาพแวดล้อมการดำเนินการแยก นั่นคือ Java smart contract ไม่สามารถใช้เธรด เครือข่าย เวลาระบบเข้าถึง และฟังก์ชันอื่นๆ เช่นโปรแกรม Java ทั่วไป นอกจากนี้ เรายังได้นำเมธอดที่เกี่ยวข้องกับบล็อกเชนไปใช้ใน JDK และเมธอดบางอย่างไม่ได้รับอนุญาตให้เรียกใช้โดยสัญญา Java ดังนั้นเราจึงใช้ตัวกรองการเรียกเมธอดภายใน HVM เพื่อสกัดกั้นการเรียกเมธอดที่ไม่ได้รับอนุญาต

3) กำหนดลำดับการดำเนินการตามลอจิก: เช่นเดียวกับ EVM เราได้นำชุดกลไก Gas มาใช้ภายใน HVM เพื่อคำนวณค่าใช้จ่ายในการดำเนินการตามสัญญา ความแตกต่างในการดำเนินการคำสั่งจะทำให้ค่าแก๊สที่คำนวณโดยโหนดต่างๆ แตกต่างกัน ใน JDK ดั้งเดิม เมื่อเมธอดบางอย่างถูกเรียกใช้สองครั้ง แม้ว่าผลลัพธ์จะเหมือนกัน แต่พาธโค้ดของการดำเนินการตรรกะจะแตกต่างกัน ยกตัวอย่างคลาสที่ใช้รูปแบบ singleton เมื่อเรียกใช้เมธอดอินสแตนซ์ของคลาสนี้เป็นครั้งแรก คุณต้องสร้างอินสแตนซ์ของคลาสนี้ เมื่อเรียกใช้เมธอดในภายหลัง คุณไม่จำเป็นต้องสร้างอินสแตนซ์อีกต่อไป ความแตกต่างทางตรรกะนี้จะทำให้ค่าก๊าซของโหนดที่เพิ่งเริ่มต้นไม่สอดคล้องกับค่าของโหนดอื่น ดังนั้น เราจำเป็นต้องปรับตรรกะประเภทนี้ใน JDK เพื่อให้แน่ใจว่าลำดับการดำเนินการของตรรกะนั้นสอดคล้องกันเสมอ

▲กลไกการโต้ตอบบัญชีแยกประเภท

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

มีสองตัวเลือกสำหรับการใช้กลไกการโต้ตอบบัญชีแยกประเภท:

1) ใช้ชุดของชุดคำสั่งที่กำหนดเองสำหรับการโต้ตอบบัญชีแยกประเภทใน JVM ในเวลาเดียวกัน คอมไพเลอร์หรือปลั๊กอินสำหรับสัญญา Java มีไว้เพื่อสร้างคำสั่งที่กำหนดเองโดยเฉพาะสำหรับการโต้ตอบบัญชีแยกประเภทในบล็อกเชนในรหัสไบต์ของสัญญา

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

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

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

ในรูปแบบนี้ ผู้ใช้สามารถเลือกบัญชีแยกประเภทการดำเนินการของคลาสโครงสร้างข้อมูลที่มีประสิทธิภาพเมื่อเขียน Java smart contracts คลาสโครงสร้างข้อมูลเหล่านี้สรุปเมธอด Java ของการโต้ตอบบัญชีแยกประเภท เพื่อให้ผู้ใช้ไม่สามารถรับรู้ได้ และนำอินเทอร์เฟซไปใช้ใน JDK ให้ได้มากที่สุด โครงสร้างข้อมูล เช่น HVMMap และ HVMList ใช้อินเทอร์เฟซ Map และ List ใน JDK ตามลำดับ และเกือบจะเหมือนกันกับ Maps และ List อื่นๆ ที่ JDK จัดเตรียมให้

▲การวิเคราะห์เปรียบเทียบเครื่องเสมือน

นอกเหนือจากสัญญา HVM แล้ว สัญญาทั่วไปยังรวมถึงสัญญา Solidity ของ EVM, Chaincode ของ Fabric และอื่นๆ

EVM จัดเตรียมสภาพแวดล้อมการดำเนินการตามสัญญาแบบแซนด์บ็อกซ์ที่แยกออกจากกันโดยสิ้นเชิง Solidity ได้รับการพิจารณาว่าเป็นภาษาสัญญาอัจฉริยะตั้งแต่เริ่มต้นการออกแบบ และมีข้อดีอย่างมากในการดำเนินการหนังสือ

Chaincode ของ Fabric รองรับการเขียนได้หลายภาษา Chaincode ทำงานในคอนเทนเนอร์ Docker ที่ได้รับการป้องกัน หลังจากได้รับคำขอการโทรที่ส่งโดยไคลเอนต์ มันจะจำลองชุดการอ่านและเขียนของสมุดบัญชีในคอนเทนเนอร์และส่งกลับไปยังไคลเอ็นต์ สุดท้าย ลูกค้าจะเริ่มธุรกรรมจำลองอีกครั้ง . สร้างคำขอเพื่อเขียนชุดการอ่าน-เขียนไปยังบัญชีแยกประเภท

เมื่อเปรียบเทียบกับเครื่องมือดำเนินการอื่น HVM มีคุณสมบัติหลักดังต่อไปนี้:

*สัญญา HVM ดำเนินการในสภาพแวดล้อมแซนด์บ็อกซ์แบบปิดที่ปลอดภัยพร้อมความปลอดภัยสูง

*เครื่องมือดำเนินการที่ฝังอยู่ในแพลตฟอร์ม ไม่มีการพึ่งพาเครือข่าย

*HVM มีกลไกการจัดการวงจรชีวิตของสัญญาที่สมบูรณ์ และสามารถอัปเกรดสัญญาได้ผ่านการเรียก sdk และ api เท่านั้น

* มีฟังก์ชันในตัวมากมาย เช่น เอาต์พุตบันทึก ชุดการเข้ารหัส และสัญญาการโทรที่หลากหลาย

นอกเหนือจากฟังก์ชันที่มีให้โดยภาษา Java JDK แล้ว HVM ยังมีโครงสร้างข้อมูลที่หลากหลายตามการดำเนินการข้อมูลบัญชีแยกประเภท blockchain

-- สรุป --

บทความนี้จะแนะนำขั้นตอนการพัฒนาและการใช้ Java smart contract จากมุมมองของนักพัฒนา จากนั้นจะอธิบายโซลูชันทางเทคนิคสำหรับการเข้าถึง JVM ในบล็อกเชน และกล่าวถึงการแปลงรหัสของ JDK และการทำให้กลไกการโต้ตอบบัญชีแยกประเภทเป็นจริง HVM มุ่งสู่เป้าหมายของประสิทธิภาพที่ดีขึ้นและประสบการณ์การใช้งานที่เป็นมิตรยิ่งขึ้น ในขณะเดียวกันเครื่องมือดำเนินการตามสัญญาในอุตสาหกรรมก็กำลังเติบโต ต่อไป เราจะแนะนำรายละเอียด FVM ซึ่งรองรับ Rust และภาษาอื่นๆ ในการเขียนสัญญาอัจฉริยะ และ KVSQL ซึ่งรองรับการดำเนินการ SQL บนบล็อกเชน ปรับ!

เกี่ยวกับผู้เขียน

เกี่ยวกับผู้เขียน

ลู่ อี้หมิง, เหยา ปิง

อ้างอิง

อ้างอิง

[1] ข้อมูลจำเพาะของเครื่องเสมือน Java