การอ่านสัญญาอัจฉริยะ

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

เข้าใจสัญญาอัจฉริยะ: พื้นฐานและวัตถุประสงค์

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

วิธีการสั่งการสัญญาอัจฉริยะกับเทคโนโลยีบล็อกเชน: BeInCrypto

คำวลัสดุ “web3” แสดงถึงนิสัยในการเขียนโปรแกรมที่ไม่เข้มงวดและขาดความปลอดภัยของเว็บ เมื่อถูกเขียนโปรแกรมเหมือนหน้าเว็บ การใช้ crypto หรือ smart contracts ก็จะพบว่ามันล้มละลายไปแล้ว บล็อกเชนที่ประสบความสำเร็จอย่างยั่งยืนและแอปพลิเคชันของมัน ถูกสร้างขึ้นจากวิธีการเขียนโปรแกรมที่ปลอดภัยมากขึ้น รอบคอบและช้าลงมาก

นิก ซาโบ, นักวิทยาศาสตร์คริปโตแกรฟเฟอร์และนักวิทยาการคอมพิวเตอร์: Twitter

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

สัญญาอัจฉริยะและความสำคัญของพวกเขา

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

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

สัญญาทางด้านดั้งเดิม เอกสารสินทรัพย์ พินัยกรรม ฯลฯ เป็นกฎหมายเอกชน 'ที่ถูกเขียนโดยบุคคลทั่วไป ไม่ใช่นักการเมืองหรือข้าราชการ' สมาร์ทคอนแทร็คเป็นรูปแบบใหม่ของการตัดสินใจที่ดีทรัพย์ที่มีลักษณะแบบนี้https://t.co/EU2Y28FznK
— Nick Szabo (@NickSzabo4) 15 มีนาคม 2561

พิจารณาสระเงินสดที่มีสัญญาอัจฉริยะเป็นมาตรฐาน

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

ลักษณะพิเศษของสัญญาอัจฉริยะ

เราไม่สามารถดำเนินการศึกษารายละเอียด, เขียน, และตรวจสอบสัญญาได้อย่างลึกซึ้งหากเราไม่รู้จักลักษณะของมัน นี่คือคุณลักษณะมาตรฐานของสัญญาอัจฉริยะที่ควรทราบ

คุณลักษณะบางประการของสัญญาอัจฉริยะมาตรฐาน: BeInCrypto

สัญญาอัจฉริยะ

สัญญาอัจฉริยะเป็นเพียงชิ้นส่วนของรหัส คุณสามารถเขียนสัญญาอัจฉริยะเพื่อดําเนินการคําสั่งและสถานการณ์ตามเงื่อนไขเฉพาะ นี่คือเหตุผลที่นักพัฒนาสัญญาอัจฉริยะและโปรแกรมเมอร์เป็นที่ต้องการในปัจจุบันเนื่องจากส่วนใหญ่ DeFispace already relies on สัญญาอัจฉริยะ to process complex instances like handling trading fees across liquidity pools, maintaining APYอัตราส่วน และอื่น ๆ

ไม่มีความเชื่อ

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

อัตโนมัส

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

มั่นคง

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

สามารถพิสูจน์ได้

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

ดังนั้นครั้งหน้าที่คุณวางแผนที่จะอ่านสัญญาอัจฉริยะ ให้แน่ใจว่า boilerplate หรือเอกสารประกอบมีลักษณะทั้งหมดที่กล่าวถึง

เวอร์ชันที่ถูกปรับแก้ง่ายของสัญญาอัจฉริยะ: Reddit

การอ่านสัญญาอัจฉริยะตามลักษณะ

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

/ SPDX-License-Identifier: MITpragma solidity ^0.8.0;// Basic Smart Contract Boilerplatecontract SimpleTrustlessEscrow {// State variablesaddress public depositor; // Account depositing etheraddress payable public beneficiary; // Account receiving etheruint256 public releaseTime; // Timestamp to release ether// Events for verifying contract activityevent Deposited(address indexed _from, uint256 _value); เหตุการณ์ Released(address indexed _to, uint256 _value);// The contract constructor initializes the smart contractconstructor(address payable _beneficiary, uint256 _releaseTime) { require(_releaseTime > block.timestamp, "Release time must be in the future");    ปลอดภัยและเชื่อถือได้: สัญญาผูกมัดผู้ฝากเงินและผู้ฝากเงินผู้รับผลประโยชน์ = msg.sender;    ผู้รับผลประโยชน์ = _beneficiary;    releaseTime = _releaseTime;}ฟังก์ชันการฝากเงิน – การดําเนินการอัตโนมัติ (ฟังก์ชันสํารอง)รับ() เจ้าหนี้ภายนอก {ปล่อยเงินฝาก(msg.sender, msg.value);}ปล่อยอีเธอร์ไปยัง beneficiaryfunction release() public { // Programmable: สามารถดําเนินการได้หลังจาก releaseTime require(block.timestamp >= releaseTime, "เร็วเกินไปที่จะปล่อย");    อิสระ: ดําเนินการโดยอัตโนมัติตามเงื่อนไข uint256 amount = address(this).balance;    beneficiary.transfer(จํานวนเงิน);    ปล่อยปล่อยออกมา(ผู้รับผลประโยชน์, จํานวนเงิน);}}

ในขณะที่เราจะไปถอดรหัสและอ่านสัญญาอัจฉริยะนี้อย่างละเอียด ให้เราเช็คก่อนว่ามันเป็นไปตามลักษณะของสัญญาที่กล่าวถึงหรือไม่

ส่วนที่"สามารถโปรแกรมได้"

ดูที่สัญญาอย่างใกล้ชิดสำหรับชิ้นโค้ดนี้

require(block.timestamp >= releaseTime, “เร็วเกินไปที่จะปล่อย”);

uint256 amount = address(this).balance;

beneficiary.transfer(amount);

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

ส่วน “trustless”

นี่คือโค้ดสั้นๆ จากข้างต้น:

depositor = msg.sender;

ผู้รับผลประโยชน์ = _beneficiary;

releaseTime = _releaseTime;

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

ส่วน “อัตโนมัส”

นี่คือส่วน "การปล่อยเงิน" ของโค้ด:

 function release() public {require(block.timestamp >= releaseTime, “ยังเร็วเกินไปที่จะปล่อย”);uint256 amount = address(this).balance;beneficiary.transfer(amount);emit Released(beneficiary, amount);}

กระบวนการทั้งหมดเป็นอัตโนมัติเนื่องจากเงินถูกปล่อยออกมาเมื่อเวลาการปล่อยตรงตามเกณฑ์บางอย่าง โปรดทราบว่าโค้ดไม่สามารถโปรแกรมบางส่วนได้แต่มีความเป็นอิสระอย่างเต็มที่

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

ส่วนที่"มีความมั่นใจ"

กังวลเกี่ยวกับว่าธาตุใดมีส่วนช่วยความปลอดภัยไปที่สัญญาหรือไม่? ตรวจสอบส่วนนี้ของโค้ด:

constructor(address payable _beneficiary, uint256 _releaseTime) {require(_releaseTime > block.timestamp, "เวลาวางจําหน่ายต้องเป็นในอนาคต"); ผู้ฝาก = msg.sender; ผู้รับผลประโยชน์ = _beneficiary; releaseTime = _releaseTime;}

โปรดสังเกตว่ามีการตั้งค่าลําดับความสําคัญของฟังก์ชัน releaseTime ที่เกี่ยวข้องกับการประทับเวลาอย่างไร ไม่มีอะไรสุ่มและต้องปฏิบัติตามเงื่อนไข

ส่วนที่"สามารถยืนยันได้"

ทุกธุรกรรมที่เกี่ยวข้องกับสัญญาอัจฉริยะจะถูกบันทึกในโซ่ด้วยองค์ประกอบกิจกรรมบันทึกที่แยกต่างหาก

เหตุการณ์ที่ฝาก (ที่อยู่จัดทําดัชนี _from, uint256 _value);

event Released(address indexed _to, uint256 _value);

emit Deposited(msg.sender, msg.value);

emit Released(beneficiary, amount);

การอ่านส่วนอื่น ๆ ของสัญญาอัจฉริยะ

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

Pragma solidity ^0.8.0; – เวอร์ชันของภาษาโปรแกรมมิ่ง Solidity ที่ต้องการเขียนสัญญาอัจฉริยะนี้

// SPDX-License-Identifier: MIT - ซอฟต์แวร์แพคเกจสื่อสารข้อมูลที่ได้รับคำถึงว่าเป็นสัญญาการอนุญาต ตัวระบุนี้ระบุให้ทราบถึงการอนุญาตของการเผยแพร่โค้ด ควรรวมเข้าไปเพื่อให้คนทราบว่ามันเป็นโอเพนซอร์สและสามารถทำงานรอบๆได้หรือไม่

Contract TimeLock { – กําหนดชื่อให้กับสัญญาอัจฉริยะเช่นฉลาก

ที่อยู่ของผู้ฝากสาธารณะ; - เนื่องจากสัญญาเกี่ยวข้องกับผู้ฝากและผู้รับผลประโยชน์ นี่คือจุดที่ที่อยู่สาธารณะของผู้ฝากถูกกล่าวถึง ตัวแปรนี้คือ กระเป๋าเงิน Ethereumที่อยู่และสามารถดูได้สาธารณะ

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

Uint256 public releaseTime; – เนื่องจากเป็นสัญญาที่มีระยะเวลา uint256 จะกำหนดตัวแปรที่เชื่อมโยงกับเวลาในสัญญา นี่จะเป็นช่วงเวลาตามซึ่งการปล่อยเงินทุนจะเกิดขึ้น

ใน Solidity uint (unsigned integer) คือวิธีในการกำหนดค่าที่เกี่ยวข้องกับจำนวนเต็ม คำต่อท้าย 256 หมายถึงการเก็บข้อมูลของตัวเลขใหญ่

หลังจาก 5 ปีของการเขียนสัญญาอัจฉริยะฉันเพิ่งตระหนักว่าโลโก้ Solidity เป็นโลโก้ Ethereum ที่กางออก 🤯 pic.twitter.com/wlM369Eff9
— kaden.eth (@0xKaden) กรกฎาคม 8, 2023

คุณสามารถพิจารณาการอ่านเอกสาร Solidity เพื่อทําความคุ้นเคยกับไวยากรณ์นิพจน์และองค์ประกอบโค้ดอื่น ๆ

องค์ประกอบอื่น ๆ

constructor(address payable _beneficiary, uint256 _releaseTime) { – ฟังก์ชัน 'Constructor' เป็นฟังก์ชันพิเศษที่เรียกใช้เพียงครั้งเดียวเมื่อสัญญาอัจฉริยะถูกนำไปใช้งาน มันเริ่มดำเนินการสัญญา โปรดสังเกตว่าในจุดนี้ ตัวแปรที่เป็นที่อยู่ทั้งหมดที่เราได้ประกาศไว้ก่อนหน้านี้จะถูกเรียกใช้และเริ่มต้นใช้งาน

Receive() external payable { – นี่คือฟังก์ชันพิเศษที่เรียกเมื่อเงินย้ายไปยังที่อยู่สัญญาจากด้านนอก คำว่า External แสดงถึงมาจากด้านนอก และ "Payable" กำหนดลักษณะของการเคลื่อนไหว นั่นคือ เพื่อรับโทเค็น ERC-20

ฟังก์ชัน release() public { - นี่คือฟังก์ชันสาธารณะที่ระบุการเคลื่อนไหวของ ERC-20 โทเค็นจากที่อยู่ของสัญญาไปยังผู้รับผลประโยชน์ ฟังก์ชันนี้ขึ้นอยู่กับ releaseTime

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

เข้าใจองค์ประกอบก่อนที่คุณจะวางแผนทำสัญญาอัจฉริยะ: BeInCrypto

DApps และสัญญาอัจฉริยะ: ความสัมพันธ์

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

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

บล็อกเชนสำหรับสัญญาอัจฉริยะ

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

แต่ก่อนอื่นเรามาพูดถึงEthereum— แพลตฟอร์มที่นักพัฒนาสัญญาอัจฉริยะส่วนใหญ่เลือก

อีเธอเรียม

สัญญาอัจฉริยะบน Ethereum เขียนด้วยภาษาโปรแกรม Solidity และอินเทอร์เฟซโทเค็นสําหรับแพลตฟอร์มการพัฒนาสัญญาอัจฉริยะนี้คือ ERC-20

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

การเปิดตัวเหรียญ ERC-20 บนบล็อกเชน Ethereum เป็นคุณลักษณะที่ใช้สัญญาอัจฉริยะอย่างสม่ำเสมอ ซึ่งเราจะพูดถึงอย่างละเอียดขณะเขียนสัญญาอัจฉริยะ

นี่คือโครงสร้างของรหัสพื้นฐานที่ดูเหมือนอย่างไร หากเราวางแผนที่จะเปิดตัวสกุลเงินดิจิตอล BIC ใหม่

พิจารณาเป็นสถานการณ์ที่เป็นสมมติ ไม่ได้เปิดตัวสกุลเงินดิจิตัล BIC แบบจริงจัง

pragma solidity ^0.8.0;import "@openzeppelin/contracts/token/ERC20/ERC20.sol";contract BICToken is ERC20 {    constructor(uint256 initialSupply) ERC20("BIC Token", "BIC") {        _mint(msg.sender, initialSupply);    }}

เราจะพูดถึงทุกองค์ประกอบของรหัสนี้ในภายหลังเมื่อเขียนสัญญาอัจฉริยะของเรา

บล็อกเชนอื่น ๆ

เช่นเดียวกับ Ethereum, คุณสามารถสร้างสัญญาอัจฉริยะบนแพลตฟอร์มเช่น Gate ได้Solana, โดยใช้ Rust และ Cardano, โดยใช้ Plutus, ซับเซ็ตของ Haskell — ภาษาโปรแกรมมิ่งแบบฟังก์ชัน

"Cordona มีสัญญาอัจฉริยะด้วยหรือไม่"
มุขอยู่ที่คุณเพื่อน#CardanoADA pic.twitter.com/j8SXCu72Sd
— Willybot 🇦🇺 (@wilbot28) 9 กรกฎาคม 2023

นี่คือโครงสร้างของรหัสใน Rust ( Solana) ดูเหมือนว่า:

หมายเหตุ: นี่คือสัญญาที่เรียบง่ายที่นับเพิ่มขึ้น

use anchor_lang::prelude::*;declare_id!(“Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS”);#[โปรแกรม] pub mod hello_world {use super::*;pub fn initialize(ctx: Context<Initialize>) -> ProgramResult {    let greeting_account = &mut ctx.accounts.greeting_account;    greeting_account.counter = 0;    Ok(())}pub fn increment(ctx: Context<Increment>) -> ProgramResult {    let greeting_account = &mut ctx.accounts.greeting_account;    greeting_account.counter += 1;    Ok(())}}

คุณรู้หรือไม่? ในขณะที่ Rust เป็นภาษาโปรแกรมสำหรับสร้างสัญญาอัจฉริยะที่มีพื้นฐานมาจาก Solana สมัยเป็นโครงสร้างการพัฒนาสัญญาอัจฉริยะที่ใช้กัน สำหรับการสร้างสัญญาอัจฉริยะโดยใช้ Rust, นักพัฒนาต้องดึงโมดูลจากกรอบ Anchor — บางอย่างในบรรทัดแรกของโค้ดตัวอย่างของเรา (use anchor_lang::*;) stands for.

เอกสาร Solanaจะช่วยให้คุณเข้าใจภาษาสัญญาอัจฉริยะที่เฉพาะเจาะจงของ Rust

โดยเช่นเดียวกัน คาร์ดาโนตาได้ตาม Plutus เป็นภาษาที่เลือกใช้ ตามด้วยภาษา Ink!Polkadot, TEAL for Algorand, C# for NEO, และอื่น ๆ การเรียนรู้เอกสารแบบลึกลับตามโซ่เป็นสิ่งที่ควรทำก่อนที่จะดำเนินการเขียนสัญญาอัจฉริยะที่เข้ากันได้

ทำไมคุณควรเรียนรู้การอ่านสัญญาอัจฉริยะ?

ความสามารถในการเขียนสัญญาอัจฉริยะได้รับการยอมรับอย่างสูง แต่การสามารถในการอ่านก็มาพร้อมกับประโยชน์ของตัวเอง

1. ความสามารถในการเรียนรู้เกี่ยวกับความซับซ้อนของระบบอัตโนมัติที่เกี่ยวข้องกับแอป DeFi
2. วิเคราะห์มาตรฐานการเป็นเจ้าของที่เกี่ยวข้องกับทรัพย์สินการทำให้เป็นโทเค็น.
3. เข้าใจว่าองค์การอัตโนมัติแบบกระจาย (DAOs)ฟังก์ชัน
4. เข้าใจและนำมาใช้ตามตรรกะที่เกี่ยวข้องกับประกัน การจำหน่ายเนื้อหาโหวตระบบ, ค่าสิทธิ์รายได้ และด้านอื่น ๆ

วิธีเขียนสัญญาอัจฉริยะ

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

สำหรับส่วนใหญ่ของการสนทนาของเรา เราจะเน้นที่อีเทอเรียมเป็นโซ่และซอลิดิตี้เป็นภาษา

บทบาทของโปรแกรมมิ่ง

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

บล็อกเชนที่แตกต่างกันและภาษาที่ใช้เขียนสัญญาอัจฉริยะ: BeInCrypto

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

EVM และสัญญาอัจฉริยะ: ภูมิทัศน์

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

หากคุณต้องการเป็นนักพัฒนาสัญญาอัจฉริยะ นี่คือสิ่งที่คุณต้องทราบเกี่ยวกับสัญญาอัจฉริยะและ EVM

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

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

ใครก็สามารถเขียนสัญญาอัจฉริยะได้หรือ

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

ทั้งหมดทั้งนั้นอาจกลายเป็นภาระที่หนักมาก ดังนั้นนี่คือแผ่นปฏิบัติการช่วยเริ่มต้นที่รวดเร็ว:

1. เริ่มต้นด้วยการเลือกแพลตฟอร์มหรือเชนที่คุณต้องการทำงาน
2. เรียนรู้ภาษาโปรแกรมที่เกี่ยวข้องกับเชน เช่น Solidity สำหรับ Ethereum
3. เรียนรู้เกี่ยวกับการใช้เครื่องมือพัฒนา เช่น สภาพแวดล้อมการพัฒนาที่รวมอยู่ เช่น Remix
4. เริ่มต้นโดยเขียนสัญญาแรกของคุณ แล้วทดสอบโดยใช้ testnets
5. เมื่อคุณพอใจกับองค์ประกอบของโค้ดแล้ว คุณสามารถใช้งานบนเชื่อมโยงได้ โปรดจำไว้ว่าการใช้งานสัญญาบนเชื่อมโยงจะมีค่าในรูปของค่าธรรมเนียมแก๊ส

นี่คือเรื่องสั้น ๆ ที่มีเคล็ดลับบางประการที่จะช่วยให้เขียนสัญญาอัจฉริยะได้ดีขึ้น:

🥧 FREI-PI
‼️ ทำไมนักพัฒนาสัญญาอัจฉริยะจำเป็นต้องรู้เรื่องนี้!
ฟังก์ชัน:
– ข้อกำหนด
– ผลกระทบ
– การโต้ตอบ
โปรโตคอล
– อินวาเรียนต์
นี่คือแบบที่คุณควรคิดถึงเมื่อสร้างสัญญาอัจฉริยะทั้งหมด
นี่คือเหตุผลที่ 👇
— Patrick Collins (@PatrickAlphaC)6 กรกฎาคม 2566

การดำเนินงานเข้าสู่โปรแกรม

มันเป็นเวลาที่จะเข้าสู่ด้านเทคนิคของการพัฒนาสัญญาอัจฉริยะ แม้ว่าเช่น Solana และ Cardano จะช่วยให้คุณสามารถพัฒนาสัญญาอัจฉริยะได้ แต่ Ethereum ยังคงเป็นแพลตฟอร์มการพัฒนาสัญญาอัจฉริยะที่ได้รับความนิยมมากที่สุด

คุณรู้หรือไม่? ในปี 2022 เพียงอย่างเดียว มีกว่า 100,000 แอปพลิเคชันที่ไม่มีส่วนรวมทั่วไปเข้าสู่เครือข่าย Ethereum

ทำไมถึงเลือกใช้ Ethereum?

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

หากคุณเป็นคนส่วนใหญ่และชอบใช้ Ethereum และ Solidity นี่คือรายการสั้น ๆ ของสิ่งที่คุณต้องติดตามก่อนที่จะเริ่มการพัฒนาสัญญาอัจฉริยะ

1. Pragmas หรือเวอร์ชันของคอมไพเลอร์
2. คำจำกัดความสำหรับการติดป้ายชื่อสัญญา
3. ตัวแปรสถานะสำหรับเก็บข้อมูล
4. เหตุการณ์สำหรับการบันทึก EVM
5. ตัวปรับเปลี่ยนเพื่อให้สิทธิ์เฉพาะกับหน่วยงานที่เฉพาะเจาะจง
6. ฟังก์ชันหรือกิจกรรมของสัญญาอัจฉริยะที่เล่น
7. การสืบทอดสำหรับความสามารถในการทำงานร่วมกัน
8. ความเข้าใจของโครงสร้างควบคุมเช่น if, else, for loops, ประเภทข้อมูลเช่น string, integer, และอื่น ๆ

เขียนและจัดการสร้างสัญญาอัจฉริยะครั้งแรก

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

พื้นฐาน

ขั้นตอนแรกคือการติดตั้งเวอร์ชันล่าสุดของ Node.js และ NPM หรือ Node Package Manager นี้จะดูแลเครื่องมือพัฒนาและสภาพแวดล้อมท้องถิ่นสำหรับการพัฒนา นอกจากนี้ Node.js และ NPM ยังช่วยให้คุณสามารถตั้งค่าส่วนหน้าเว็บสำหรับสัญญาอัจฉริยะของคุณ

ตอนนี้คุณต้องตั้ง IDE เพื่อเขียนโค้ดสัญญา สำหรับนั้นคุณสามารถติดตั้ง Visual Studio Code ได้อย่างรวดเร็ว หรือคุณสามารถตัดข้อความและhopไปที่ Alchemy — แพลตฟอร์มการพัฒนาบล็อกเชน ด้วย Alchemy คุณสามารถรับ ETH เวอร์ชันเทสเน็ตได้บางส่วน นี้จะช่วยปกป้องค่าธรรมเนียมการใช้ gas เมื่อคุณใช้งานสัญญาอัจฉริยะบนเทสเน็ต Goerli หรือแม้แต่เทสเน็ต Sepolia

โปรดทราบว่า Sepolia เป็นเครือข่ายทดสอบรุ่นใหม่และดังนั้นใช้พื้นที่ดิสก์น้อยกว่าเมื่อเป็นการติดตั้งโหนด

ในขณะนี้เราจะยึดถือกับ Goerli testnet เนื่องจากมันมีจำนวนของการประยุกต์ใช้ที่ถูกติดตั้งมากกว่า

พร้อมกับ testnet และ fake ETH พร้อม ให้เราเริ่มเขียนสัญญาอัจฉริยะโดยเฉพาะ นี่คือโค้ดสำหรับการสร้างโทเค็น BIC ด้วยการจำหน่ายคงที่ 1 ล้าน

หมายเหตุ: เราจะนำสัญญาอัจฉริยะของเราไปใช้งานในเครื่อง Mac และไม่ใช่ที่เทสเน็ต สำหรับการใช้งานสัญญาอัจฉริยะในเทสเน็ตและเมนเน็ตเราจะมีส่วนต่าง ๆ ที่เป็นนอกเหนือจากขอบเขตของการสนทนานี้

ขั้นตอนในการเขียนและติดตั้ง

นี่คือโค้ดตัวอย่างที่ง่ายสำหรับโทเค็นที่เป็นสมมติ

pragma solidity ^0.8.0;import "@openzeppelin/contracts/token/ERC20/ERC20.sol";contract BICToken is ERC20 {    constructor() ERC20("BIC Token", "BIC") {        _mint(msg.sender, 1000000 * 10 ** decimals());    }}

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

ฟังก์ชัน mint พูดถึงการจัดหาเงินเริ่มต้นซึ่งถูกสร้างขึ้นที่ที่อยู่ของสัญญาอัจฉริยะหรือผู้ส่งข้อความ

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

1. Node.js และ NPM (ที่ถูกพูดถึงแล้ว): ทำงานเหมือนเครื่องยนต์เพื่อขับเคลื่อนสัญญาอัจฉริยะของคุณ
2. Truffle: ทำงานเหมือนกล่องเครื่องมือ ช่วยให้คุณจัดระเบียบโค้ด สคริปต์ และส่วนอื่น ๆ ของสัญญา
3. Ganache: ทำงานเหมือนเป็นสนามเด็กเล่นเสมือนเสมือนบนอุปกรณ์ คิดว่ามันเหมือนบล็อกเชนส่วนตัว

การดำเนินการสัญญาคืออะไร?

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

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

ขั้นตอนที่ 1

โค้ดส่วนย่อยที่เราเขียนต้องถูกดำเนินการที่ที่ใดบางแห่ง ในกรณีของสัญญาอัจฉริยะ สถานที่ดำเนินการคือบล็อกเชน โหนดหรือสมาชิกที่เข้าร่วมในเชนช่วยดำเนินการสัญญา

ขั้นตอนที่ 2

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

ขั้นตอนที่ 3

ทุกสัญญาอัจฉริยะมีที่อยู่เฉพาะ สำหรับการดำเนินการสัญญา ธุรกรรมจะถูกส่งไปยังที่อยู่สัญญานั้น ๆ โปรดทราบว่าทุกโหนดทำงานกับ EVM ซึ่งจะมีสำเนาของรหัสสัญญาอัจฉริยะ ทำให้ง่ายต่อการตรวจสอบความถูกต้องของธุรกรรม

ขั้นตอนที่ 4

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

ขั้นตอนที่ 5

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

ขั้นตอนที่ 6

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

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

ทุกการเปลี่ยนแปลงของรัฐบาลที่เกี่ยวข้องกับสัญญาอัจฉริยะถูกบันทึกไว้ในบล็อกเชนและกลายเป็นส่วนที่ไม่สามารถเปลี่ยนแปลงได้ของเดียวกัน

การพัฒนาสัญญาอัจฉริยะและปฏิบัติที่ดีที่สุด

ตอนนี้ที่คุณทราบอยู่เกี่ยวกับสัญญาอัจฉริยะอย่างมีความรู้ นี่คือบางข้อแนะนำเพื่อเริ่มต้นในการพัฒนาสัญญา:

1. ขณะเขียนสัญญา การพึ่งพาที่ไว้วางใจในห้องสมุดที่เชื่อถือได้ เช่น OpenZeppelin เพื่อปฏิบัติตามมาตรฐานการปรับปรุงโค้ดและมาตรฐานด้านความปลอดภัยที่ต้องการ นั้นเป็นสิ่งที่ควรทำ
2. ความคิดคือการเก็บสัญญาให้เป็นโมดูลและง่ายขึ้น - ทำให้ง่ายต่อการทดสอบและตรวจสอบ
3. ความคิดที่ดีคือการใช้การควบคุมการเข้าถึงที่เฉพาะกับสัญญา นั่นหมายความว่าการประกาศรหัสที่มีบทบาทที่เฉพาะเจาได้สามารถเปลี่ยนแปลงลักษณะที่สำคัญของสัญญาได้เท่านั้น การควบคุมการเข้าถึงทำให้ง่ายต่อการรักษาความปลอดภัยของสัญญาอัจฉริยะ
4. ขณะเขียนสัญญา ควรเตรียมการให้ความสำคัญกับกรณีพิเศษและข้อยกเว้นทั้งหมดในขณะที่เขียนการทดสอบหลายรายการ

ดูแลรักษาความยั่งยืนของโค้ด

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

1. จัดการพื้นที่จัดเก็บอย่างมีประสิทธิภาพโดยใช้ชุดข้อมูลขนาดเล็ก ตัวอย่างเช่น ในขณะเขียนสัญญา ใช้ uint8 เป็นค่าการดำเนินการแทน uint256
2. ขณะเขียนสัญญา ควรปรับปรุงรหัสโดยการรวมการดำเนินการหลาย ๆ อย่างเข้าด้วยกัน เราจะศึกษาลึกลงไปในเรื่องนี้ในบทความที่ละเอียดเกี่ยวกับ "การเขียนสัญญาอัจฉริยะ"
3. ควรใช้การประเมินแบบเฉื่อยในการดำเนินการสัญญาอัจฉริยะ โดยที่คุณจะต้องดำเนินการฟังก์ชันเมื่อจำเป็น และไม่ใช้ทุกครั้งที่มีบางสิ่งถูกผลักดันเข้าสู่ที่อยู่สัญญาอัจฉริยะ
4. ในที่สุดการพึ่งพาการคำนวณนอกเชือก ยังเป็นวิธีที่ดีในการให้ความสำคัญกับเรื่องความยั่งยืน สิ่งนี้ช่วยลดค่าธรรมเนียมแก๊สและอาจเร่งความเร็วในการดำเนินการสัญญาอัจฉริยะ

แม้จะปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดในขณะที่เขียนและพัฒนาสัญญาอัจฉริยะ แต่ก็จําเป็นต้องมุ่งเน้นไปที่ช่องโหว่ด้านความปลอดภัยของสัญญาในขณะที่ผลักดันพวกเขาไปยังเครือข่ายหลัก

วิธีตรวจสอบสัญญาอัจฉริยะ?

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

นี่คือรายการตรวจสอบด่วนเพื่อเริ่มต้น:
รายการตรวจสอบสัญญาอัจฉริยะที่น่าทึ่ง😈
โปรดตรวจสอบเช็คเค้าในการตรวจสอบครั้งถัดไปของคุณ✅
ฉันขอความกรุณาให้ทวีตออกไป กระจายความรู้🫡https://t.co/ILx0C67kf8
— cholakov (@cholakovv) 7 กรกฎาคม 2023

ความสัมพันธ์ระหว่างการอ่าน เขียน และตรวจสอบ: ทำไมต้องตรวจสอบสัญญาอัจฉริยะ?

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

ช่องโหว่ของสัญญาและการแก้ไข

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

การละเมิด การศึกษาเคส และการเรียนรู้

ยังไม่แน่ใจว่าการตรวจสอบสัญญาอัจฉริยะจะช่วยเหลืออย่างไร? ดีให้เรากลับมาสู่ DAOการโจมตีในปี 2016 ซึ่งใช้ช่องโหว่ reentrancy และทำให้ ETH สูญเสียเกือบ 3.6 ล้าน ETH ในทางเดียวกัน มีการโจมตีสัญญากระเป๋า Parity ในปี 2017 ทำให้สูญเสียเกือบ 500,000 ETH เหตุการณ์เหล่านี้สามารถหลีกเลี่ยงได้ด้วยการตรวจสอบชุดที่ถูกต้อง

แผนภูมิการโจมตี DAO: BeInCrypto

กลยุทธ์ในการตรวจสอบสัญญาอัจฉริยะ

มีกลยุทธ์หลายวิธีในการตรวจสอบสัญญาอัจฉริยะ บางอันได้รับความนิยมมากมาย เช่น:

เครื่องมือตรวจสอบ

เครื่องมือเหล่านี้ทำหน้าที่เป็นชุดป้องกันแรก และเหมาะที่สุดสำหรับการค้นหาช่องโหว่ที่พบบ่อย บางส่วนของเครื่องมือที่นิยมมาก รวมถึง Securify, Mythril, และอื่น ๆ — สามารถทำการวิเคราะห์แบบคงที่ของโค้ด ตรวจจับรูปแบบการละเมิด และช่วยให้มีการเริ่มต้นด้านความปลอดภัยที่เฉพาะเจาะจง

เครื่องมือในการตรวจสอบสัญญาอัจฉริยะ: BeInCrypto

การทบทวนโค้ด

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

นี่คือวิธีที่การตรวจสอบโค้ดด้วยมือช่วยคุณในการค้นหาความเสี่ยง

คำถามเล็กๆ สำหรับผู้ตรวจสอบระดับประถมของเรา!
มาเราไปและทวีตอีกครั้งถ้าคุณพบบั๊ก!pic.twitter.com/i14YtweXcz
— CharlesPaladin (@PaladinCharles) 8 กรกฎาคม 2566

การสแกนอัตโนมัติ

เครื่องมือเช่น Snyk และ GuardRails ช่วยในการสแกนสัญญาโดยอัตโนมัติ - การปฏิบัติความปลอดภัยที่ถูกเรียกใช้ทุกครั้งที่มีการอัปเดตโค้ด รูปแบบการตรวจสอบนี้ทำให้มั่นใจว่าการเปลี่ยนแปลงใหม่ๆ ที่ทำกับโค้ดเป็นอันตราบและไม่มีผลกระทบ

การยืนยันทางกฎหมาย

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

นอกจากกลยุทธ์ที่กล่าวถึงข้างต้นแล้ว การตรวจสอบสัญญาอัจฉริยะยังสามารถเริ่มต้นได้โดยใช้การทบทวนโดยเพื่อนร่วมงาน โปรแกรม bug bounty และการ cover test ผ่านเครื่องมือเช่น Solidity Coverage เพื่อเพิ่มประสิทธิภาพสูงสุด

วิธีง่าย ๆ ในการตรวจสอบสัญญาอัจฉริยะ: BeInCrypto

วิธีตรวจสอบโค้ดถูกต้อง

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

การวิเคราะห์แบบคงที่

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

การวิเคราะห์เคลื่อนไหว

วิธีการตรวจสอบนี้จะทดสอบการจัดตําแหน่งของรหัสกับ EVM แทนที่จะตรวจสอบเฉพาะรหัสการวิเคราะห์แบบไดนามิกจะตรวจสอบการตอบสนองของสัญญาอัจฉริยะต่ออินพุตที่หลากหลาย การวิเคราะห์แบบไดนามิกสามารถระบุปัญหาต่างๆเช่นการใช้ก๊าซที่ไม่สอดคล้องกันและแม้แต่ตรรกะสัญญาที่ผิดพลาด สภาพแวดล้อมบล็อกเชนส่วนบุคคลเช่น Ganache สามารถทํางานเป็นแพลตฟอร์มการวิเคราะห์แบบไดนามิกช่วยให้นักพัฒนาสามารถทําธุรกรรมดําเนินการคําสั่งและทําสิ่งต่างๆได้มากขึ้นกับสัญญาของพวกเขา

ทดสอบรหัสจริง

นี่คือโค้ดสัญญาอัจฉริยะที่ทำงานเป็นการเก็บเงินกองทุน มีฟังก์ชันการถอน

pragma solidity ^0.6.1;contract VulnerableContract {    mapping(address => uint256) public balances;    function deposit() public payable {        balances[msg.sender] += msg.value;    }    function withdraw(uint256 _amount) public {        require(balances[msg.sender] >= _amount, "Insufficient balance.");        (bool success, ) = msg.sender.call{value: _amount}("");        require(success, "Transfer failed.");        balances[msg.sender] -= _amount;    }}

หากคุณสังเกตรหัสโค้ดอย่างใกล้ชิด จะพบว่ามีจุดอ่อนสำคัญ:

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

นี่คือโค้ดที่แก้ไขแล้วสำหรับเหมือนกัน:

function withdraw(uint256 _amount) public {    require(balances[msg.sender] >= _amount, "ยอดคงเหลือไม่เพียงพอ");    balances[msg.sender] -= _amount;    (bool success, ) = msg.sender.call{value: _amount}("");

require(success, “โอนเงินล้มเหลว”);}

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

โซ่ที่ไม่ใช่ Ethereum และการทบทวนโค้ด

โลกของแอปพลิเคชันแบบกระจายอํานาจและสัญญาอัจฉริยะได้ก้าวไปไกลกว่า Ethereum แม้ว่าการดําเนินการจํานวนมากยังคงเกิดขึ้นภายในระบบนิเวศของ Ethereum แต่ก็มีเครือข่ายอื่น ๆ เช่น Cardano, Solana และอื่น ๆ ที่รองรับสัญญาอัจฉริยะและต้องการมาตรฐานการตรวจสอบที่แตกต่างกัน

ทําไมทุกแพลตฟอร์มถึงไม่ซ้ํากัน?

บล็อกเชนที่แตกต่างกันใช้ภาษาการเขียนโปรแกรมที่แตกต่างกัน ความหมาย ไวยากรณ์ และคุณสมบัติของโค้ดนั้นแตกต่างกัน ทําให้สัญญาอัจฉริยะตอบสนองต่อการเขียนและการตรวจสอบที่แตกต่างกัน ตัวอย่างเช่น Ethereum ใช้ Solidity ในขณะที่ Polkadot ใช้ Ink และ Rust ทําให้ตอบสนองต่อมาตรฐานการตรวจสอบเฉพาะ

เครื่องมือสําหรับการไม่ใช้ Ethereum

ตอนนี้หากคุณต้องการก้าวข้ามจาก Ethereum มีเครื่องมือตรวจสอบที่เฉพาะทางเพียงเล็กน้อยที่จะช่วยคุณเริ่มต้น ตัวอย่างเช่น กับ Cardano มีชุด Marlowe สำหรับการตรวจสอบแบบเชิงรูปแบบและการตรวจสอบ ในกรณีของ Solana libfuzzer และ cargo-fuzz ที่เฉพาะของ Rust ใช้สำหรับการตรวจสอบและทดสอบสัญญา ผู้ตรวจสอบหลายๆ โซนต้องเรียนรู้เกี่ยวกับแนวความคิดเหล่านี้เพื่อป้องกันช่องโหว่ของสัญญา

มีประเภทต่าง ๆ ของการตรวจสอบสัญญาอัจฉริยะอย่างไรบ้าง

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

การออกแบบการตรวจสอบของคุณ

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

นอกจากนี้ นี่คือปัจจัยที่ควรระวังขณะจะออกแบบงานตรวจสอบ

การเลือกบริษัทที่เหมาะสม

ก่อนที่คุณจะเลือกบริษัทที่จะออกแบบด้านนอกที่เหมาะสม สำคัญที่จะตรวจสอบการตรวจสอบในอดีต ประเมินประสบการณ์ และให้ความสำคัญกับสมาชิกทีมหลัก

เข้าใจความรับผิดชอบ ค่าใช้จ่าย และค่าใช้จ่ายในการดำเนินงาน

ก่อนทําการว่าจ้างให้จดบันทึกค่าใช้จ่ายและบริการที่เกี่ยวข้องกับการตรวจสอบ จําเป็นต้องเข้าใจลักษณะของบริการที่นําเสนอก่อนเช่นการระบุปัญหาการแก้ไขปัญหาและอื่น ๆ คุณต้องตรวจสอบด้วยว่ามีการตรวจสอบซ้ําหรือไม่หลังการดําเนินการแก้ไขบรรทัดแรกหรือไม่ ค่าใช้จ่ายในการตรวจสอบสัญญาอัจฉริยะอาจแตกต่างกันไปขึ้นอยู่กับบริการดังนั้นจึงจําเป็นต้องติดตามทุกข้อกําหนดและข้อเสนอก่อนดําเนินการต่อ

ปฏิบัติการตรวจสอบสัญญาอัจฉริยะที่ดีที่สุด

ในกรณีที่คุณต้องการทิ้งบริษัทและตรวจสอบสัญญาอัจฉริยะเอง นี่คือกลยุทธ์และปฏิบัติที่ดีที่สุดที่ควรจำไว้

1. เน้นการทบทวนโค้ดอย่างละเอียดเช่น ไวยากรณ์และตรรกะ
2. เริ่มต้นด้วยการใช้เครื่องมือเช่น Slither, MythX, และอื่น ๆ เพื่อตรวจจับช่องโหว่ที่พบบ่อย
3. ท่องไปที่ลงทะเบียนการจำแนกความเสี่ยงของสัญญาอัจฉริยะหรือ SWC เพื่อค้นหาช่องโหว่ที่รู้จักและตรวจสอบเพื่อเตรียมตรวจสอบล่วงหน้า
4. ทดสอบสัญญาอัจฉริยะอย่างเข้มข้น รวมถึงการทดสอบการรวมตัว การทดสอบหน่วย และอื่น ๆ เพื่อทดสอบโค้ดในสถานการณ์หลากหลาย
5. สำคัญที่จะตรวจสอบโอกาสของการโจมตี reentrancy โดยเฉพาะ วิธีที่ดีที่สุดในการต่อสู้กับสิ่งเดียวกันคือการตรวจสอบการเรียกตัวเองที่มีความสามารถที่ผู้โจมตีสามารถเรียกใช้ก่อนฟังก์ชันสัญญาอัจฉริยะครั้งแรก
6. เน้นฟังก์ชันที่ทำให้เกิดการเรียกภายนอก ข้อผิดพลาดในเชิงนี้อาจเปลี่ยนแปลงสถานะและการควบคุมได้ ซึ่งไม่ควร
7. ควรเฝ้ามองรหัสบิตที่ชี้ไปที่การใช้ก๊าซเสมอ เราไม่ต้องการที่จะให้สัญญาของคุณเริ่มทำปฏิสัมพันธ์ที่มีราคาแพงมาก

การพัฒนาสัญญาอัจฉริยะและ AI: อนาคต

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

ข้อความปฏิเสธความรับผิดชอบ:

1. บทความนี้ถูกคัดลอกมาจาก [Beincrypto], and the copyright belongs to the original author [Ananda Banerjee]. If there are objections to the reproduction, please contact the Gate Learn team, and the team will process it promptly according to relevant procedures.
2. คำประกาศ: มุมมองและความคิดเห็นที่แสดงอยู่ในบทความนี้แทนเฉพาะมุมมองส่วนตัวของผู้เขียนเท่านั้น และไม่เป็นที่สำหรับการให้คำแนะนำทางการลงทุนใดๆ
3. เวอร์ชันภาษาอื่น ๆ ของบทความถูกแปลโดยทีม Gate Learn ห้ามคัดลอก กระจายหรือลอกเลียนบทความที่ถูกแปลโดยไม่ระบุ Gate.io