จะเขียน Smart Contract แรกของคุณได้อย่างไร?

ใน คุณได้เรียนรู้แล้วว่า Smart Contract คืออะไรภาษาของสัญญาอัจฉริยะที่แตกต่างกันและวิธีตั้งค่าสภาพแวดล้อมการพัฒนา Smart Contract ในบทความนี้คุณจะได้เรียนรู้วิธีสร้างสัญญาอัจฉริยะฉบับแรกของคุณ ฉันจะใช้Remix IDE สำหรับการพัฒนาและทดสอบสัญญาอัจฉริยะ

หัวข้อด้านล่างนี้ครอบคลุมในบทช่วยสอนการพัฒนาสัญญาอัจฉริยะนี้:

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

• สรุป

การสร้างสัญญาอัจฉริยะของคุณ

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

โครงสร้างของสัญญาอัจฉริยะ

โดยพื้นฐานแล้ว Solidity smart contract คือชุดของสิ่งต่อไปนี้

• ข้อมูล - ซึ่งรักษาสถานะปัจจุบันของสัญญา
• ฟังก์ชัน - ซึ่งใช้ตรรกะในการเปลี่ยนสถานะของสัญญา

Solidity smart contract เป็นไปตามโครงสร้างมาตรฐาน สัญญาอัจฉริยะใด ๆ เริ่มต้นด้วยข้อความต่อไปนี้

คำสั่ง Pragma

คีย์เวิร์ด“ pragma” สามารถใช้เพื่อเปิดใช้งานคุณสมบัติบางอย่างของคอมไพเลอร์หรือการตรวจสอบ คำสั่งด้านล่างกำหนดว่าซอร์สไฟล์ (สัญญาอัจฉริยะ) จะไม่คอมไพล์ด้วยคอมไพเลอร์ที่เก่ากว่า 0.4.0 และเวอร์ชันคอมไพเลอร์หลัง 0.6.0 การประกาศนี้ช่วยให้มั่นใจได้ว่าไม่มีการนำพฤติกรรมที่ไม่ได้ตั้งใจมาใช้เมื่อมีการแนะนำเวอร์ชันคอมไพเลอร์ใหม่

pragma solidity> = 0.4.0<=0.6.0 

การประกาศสัญญา

มีการประกาศสัญญาโดยใช้คำหลัก 'สัญญา' นี่เป็นการประกาศสัญญาว่างเปล่าซึ่งระบุโดยชื่อ“ PurchaseOrder”

สัญญา PurchaseOrder {}

การจัดเก็บข้อมูลที่เกี่ยวข้องกับสัญญา

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

การพัฒนาสัญญาอัจฉริยะ: การแนะนำตัวแปร

ในความเป็นของแข็งตัวแปรมีสองประเภท

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

การเพิ่มข้อมูลลงใน Smart Contract

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

คลาส __init__ python

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

• ยู - ไม่ได้ลงนาม (หมายถึงประเภทนี้สามารถแทนจำนวนเต็มบวกเท่านั้นไม่ใช่จำนวนเต็มบวกและจำนวนเต็มลบ)
• INT - จำนวนเต็ม
• ขนาด 256 - 256 บิต
• ค่าต่ำสุด uint256 สามารถกำหนดได้คือ 0
• ค่าสูงสุด uint256 สามารถกำหนดได้คือ 2 ^ 256-1 [จำนวนมาก]

ปริมาณผลิตภัณฑ์เป็นเพียงมูลค่าเชิงบวกและสมมติฐานในปัจจุบันคือเราจะรองรับมูลค่าที่มากสำหรับปริมาณผลิตภัณฑ์

ตัวแปร“ product_quantity” ที่ประกาศเป็นส่วนหนึ่งของสถานะสัญญาและด้วยเหตุนี้จึงยังคงอยู่หรือเก็บไว้ในพื้นที่สัญญา ปัจจุบันตัวแปรนี้จะมีค่าเริ่มต้นเป็นค่า 0

สัญญา PurchaseOrder {uint256 product_quantity}

การกำหนดตัวสร้าง

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

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

ตัวสร้าง () สาธารณะ {product_quantity = 100}

การเพิ่มฟังก์ชัน

ตอนนี้ให้เราเพิ่มฟังก์ชันเพื่อให้โปรแกรมของเราโต้ตอบได้ ฟังก์ชันคือความสามารถในการควบคุมซึ่งสามารถเพิ่มลงในโปรแกรมได้ ฟังก์ชันใด ๆ นำหน้าด้วยฟังก์ชันคำหลัก โดยรวมแล้วนี่คือลักษณะการประกาศฟังก์ชัน' ฟังก์ชัน ”.

รับฟังก์ชั่น

ข้อกำหนดทั่วไปประการหนึ่งสำหรับโปรแกรมใด ๆ คือการอ่านค่าที่จัดเก็บไว้ ในสัญญาต่อไปนี้เราจะต้องอ่านค่า 'product_quantity' เพื่อเพิ่มความสามารถนี้ฟังก์ชันอ่านหรือฟังก์ชัน get จะถูกเพิ่มเข้ามา ในฟังก์ชั่นนี้เราไม่ได้ทำการปรับแต่งใด ๆ กับค่าที่เก็บไว้เราแค่ดึงค่าที่เก็บไว้

ตอนนี้ให้เราแยกฟังก์ชั่นรับของเรา (get_quantity)

ฟังก์ชัน get_quantity () การคืนค่ามุมมองสาธารณะ (uint256) {return product_quantity}

ฟังก์ชัน Setter

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

ให้เราแยกฟังก์ชั่นชุดของเรา (update_quantity)

keyerror ใน python คืออะไร

การเพิ่มฟังก์ชันเพื่ออัปเดตมูลค่าของปริมาณสินค้า

ฟังก์ชัน update_quantity (ค่า uint256) สาธารณะ {product_quantity = product_quantity + value}

เมื่อรวมทั้งหมดนี้เข้าด้วยกันนี่คือลักษณะของสัญญาโดยรวม

pragma solidity> = 0.4.0<=0.6.0 contract PurchaseOrder{ uint256 product_quantity //state variable /*Called with the contract is deployed and initializes the value*/ constructor() public{ product_quantity = 100 } // Get Function function get_quantity() public view returns(uint256){ return product_quantity } // Set Function function update_quantity(uint256 value) public { product_quantity = product_quantity + value } } 

การปรับใช้ Smart Contract

ถึงเวลาทดสอบสัญญาอัจฉริยะ ในการทดสอบสัญญาอัจฉริยะนี้เราจะใช้ รีมิกซ์ออนไลน์ IDE .

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

Remix ยังให้ความสามารถในการทดสอบสัญญาอัจฉริยะได้อย่างรวดเร็ว

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

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

Remix เพิ่งอัปเกรด UI

ส่งผ่านค่าใน java

คลิกที่ไอคอนไฟล์ตามที่ไฮไลต์ในภาพด้านบน file explorer จะเปิดขึ้น

1. คลิกที่ไอคอนเครื่องหมายบวกจะสามารถสร้างไฟล์ใหม่ตั้งชื่อไฟล์ PurchaseOrder.sol
2. สิ่งนี้จะสร้างไฟล์ว่างชื่อ PurchaseOrder.sol คลิกและเปิดไฟล์นี้
3. ให้เราคัดลอกและวางสัญญาทั้งหมดใน PurchaseOrder.sol
4. คลิกที่ไอคอนที่สองในเมนูด้านซ้ายใต้ไอคอนไฟล์ตัวเลือก solidity compiler ควรปรากฏขึ้น
5. ภายใต้เลเบลคอมไพเลอร์เลือกเวอร์ชันคอมไพเลอร์ เวอร์ชันปัจจุบันที่เลือกคือ 0.5.8
6. โพสต์การเลือกเวอร์ชันของคอมไพเลอร์คลิกที่“ Compile PurchaseOrder.sol” สิ่งนี้จะรวบรวมสัญญาอัจฉริยะ

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

1. • ABI - อินเทอร์เฟซไบนารีของแอปพลิเคชัน. นี่คือไฟล์ json ซึ่งให้รายละเอียดวิธีการทั้งหมดที่เปิดเผยใน smart contract พร้อมกับข้อมูลเมตาของวิธีการ เพิ่มเติมเกี่ยวกับเรื่องนี้จะกล่าวถึงในบล็อกถัดไป
   • Bytecode- รหัสการทำงาน EVM (เครื่องเสมือน Ethereum) ลอจิกสัญญาอัจฉริยะจะถูกแปลงเป็น bytecode ในการคอมไพล์

8. ในการทดสอบสัญญาอัจฉริยะจำเป็นต้องใช้สัญญาอัจฉริยะ ในการปรับใช้สัญญาอัจฉริยะให้คลิกที่ไอคอนถัดไปในเมนูด้านซ้ายใต้ไอคอนคอมไพล์ หน้าจอต่อไปนี้จะปรากฏขึ้น ในการทดสอบสัญญาอัจฉริยะจำเป็นต้องใช้สัญญาอัจฉริยะ ในการปรับใช้สัญญาอัจฉริยะให้คลิกที่ไอคอนถัดไปในเมนูด้านซ้ายใต้ไอคอนคอมไพล์ หน้าจอต่อไปนี้จะปรากฏขึ้น

ตัวเลือกการปรับใช้

หน้าจอการปรับใช้มีสองทางเลือกให้เราดูทีละรายการ

• สภาพแวดล้อม: นี่อาจเป็นตัวเลือกที่คล้ายกับการเลือกซื้อแล็ปท็อปจาก Amazon, Flipkart, Newegg (ทั้งหมดนี้เป็นร้านค้าปลีกออนไลน์) ที่คุณเลือกได้ว่าคุณต้องการซื้อจากที่ใดตามความต้องการของคุณ ในกรณีของ Remix เรามีตัวเลือกในการปรับใช้ smart contract และทดสอบ smart contract ดรอปดาวน์ถัดจากป้ายกำกับสภาพแวดล้อมมีตัวเลือกสามแบบ
  • JavaScript VM - โหนดเดี่ยวของ Ethereum ในเครื่องถูกสปินขึ้นในหน่วยความจำของเบราว์เซอร์และจัดเตรียมบัญชีทดสอบล่วงหน้า 5 บัญชีซึ่งสามารถใช้สำหรับธุรกรรม (การปรับใช้การเรียกใช้ฟังก์ชัน)
  • การจัดเตรียม Web3 แบบฉีด - สิ่งนี้อาศัย MetaMask Metamask เปรียบเสมือนนายหน้าหรือคนกลางซึ่งช่วยให้เว็บแอปพลิเคชันโต้ตอบกับสัญญาอัจฉริยะ Metamask ให้ความสามารถในการจัดการข้อมูลประจำตัวและยังลงนามในธุรกรรมที่จะส่งไปยังเครือข่าย ethereum คนกลางหรือ 3ถฝ่ายให้ความช่วยเหลือคุณในการกำหนดเครือข่าย blockchain ที่สัญญาอัจฉริยะจะนำไปใช้
  • ผู้ให้บริการ Web3 - หากคุณกำลังเรียกใช้โหนด Ethereum ในเครื่องและจุดสิ้นสุด RPC พร้อมใช้งานตัวเลือกนี้สามารถใช้ได้ สัญญาอัจฉริยะจะนำไปใช้กับโหนด Ethereum ในพื้นที่
• บัญชี: ข้อมูลนี้ถูกสร้างขึ้นตามสภาพแวดล้อมที่เลือก ตัวอย่างเช่น. JavaScript VM มีบัญชีทดสอบที่เตรียมไว้ล่วงหน้า 5 บัญชี ในกรณีของผู้ให้บริการ Web3 และ Injected Web3 ไม่ได้จัดเตรียมบัญชีทดสอบไว้ล่วงหน้า
• ขีด จำกัด ก๊าซ: กำหนดจำนวนก๊าซสูงสุดที่ผู้ริเริ่มยินดีจ่ายสำหรับธุรกรรมใด ๆ นี่คือสถานที่เพื่อป้องกันการวนซ้ำที่ไม่มีที่สิ้นสุดและทำให้เงินทั้งหมดของบัญชีหมดลงในกรณีที่เงื่อนไขวงวนไม่สิ้นสุด
• ค่า: ค่าที่อาจต้องใช้ในการส่งไปในขณะที่ปรับใช้สัญญาอัจฉริยะ ค่านี้เป็นค่าที่ไม่บังคับ

ในการปรับใช้สัญญาให้เลือกตัวเลือก JavaScript VM เลือกบัญชีแรกจากรายการแบบเลื่อนลงของบัญชีจดบันทึกยอดคงเหลือของบัญชี (100 อีเธอร์)

ตรวจสอบว่าชื่อสัญญาอัจฉริยะปรากฏว่า PurchaseOrder คลิกที่ปรับใช้ การดำเนินการสำคัญที่จะเกิดขึ้น

1. ยอดเงินในบัญชีเปลี่ยนจาก 100 อีเธอร์เป็น 99.999999 อีเธอร์จำนวนเงินที่หักเป็นต้นทุนธุรกรรมสำหรับการปรับใช้สัญญาอัจฉริยะ
2. ภายใต้สัญญาที่ปรับใช้แล้วไทล์ใหม่สำหรับสัญญาอัจฉริยะจะปรากฏขึ้นซึ่งจะให้ที่อยู่ของสัญญาอัจฉริยะใหม่เช่นนี้ (0x692a70d2e424a56d2c6c27aa97d1a86395877b3a)
3. ในหน้าต่างคอนโซลข้อมูลต่อไปนี้จะปรากฏขึ้น
   1. แฮชธุรกรรม - ระบุการปรับใช้สัญญาโดยไม่ซ้ำกัน
   2. ต้นทุนการทำธุรกรรม
   3. ที่อยู่ตามสัญญา

การโต้ตอบกับสัญญาที่ทำให้ใช้งานได้

1. ภายใต้สัญญาที่ปรับใช้วิธีการโต้ตอบสองวิธีต่อไปนี้คือ update_quantity และ get_quantity
2. วิธีการโต้ตอบทั้งสองนี้เป็นวิธีสาธารณะที่กำหนดไว้ในสัญญา 'ใบสั่งซื้อ'
3. วิธีการอัปเดตปริมาณ“ update_quantity” ต้องใช้พารามิเตอร์อินพุตดังนั้นจึงต้องใส่กล่องอินพุต
4. วิธีรับปริมาณ“ get_quantity” จะดึงค่าของ product_quantity
5. ให้เราตรวจสอบสิ่งที่เกิดขึ้นเมื่อเรียกใช้ get_quantity ค่าส่งคืน 100 จะแสดงขึ้นซึ่งเริ่มต้นในตัวสร้าง สิ่งนี้ไม่ทำให้เกิดธุรกรรม
6. ให้เราเรียก update_quantity และระบุ 30 เป็นอินพุต ทำให้ธุรกรรมเกิดขึ้น

โดยสรุปการดำเนินการใด ๆ ที่ทำให้เกิดการดำเนินการเขียนในสถานะของสัญญา (เช่นการเปลี่ยนแปลงตัวแปรของสัญญา) จะทำให้เกิดธุรกรรม

การดำเนินการใด ๆ ที่เพิ่งอ่านสถานะของสัญญาไม่ก่อให้เกิดธุรกรรม

ข้อสรุปการพัฒนาสัญญาอัจฉริยะ

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

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

ด้วยเหตุนี้ฉันจึงสรุปได้ว่า สัญญาอัจฉริยะ บล็อกการพัฒนา ฉันหวังว่าคุณจะสนุกกับการอ่านบล็อกนี้และพบว่าเป็นข้อมูล

ผมหากคุณต้องการเรียนรู้ Smart Contracts สร้างอาชีพในโดเมนของ Blockchain และได้รับความเชี่ยวชาญในการเขียนโปรแกรม Ethereum ลงทะเบียนในออนไลน์แบบสด ที่นี่มาพร้อมกับการสนับสนุน 24 * 7 เพื่อแนะนำคุณตลอดระยะเวลาการเรียนรู้ของคุณ

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