Dive into Move - ภาษาการเขียนโปรแกรมบล็อกเชน Libra ของ Facebook

ต่อไป เราจะพิจารณารายละเอียดเกี่ยวกับลักษณะสำคัญของภาษา Move และความแตกต่างที่สำคัญกับภาษาอื่นที่เป็นที่นิยมอยู่แล้วสำหรับสัญญาอัจฉริยะ - Solidity (บนแพลตฟอร์ม Ethereum) เนื้อหานี้อิงจากการศึกษาเอกสารทางเทคนิค 26 หน้าออนไลน์ที่มีอยู่

การแนะนำ

Move เป็นภาษาไบต์โค้ดที่ปฏิบัติการได้ซึ่งใช้ในการดำเนินธุรกรรมของผู้ใช้และสัญญาอัจฉริยะ โปรดทราบสองประเด็น:

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

การแปลดำเนินการโดยทีมงานโครงการ INDEX Protocol เราแปลเรียบร้อยแล้ว เนื้อหาขนาดใหญ่ที่อธิบายโครงการ Libraตอนนี้ถึงเวลาดูรายละเอียดภาษา Move โดยละเอียดแล้ว การแปลดำเนินการร่วมกับ Habrauser คูลซิว

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

ตัวอย่างเช่น ข้อมูลโค้ดต่อไปนี้จะแสดงข้อผิดพลาด: การใช้ค่าย้าย 'x' เนื่องจากไม่มีการรวบรวมขยะใน Rust เมื่อตัวแปรอยู่นอกขอบเขต หน่วยความจำที่อ้างถึงก็จะว่างเช่นกัน พูดง่ายๆ ก็คือ มี "เจ้าของ" ข้อมูลได้เพียงคนเดียวเท่านั้น ในตัวอย่างนี้ x เป็นเจ้าของเดิมแล้ว y กลายเป็นเจ้าของคนใหม่ อ่านเพิ่มเติมเกี่ยวกับพฤติกรรมนี้ที่นี่.

การแสดงสินทรัพย์ดิจิทัลในระบบเปิด

มีสองคุณสมบัติของสินทรัพย์ทางกายภาพที่ยากต่อการแสดงแบบดิจิทัล:

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

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

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

คำแนะนำ # 1: กฎที่ง่ายที่สุดโดยปราศจากความขาดแคลนและการควบคุมการเข้าถึง

• G [K]: = n หมายถึงการอัปเดตหมายเลขที่เข้าถึงได้โดยคีย์ К ในสถานะโลกของ blockchain ที่มีความหมายใหม่ n.
• ธุรกรรม ⟨อลิซ 100⟩ หมายถึงการตั้งค่ายอดเงินในบัญชีของอลิซเป็น 100

วิธีแก้ปัญหาข้างต้นมีปัญหาสำคัญหลายประการ:

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

คำแนะนำ # 2: คำนึงถึงการขาดดุล

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

ข้อเสนอ # 3: การรวมความขาดแคลนและการควบคุมการเข้าถึงเข้าด้วยกัน

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

ภาษาโปรแกรมบล็อกเชน

ภาษา blockchain ที่มีอยู่ประสบปัญหาต่อไปนี้ (ทั้งหมดได้รับการแก้ไขใน Move (หมายเหตุ: น่าเสียดายที่ผู้เขียนบทความสนใจแต่ Ethereum ในการเปรียบเทียบของเขาเท่านั้น ดังนั้นจึงควรค่าแก่การพิจารณาเฉพาะในบริบทนี้เท่านั้น ตัวอย่างเช่น สิ่งต่อไปนี้ส่วนใหญ่ได้รับการแก้ไขใน EOS ด้วย-

การแสดงทรัพย์สินทางอ้อม. เนื้อหาถูกเข้ารหัสโดยใช้จำนวนเต็ม แต่จำนวนเต็มไม่เหมือนกับเนื้อหา ในความเป็นจริง ไม่มีประเภทหรือมูลค่าที่เป็นตัวแทนของ Bitcoin/Ether/<Any Coin>! ทำให้การเขียนโปรแกรมที่ใช้แอสเซทเป็นเรื่องยากและเกิดข้อผิดพลาดได้ง่าย รูปแบบต่างๆ เช่น การส่งผ่านสินทรัพย์ไปยัง/จากขั้นตอน หรือการจัดเก็บสินทรัพย์ในโครงสร้าง จำเป็นต้องได้รับการสนับสนุนเป็นพิเศษจากภาษา

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

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

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

สิ่งนี้ก็เป็นจริงบน Ethereum เช่นกัน โดยที่สัญญาอัจฉริยะไม่รองรับการเข้ารหัสแบบเนทีฟสำหรับการควบคุมการเข้าถึง นักพัฒนาจะต้องตั้งค่าการควบคุมการเข้าถึงด้วยตนเอง เช่น การใช้ตัวแก้ไข onlyOwner

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

ดังนั้น ใน Solidity เมื่อสัญญา A เรียกใช้ฟังก์ชันในสัญญา B สัญญา B อาจเรียกใช้โค้ดที่นักพัฒนาของสัญญา A ไม่ได้ตั้งใจ ซึ่งอาจส่งผลให้ ช่องโหว่กลับเข้ามาใหม่ (สัญญา A บังเอิญทำหน้าที่เป็นสัญญา B เพื่อถอนเงินก่อนหักยอดบัญชีจริง)

ย้ายพื้นฐานการออกแบบภาษา

ทรัพยากรอันดับหนึ่ง

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

มีความยืดหยุ่น

Move เพิ่มความยืดหยุ่นให้กับ Libra ผ่านการเขียนสคริปต์ ทุกธุรกรรมใน Libra จะมีสคริปต์ ซึ่งเป็นขั้นตอนหลักของธุรกรรม สคริปต์สามารถดำเนินการอย่างใดอย่างหนึ่งที่ระบุ เช่น ชำระเงินให้กับรายชื่อผู้รับที่ระบุ หรือใช้ทรัพยากรอื่น ๆ ซ้ำ - ตัวอย่างเช่น โดยการเรียกขั้นตอนที่ระบุตรรกะทั่วไป นี่คือเหตุผลว่าทำไมสคริปต์ธุรกรรม Move จึงมีความยืดหยุ่นมากกว่า สคริปต์สามารถใช้ทั้งพฤติกรรมแบบครั้งเดียวและแบบทำซ้ำ ในขณะที่ Ethereum สามารถเรียกใช้สคริปต์ที่ทำซ้ำได้เท่านั้น (เรียกวิธีเดียวในวิธีสัญญาอัจฉริยะ) เหตุผลที่เรียกว่า "นำมาใช้ซ้ำ" ก็เนื่องมาจากฟังก์ชันของสัญญาอัจฉริยะสามารถดำเนินการได้หลายครั้ง (บันทึก: ประเด็นที่นี่ละเอียดอ่อนมาก ในแง่หนึ่ง สคริปต์ธุรกรรมในรูปแบบของรหัสไบต์หลอกก็มีอยู่ใน Bitcoin เช่นกัน ในทางกลับกัน ตามที่ฉันเข้าใจ Move จะขยายภาษานี้ไปสู่ระดับของภาษาสัญญาอัจฉริยะที่เต็มเปี่ยม).

ความปลอดภัย

รูปแบบปฏิบัติการ Move คือ bytecode ซึ่งในด้านหนึ่งเป็นภาษาระดับที่สูงกว่าภาษาแอสเซมบลี แต่ระดับต่ำกว่าซอร์สโค้ด รหัสไบต์จะถูกตรวจสอบในเวลารันไทม์ (ออนไลน์) สำหรับทรัพยากร ประเภท และความปลอดภัยของหน่วยความจำโดยใช้ตัวตรวจสอบรหัสไบต์ จากนั้นจึงดำเนินการโดยล่าม วิธีการนี้ช่วยให้ Move สามารถจัดเตรียมการรักษาความปลอดภัยของซอร์สโค้ดได้ แต่ไม่มีกระบวนการคอมไพล์และจำเป็นต้องเพิ่มคอมไพลเลอร์ให้กับระบบ การทำให้ Move ภาษา bytecode เป็นทางออกที่ดีจริงๆ ไม่จำเป็นต้องคอมไพล์จากแหล่งที่มา เช่นเดียวกับในกรณีของ Solidity และไม่จำเป็นต้องกังวลเกี่ยวกับความล้มเหลวหรือการโจมตีที่อาจเกิดขึ้นกับโครงสร้างพื้นฐานของคอมไพเลอร์

ตรวจสอบได้

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

ความเป็นโมดูล

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

ภาพรวมการย้าย

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

การชำระเงินแบบ Peer-to-Peer

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

• 0x0: ที่อยู่ของบัญชีที่จัดเก็บโมดูล
• เงินตรา: ชื่อโมดูล
• เหรียญ: ประเภททรัพยากร
• ค่าเหรียญที่ส่งคืนโดยโพรซีเดอร์เป็นค่าทรัพยากรประเภท 0x0.Currency.Coin
• เคลื่อนไหว (): ไม่สามารถใช้ค่าได้อีก
• สำเนา(): ค่าใช้ภายหลังได้

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

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

การใช้เงินซ้ำโดยระบุ ย้าย (เหรียญ) สองครั้ง . การเพิ่มบรรทัด 0x0.Currency.deposit (คัดลอก (some_other_payee), ย้าย (coin)) ตัวอย่างเช่นข้างต้นจะอนุญาตให้ผู้ส่ง "ใช้จ่าย" เหรียญสองครั้ง - ครั้งแรกกับผู้รับเงินและครั้งที่สองกับ some_other_payee. นี่เป็นพฤติกรรมที่ไม่พึงประสงค์ซึ่งไม่สามารถทำได้กับสินทรัพย์ทางกายภาพ โชคดีที่ Move จะปฏิเสธโปรแกรมนี้

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

โมดูลสกุลเงิน

แต่ละบัญชีสามารถมี 0 โมดูลขึ้นไป (แสดงเป็นรูปสี่เหลี่ยม) และค่าทรัพยากรหนึ่งค่าขึ้นไป (แสดงเป็นรูปทรงกระบอก) เช่น บัญชีที่ 0x0 มีโมดูล 0x0.สกุลเงิน และมูลค่าของประเภททรัพยากร 0x0.สกุลเงินเหรียญ. บัญชีตามที่อยู่ 0x1 มีสองทรัพยากรและหนึ่งโมดูล บัญชีตามที่อยู่ 0x2 มีสองโมดูลและหนึ่งค่าทรัพยากร

บางช่วงเวลา:

• สคริปต์ธุรกรรมเป็นแบบอะตอมมิก - ไม่ว่าจะถูกดำเนินการอย่างสมบูรณ์หรือไม่ทำงานเลยก็ตาม
• โมดูลคือโค้ดที่มีอายุการใช้งานยาวนานซึ่งสามารถเข้าถึงได้ทั่วโลก
• สถานะส่วนกลางมีโครงสร้างเป็นตารางแฮช โดยที่คีย์คือที่อยู่บัญชี
• บัญชีสามารถมีค่าทรัพยากรประเภทที่กำหนดได้ไม่เกินหนึ่งค่าและมีชื่อที่กำหนดได้ไม่เกินหนึ่งโมดูล (บัญชีที่ 0x0 ไม่สามารถมีทรัพยากรเพิ่มเติมได้ 0x0.สกุลเงินเหรียญ หรือโมดูลอื่นชื่อ เงินตรา)
• ที่อยู่ของโมดูลที่ประกาศเป็นส่วนหนึ่งของประเภท (0x0.สกุลเงินเหรียญ и 0x1.สกุลเงินเหรียญ เป็นประเภทแยกกันซึ่งไม่สามารถใช้แทนกันได้)
• โปรแกรมเมอร์สามารถจัดเก็บทรัพยากรประเภทนี้ได้หลายอินสแตนซ์ในบัญชีโดยกำหนดทรัพยากรที่กำหนดเอง - (ทรัพยากร TwoCoins {c1: 0x0.Currency.Coin, c2: 0x0.Currency.Coin})
• คุณสามารถอ้างถึงทรัพยากรตามชื่อได้โดยไม่มีข้อขัดแย้ง ตัวอย่างเช่น คุณสามารถอ้างถึงทรัพยากรสองรายการโดยใช้ TwoCoins.c1 и TwoCoins.c2.

การประกาศทรัพยากรเหรียญ

ชื่อโมดูล เงินตรา และประเภททรัพยากรที่ชื่อ เหรียญ

บางช่วงเวลา:

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

ขายฝาก

ขั้นตอนนี้ยอมรับทรัพยากร เหรียญ เป็นอินพุตและรวมเข้ากับทรัพยากร เหรียญเก็บไว้ในบัญชีของผู้รับ:

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

บางช่วงเวลา:

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

การดำเนินการ withdraw_from_sender

ขั้นตอนนี้:

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

บางช่วงเวลา:

• เงินฝาก อาจเกิดจากใครก็ได้แต่ ถอน_จาก_ผู้ส่ง มีสิทธิ์เข้าถึงเหรียญของบัญชีการโทรเท่านั้น
• รับ TxnSenderAddress คล้ายกับ msg.ผู้ส่ง ในความแข็งแกร่ง
• ปฏิเสธเว้นแต่ คล้ายกับ ต้องการ ในความแข็งแกร่ง หากการตรวจสอบนี้ล้มเหลว ธุรกรรมจะหยุดลงและการเปลี่ยนแปลงทั้งหมดจะถูกย้อนกลับ
• หีบห่อ นอกจากนี้ยังเป็นขั้นตอนในตัวที่สร้างทรัพยากรใหม่ประเภท T
• เช่นกัน แกะ, หีบห่อ สามารถเรียกได้ภายในโมดูลที่มีการอธิบายทรัพยากรเท่านั้น T

ข้อสรุป

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

ที่มา: will.com