การเขียนและการปรับใช้สัญญาอัจฉริยะสำหรับนักพัฒนา

by

การเขียนและการปรับใช้สัญญาอัจฉริยะสำหรับนักพัฒนา

บทนำ

ในฐานะนักพัฒนาบล็อกเชนผู้ช่ำชอง ฉันสามารถพูดได้อย่างมั่นใจว่า Uniswap เป็นตัวอย่างที่ชัดเจนของพลังและศักยภาพของการเงินแบบกระจายอำนาจ (DeFi) แนวทางใหม่ในการซื้อขายโทเค็นผ่านผู้สร้างสภาพคล่องอัตโนมัติ (AMM) และกลุ่มสภาพคล่องได้ปฏิวัติวิธีที่เราโต้ตอบกับสินทรัพย์ดิจิทัล

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

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

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

เหตุใดคุณจึงควรเขียนและปรับใช้ Smart Contracts สำหรับ dApps

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

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

เครื่องมือการพัฒนาและการตั้งค่าสภาพแวดล้อม

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

สภาพแวดล้อมการพัฒนาแบบรวม (IDE):

นักพัฒนาส่วนใหญ่มักจะเลือกจากสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) ที่หลากหลายเมื่อเป็นเรื่องของการสร้างและทดสอบสัญญาอัจฉริยะ อย่างไรก็ตาม ตัวเลือกอันดับต้นๆ บางส่วนได้แก่:

  • รีมิกซ์: รีมิกซ์เป็น IDE ออนไลน์ที่รวบรวมไว้เป็นพิเศษสำหรับสัญญาอัจฉริยะ Solidity และมีอินเทอร์เฟซแบบโต้ตอบและเครื่องมือแก้ไขข้อบกพร่องที่มีประสิทธิภาพ Remix มอบประสบการณ์ที่ไม่ยุ่งยากให้กับคุณ และไม่จำเป็นต้องกำหนดค่าใดๆ เพียงเยี่ยมชมเว็บไซต์และเริ่มเขียนโค้ด
  • VS Code: Vs Code เป็น IDE ที่นักพัฒนาทุกคนใช้ซึ่งมีความเข้ากันได้กับภาษาต่างๆ และมีส่วนขยายสำหรับ Solidity ด้วยเช่นกัน มีสภาพแวดล้อมที่หลากหลายสำหรับการพัฒนาและสามารถผสานรวมกับเครื่องมือและปลั๊กอินอื่นๆ ได้อย่างราบรื่น 

วิธีตั้งค่ารหัส VS: 

  • ดาวน์โหลดได้จากเว็บไซต์อย่างเป็นทางการ
  • ปฏิบัติตามคำแนะนำบนหน้าจอ
  • ติดตั้งส่วนขยาย Solidity ทั้งหมดที่จำเป็นในการเขียนสัญญาอัจฉริยะ 

กรอบงานและไลบรารี:

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

  • Truffle: เป็นกรอบการพัฒนาที่ให้ชุดเครื่องมือสำหรับการพัฒนา การคอมไพล์ การเชื่อมโยง และการปรับใช้สัญญาอัจฉริยะ
  • Hardhat: Hardhat เป็นตัวเลือกยอดนิยมในหมู่นักพัฒนาเนื่องจากมีคุณสมบัติเช่นความยืดหยุ่นและความสามารถในการขยายได้ นอกจากนี้ยังมีตัวรันงานแบบรวมและความสามารถในการจัดการเครือข่ายและสามารถขยายฟังก์ชันการทำงานผ่านปลั๊กอินได้
  • บราวนี่: บราวนี่เป็นเฟรมเวิร์กที่ใช้ Python สำหรับการพัฒนาสัญญาอัจฉริยะของ Ethereum
  • การตั้งค่าเฟรมเวิร์กเป็นเพียงการเขียนคำสั่งเหล่านี้ในเทอร์มินัลของคุณ และคุณก็พร้อมที่จะดำเนินการแล้ว:
ติดตั้ง Node.js และตั้งค่า npm
ติดตั้ง Truffle: npm
ติดตั้ง -g truffleติดตั้ง Hardhat:  install -save-dev hardhat
b>
ติดตั้ง Ganache
pip ติดตั้ง eth-brownie

วงจรชีวิตของสัญญาอัจฉริยะ:

มาดูวงจรชีวิตของสัญญาอัจฉริยะกันดีกว่า

การเขียนและการปรับใช้สัญญาอัจฉริยะสำหรับนักพัฒนา

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

ตอนนี้ เรามาเข้าสู่ส่วนที่สนุกกันดีกว่า—การเขียนสัญญาอันชาญฉลาดฉบับแรกของคุณ! 

โครงสร้างสัญญา:

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

 สัญญาอัจฉริยะประกอบด้วยองค์ประกอบดังต่อไปนี้:

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

นี่คือโครงสร้างที่เป็นลายลักษณ์อักษรของ Smart Contract:

ความแข็งแกร่งของ Pragma ^0.8.0;
สัญญา SimpleStorage {    uint256 ข้อมูลสาธารณะที่เก็บไว้; //ตัวแปรสถานะ

เหตุการณ์ DataStored (ข้อมูล uint256); //เหตุการณ์

ชุดฟังก์ชั่น (uint256 x) สาธารณะ { //ฟังก์ชั่น        
ข้อมูลที่เก็บไว้ = x ;        
ปล่อย DataStored(x);   
 }
    ฟังก์ชั่นรับผลตอบแทนมุมมองสาธารณะ (uint256) {        
ส่งคืนข้อมูลที่เก็บไว้;    
}
}

รูปแบบการออกแบบทั่วไป:

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

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

ตัวอย่างข้อมูลโค้ด

ความแข็งแกร่งของ Pragma ^0.8.0;
โทเค็นสัญญา {    string ชื่อสาธารณะ;

ตัวสร้าง (หน่วยความจำสตริง _name) {        
name = _name;    
}
}
สัญญา TokenFactory {    
โทเค็น [] โทเค็นที่ปรับใช้สาธารณะ;

ฟังก์ชัน createToken(หน่วยความจำสตริง _name) สาธารณะ {        
โทเค็น newToken = โทเค็นใหม่ (_name); // สร้างสัญญาโทเค็นใหม่
อินสแตนซ์        

deployedTokens.push(newToken); // เก็บอินสแตนซ์ไว้ในอาร์เรย์    
}
}

ฟังก์ชัน TokenFactory ใช้เพื่อจัดเก็บค่าของโทเค็นสัญญาแบบไดนามิก

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

ตัวอย่างข้อมูลโค้ด

pragma solidity ^0.8.0;

contract Proxy {    
กล่าวถึงการใช้งานสาธารณะ; // ที่อยู่ของการใช้งานปัจจุบัน

การอัปเกรดฟังก์ชัน (ที่อยู่ _newImplementation) สาธารณะ {        
การใช้งาน = _การใช้งานใหม่; // อัปเกรดตรรกะ    
}
    สำรองเจ้าหนี้ภายนอก {        
ที่อยู่ _impl = การดำเนินการ;        
ต้องการ(_impl != ที่อยู่(0));        
(บูลสำเร็จ ) = _impl.delegatecall(msg.data); // มอบหมายการเรียกใช้การดำเนินการ        require(success);    
}
}

คุณลักษณะขั้นสูง:

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

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

การรักษาความปลอดภัยสัญญาอัจฉริยะ

ช่องโหว่ทั่วไป:

ความปลอดภัยเป็นสิ่งสำคัญยิ่งของ Blockchain ดังนั้นการนำแนวทางปฏิบัติด้านความปลอดภัยที่ดีที่สุดมาใช้จึงเป็นสิ่งจำเป็น สัญญาที่ชาญฉลาดถือเป็นมูลค่าที่แท้จริง และความไม่รู้เพียงเล็กน้อยก็สามารถนำไปสู่ผลกระทบที่ยิ่งใหญ่ได้ การแฮ็ก DAO ในปี 2559 เป็นตัวอย่างที่สำคัญของสัญญาที่มีช่องโหว่หากไม่ปฏิบัติตามแนวทางปฏิบัติด้านความปลอดภัยที่ดีที่สุด ช่องโหว่ทั่วไปบางประการในโดเมนนี้คือ Reentrancy และ Integer Overflow/underflow

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

 แนวทางปฏิบัติด้านความปลอดภัยที่ดีที่สุด:

  • ใช้คอมไพเลอร์เวอร์ชันล่าสุด
  • ปฏิบัติตามการตรวจสอบ-ผลกระทบ-การโต้ตอบ
  • จำกัดจำนวนโค้ดในฟังก์ชันทางเลือก
  • ใช้ไลบรารี SafeMath เพื่อป้องกันการล้นและอันเดอร์โฟลว์

การตรวจสอบและการทดสอบ:

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

มิธเอ็กซ์

MythX เป็นเครื่องมือวิเคราะห์ความปลอดภัยที่ทำการสแกนความปลอดภัยในสัญญาอัจฉริยะของคุณ

 ขั้นตอนในการรวม MythX เข้ากับขั้นตอนการพัฒนา:

  • ลงทะเบียนเพื่อรับ MythX
  • กำหนดค่าโครงการของคุณ 
  • ทำการสแกนเพื่อระบุ
  • แก้ไขปัญหาด้านความปลอดภัย                     

เลื้อย

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

ดำเนินการตรวจสอบความปลอดภัยบนสัญญาอัจฉริยะ:

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

ตัวอย่าง:

const { คาดหวัง } = need(“chai”);
describe(“SimpleStorage”, function {    
it(“ควรจัดเก็บ และดึงค่าที่ถูกต้อง” ฟังก์ชัน async {        
const SimpleStorage = await
ethers.getContractFactory(“SimpleStorage”);         < br/>const simpleStorage = รอ SimpleStorage.deploy;        
รอ simpleStorage.set(42);
        คาดหวัง (รอ simpleStorage.get ).to.equal(42);    
});
});

การปรับใช้สัญญาอัจฉริยะ

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

กลยุทธ์การปรับใช้:

การเตรียม Smart Contracts ให้พร้อมสำหรับการเปิดตัว:

การเพิ่มประสิทธิภาพโค้ด: จัดระเบียบและปรับปรุงโค้ดของคุณเพื่อให้ใช้ทรัพยากรน้อยลง (ก๊าซ) ซึ่งจะช่วยลดต้นทุนในการใช้งาน ใช้เครื่องมือ เช่น solc และ hardhat-gas-reporter เพื่อวิเคราะห์ปริมาณการใช้ก๊าซในโค้ดของคุณ

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

กระบวนการปรับใช้โดยใช้ทรัฟเฟิล หมวกแข็ง หรือบราวนี่:

(ทุบตี)
การโยกย้ายแห้ว – เครือข่าย

(หมวกแข็ง)
ฟังก์ชัน async main {    
const SimpleStorage = กำลังรอ
ethers.getContractFactory(“SimpleStorage”);    
const simpleStorage = กำลังรอ SimpleStorage.deploy;    
รอ simpleStorage.deployed;    
console.log(“SimpleStorage ปรับใช้กับ:”, simpleStorage.address);
}

(บราวนี่)
def main: 
SimpleStorage.deploy({‘from’: บัญชี[ 0]})

สคริปต์อัตโนมัติสำหรับการปรับใช้: พัฒนาสคริปต์ที่ทำให้ขั้นตอนการปรับใช้ง่ายขึ้น สคริปต์เหล่านี้จะดูแลการกำหนดค่าการตั้งค่าสำหรับการปรับใช้ตามสัญญาตลอดจนการเริ่มต้นการเริ่มต้นระบบ

ฟังก์ชัน async main {    
const [deployer] = await ethers.getSigners;    
console.log(“กำลังปรับใช้สัญญากับบัญชี:”, Deployer.address);

const SimpleStorage = รอ
ethers.getContractFactory(“SimpleStorage”);    
const simpleStorage = กำลังรอ SimpleStorage.deploy;    
console.log(“ที่อยู่ SimpleStorage:”, simpleStorage.address);
}
main
.then( => process.exit(0))  
.catch((ข้อผิดพลาด) => {    
console.error(ข้อผิดพลาด);    
process.exit(1);  //การกำหนดค่า Hardhat
module.exports = { 

 เครือข่าย: {    
ropsten: {      
url: “https://ropsten.infura.io/v3/YOUR-PROJECT-ID”,      
บัญชี: [`0x${YOUR_PRIVATE_KEY}`]    
},    
mainnet: {      
url : “https://mainnet.infura.io/v3/YOUR-PROJECT-ID”,      
บัญชี: [`0x${YOUR_PRIVATE_KEY}`]    
  

}
};

การตรวจสอบและการตรวจสอบความถูกต้อง:

ใช้บริการเช่น Etherscan เพื่อตรวจสอบและเผยแพร่ซอร์สโค้ดของสัญญาของคุณ

การตรวจสอบ npx hardhat – เครือข่าย mainnet DEPLOYED_CONTRACT_ADDRESS “อาร์กิวเมนต์ตัวสร้าง 1”

การโต้ตอบกับสัญญาที่ปรับใช้

หลังจากที่สัญญาของคุณได้รับการเผยแพร่เรียบร้อยแล้ว คุณจะมีส่วนร่วมกับสัญญาผ่านอินเทอร์เฟซผู้ใช้ที่ส่วนหน้า เครื่องมือเช่น Web3.js และ ethers.js อำนวยความสะดวกในการสื่อสารระหว่างสัญญาอัจฉริยะและ JavaScript

บูรณาการ Web3:

  • เราใช้ Web3.py และ ether.js สำหรับการโต้ตอบกับผู้ติดต่อที่ปรับใช้และการรวมส่วนหน้า
  • นี่คือตัวอย่างโค้ดบางส่วน:
จาก web3 นำเข้า Web3

# เชื่อมต่อกับเครือข่าย Ethereumweb3 = Web3(Web3.HTTPProvider(‘https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID’ ))

# กำหนดสัญญา ABI และที่อยู่
abi =
‘[ {“คงที่”:เท็จ,”อินพุต”:[{“ชื่อ”:”x”,”ประเภท”:”uint256″}],”ชื่อ”:”ชุด”,
“เอาท์พุท”:[],”ต้องชำระ”:false,”stateMutability”:”nonpayable”,”type”:”function”},{“constant”:true,”inputs”:[],”name”:”get ”,”เอาท์พุท”:[{“ชื่อ”:””,”ประเภท”:”uint256″}],”ต้องชำระ”:false,”stateMutability”:”view”,”ประเภท”:”ฟังก์ชั่น”}]’

contract_address = ‘0xYourContractAddress’
# สร้างอินสแตนซ์สัญญา
contract = web3. eth.contract(address=contract_address, abi=abi)

# เรียกใช้ฟังก์ชันของสัญญา
stored_data = Contract.functions.get .call
print(f’Stored Data: {stored_data}’)

# ส่งธุรกรรมเพื่อแก้ไขสถานะของสัญญา
tx_hash = Contract.functions.set(42).transact({‘from’: web3.eth.accounts[0]})
web3 .eth.waitForTransactionReceipt(tx_hash)

ต่อไปนี้คือข้อมูลโค้ดสำหรับการรวมส่วนหน้าโดยใช้ Web3,js

 <ชื่อ> พื้นที่เก็บข้อมูลแบบธรรมดา  

พื้นที่เก็บข้อมูลแบบธรรมดา

  


การจัดการธุรกรรม:

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

web3.js
const Web3 = need(‘web3’);
const web3 = new Web3(‘https://mainnet) .infura.io/v3/YOUR-PROJECT-ID’);
สัญญา const = ใหม่ web3.eth.Contract(abi, ContractAddress);
< br/>const sendTransaction = async => {  
const ใบเสร็จรับเงิน = รอสัญญา.methods.set(42).send({ จาก: userAddress });  
console.log(“ใบเสร็จรับเงินธุรกรรม:”, ใบเสร็จรับเงิน);
};
ether. js
const { ethers } = need(‘ethers’);
const provider = new ethers.providers.InfuraProvider(‘mainnet’,
‘รหัสโครงการของคุณ’);
const wallet = new ethers.Wallet(‘Your-PRIVATE-KEY’, provider);
constสัญญา = ethers.Contract(contractAddress, abi, wallet);

const sendTransaction = async => {  const tx = รอconst.set(42);  
ใบเสร็จรับเงิน const = รอ tx.wait;  
console.log(“ใบเสร็จการทำธุรกรรม:”, ใบเสร็จรับเงิน);};

web3.py

จาก web3 นำเข้า Web3web3 =
Web3(Web3.HTTPProvider(‘https://mainnet.infura.io/v3/YOUR-PROJECT-ID’ ))สัญญา = web3.eth.contract(address=contract_address, abi=abi)

tx = Contract.functions.set(42).buildTransaction({    
‘from’: user_address,    
‘nonce’: web3.eth.getTransactionCount(user_address),    
‘ น้ำมัน’: 2000000,    ‘
ราคาน้ำมัน’: web3.toWei(’50’, ‘gwei’)
})< br/>
signed_tx = web3.eth.account.sign_transaction(tx, private_key)tx_hash = web3.eth.sendRawTransaction(signed_tx.rawTransaction)receipt = web3.eth.waitForTransactionReceipt(tx_hash)พิมพ์(“ธุรกรรม ใบเสร็จรับเงิน:”, ใบเสร็จรับเงิน)

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

ether.js
contract.events.DataStored  
.on(‘data’, (เหตุการณ์) => {    
console.log(event.returnValues);  
})  
.on(‘error’, console.error );
web3.py
event_filter = Contract.events.DataStored.createFilter(fromBlock=’latest’)ในขณะที่ True:    
สำหรับกิจกรรมใน event_filter.get_new_entries:        
print(event[‘args’])

การจัดการข้อผิดพลาดและการลองอีกครั้งในการประมวลผลธุรกรรม

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

const sendTransaction = async => {  
ลอง {    
const ใบเสร็จรับเงิน = รอสัญญา.methods.set(42).send({ จาก:
ที่อยู่ผู้ใช้ });    
console.log(“ธุรกรรมสำเร็จ:”, ใบเสร็จรับเงิน);  } catch (ข้อผิดพลาด) {    
console.error(“ธุรกรรมล้มเหลว:”, ข้อผิดพลาด);    
// ใช้ตรรกะการลองใหม่    
if (shouldRetry(ข้อผิดพลาด)) {      
setTimeout(sendTransaction, 1,000); // ลองอีกครั้งหลังจากผ่านไป 1 วินาที    
}  
}
};
const shouldRetry = (error) => {  
// กำหนดตรรกะการลองใหม่ตามประเภทข้อผิดพลาด  
return error.message รวมถึง(‘ความแออัดของเครือข่าย’) ||
error.message.includes(‘น้ำมันหมด’);
};

การอัปเกรดและการบำรุงรักษา Smart Contracts

รูปแบบความสามารถในการอัปเกรด:

การใช้รูปแบบพร็อกซีสำหรับการอัพเกรดสัญญา:

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

ความมั่นคง:
พร็อกซีสัญญา {    
การใช้งานที่อยู่;

การอัปเกรดฟังก์ชัน (ที่อยู่ newImplementation) สาธารณะ {        
implementation = newImplementation;    

ทางเลือกสำรอง เจ้าหนี้ภายนอก {        
ที่อยู่ _impl = การใช้งาน;        
require(_impl != address(0), “ไม่ได้กำหนดสัญญาการดำเนินการ”);        
ประกอบ {            
let ptr := mload(0x40)            
calldatacopy(ptr, 0, calldatasize )            
ให้ผลลัพธ์ := delegatecall(gas, _impl, ptr, calldatasize,
0, 0)            
let size := returndatasize            
returndatacopy(ptr, 0, size)            
สลับผลลัพธ์            
case 0 { เปลี่ยนกลับ(ptr, ขนาด) }            
default { return(ptr, ขนาด) }        
}    
}
}

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

ทำสัญญา NewContract {    
uint256 ข้อมูลสาธารณะ

ฟังก์ชั่น setData(uint256 _data) สาธารณะ {        
ข้อมูล = _data;    
}
}
สัญญาการย้ายข้อมูล {    
ฟังก์ชัน ย้าย (ที่อยู่ oldContract ที่อยู่ newContract) สาธารณะ {        
uint256 data = OldContract(oldContract).data;        
NewContract(newContract).setData(ข้อมูล);    
}
}

การรักษาสัญญา:

แนวทางปฏิบัติที่ดีที่สุดในการรักษาและอัปเดตสัญญาเมื่อเวลาผ่านไป:

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

การตรวจสอบสัญญาที่ปรับใช้เพื่อประสิทธิภาพและความปลอดภัย:

จ้างทรัพยากร เช่น Etherscan, Tenderly และสคริปต์ส่วนบุคคลเพื่อติดตามการดำเนินการตามสัญญา ประสิทธิภาพ และปัญหาด้านความปลอดภัยที่อาจเกิดขึ้น ตรวจสอบบันทึกและบันทึกธุรกรรมเป็นประจำเพื่อระบุความผิดปกติหรือความผิดปกติ

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

การใช้งานจริงและกรณีศึกษา

เราสามารถนำตัวอย่างของ Uniswap: การแลกเปลี่ยนแบบกระจายอำนาจ

ภาพรวมของโครงการ:

Uniswap เป็นการแลกเปลี่ยนประเภทหนึ่งที่ไม่มีหน่วยงานกลาง แต่ดำเนินการบนบล็อกเชน Ethereum แทน ต่างจากการแลกเปลี่ยนปกติที่ใช้การจองคำสั่งซื้อ Uniswap ทำงานโดยใช้ระบบ Automated Market Maker (AMM) เพื่อเปิดใช้งานการซื้อขายโทเค็น ERC-20 ผ่านแหล่งรวมสภาพคล่องที่ใช้ร่วมกัน ผู้ใช้สามารถแลกเปลี่ยนโทเค็นได้โดยตรงจากกระเป๋าเงินของพวกเขา และด้วยการมอบสภาพคล่องให้กับพูลเหล่านี้ พวกเขาจะได้รับค่าธรรมเนียมเป็นรางวัล

ส่วนสำคัญ:

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

แนวทางปฏิบัติที่ดี:

  • มีการตรวจสอบความปลอดภัยเป็นประจำ
  • การเพิ่มประสิทธิภาพการใช้แก๊ส
  • การตัดสินใจของชุมชน

การพัฒนาโครงการ:

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

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

ข้อควรพิจารณาที่สำคัญสำหรับการวางแผนและการดำเนินโครงการ

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

บทสรุป

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

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

แนวโน้มในอนาคตในสัญญาอัจฉริยะ

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

ลองดูเพิ่มเติม: วิธีสร้างบล็อกเชนแรกของคุณด้วย Plutus: บทช่วยสอนทีละขั้นตอน

Sorry. No data so far.

2024-09-18 14:10