คำแนะนำทีละขั้นตอน: วิธีสร้างโทเค็น Ethereum ERC-20 ของคุณเอง
นี่คือบทช่วยสอน Solidity ครั้งที่สองของเราหากคุณพลาดโปรดดูบทนำสู่ Solidity ซึ่งเราจะแนะนำคุณเกี่ยวกับพื้นฐานบางประการของภาษาการเขียนโปรแกรมสำหรับ Ethereum blockchain.
เราอธิบายเล็กน้อยเกี่ยวกับวิธีการทำงานของ Solidity โครงสร้างเป็นอย่างไรและเริ่มต้นด้วยโค้ดง่ายๆสำหรับการเขียนสัญญาอัจฉริยะ“ Hello World”.
ในบทช่วยสอนนี้เราจะเจาะลึกมากขึ้นและสอนโค้ดเพื่อปรับใช้โทเค็น Ethereum ERC-20 ของคุณเอง (นี่คือไฟล์ โทเค็น Blockonomi ).
Ethereum & ICO Boom
ICO ย่อมาจาก Initial Coin Offering เป็นประเภทของการระดมทุนโดยใช้ cryptocurrencies ใน ICO ปริมาณของสกุลเงินดิจิทัลจะถูกขายในรูปแบบของ “โทเค็น” (“เหรียญ”) ให้กับนักเก็งกำไรหรือนักลงทุนเพื่อแลกกับการซื้อตามกฎหมายหรือสกุลเงินดิจิทัลอื่น ๆ เช่น Bitcoin หรือ Ethereum.
โทเค็นที่ขายจะได้รับการส่งเสริมให้เป็นหน่วยสกุลเงินที่ใช้งานได้ในอนาคตหากหรือเมื่อบรรลุเป้าหมายการระดมทุนของ ICO และโครงการจะเปิดตัว.
เราได้พูดคุยกันแล้วว่าสัญญาอัจฉริยะเปิดโลกใหม่ให้นักพัฒนาสร้างและสร้างสรรค์สิ่งใหม่ ๆ ได้อย่างไร อย่างไรก็ตามนักพัฒนาเหล่านี้ต้องการวิธีการจัดหาเงินทุนสำหรับโครงการของพวกเขา.
และทางออกคือ ICO.
ในปี 2560 ICO กำลังเฟื่องฟูโครงการนับไม่ถ้วนปรากฏขึ้นทุกวันพร้อมกับคำสัญญาที่ดุเดือดถึงสิ่งที่พวกเขาต้องการบรรลุและนักลงทุนก็ทำให้พวกเขาล้มเหลว.
ตั้งแต่นั้นมาสิ่งต่างๆก็สงบลงเมื่อพื้นที่ครบกำหนดและนักลงทุนก็หายไป ICO จำนวนมากล้มเหลวในการส่งมอบสิ่งที่สัญญาไว้ แต่นั่นเป็นเรื่องราวสำหรับโพสต์อื่นเรามาที่นี่เพื่อพูดคุยด้านเทคนิค.
Token คืออะไร?
โทเค็นเป็นสัญญาที่ชาญฉลาดซึ่งอาศัยอยู่บน Ethereum Blockchain พวกเขาสามารถใช้และวัตถุประสงค์ได้.
โทเค็นไม่ได้ จำกัด เฉพาะบทบาทใดบทบาทหนึ่ง สามารถตอบสนองบทบาทมากมายในระบบนิเวศของมัน นี่คือรายการของบทบาทบางอย่างที่โทเค็นสามารถรับได้.
- ค่าผ่านทาง: โทเค็นสามารถทำหน้าที่เป็นเกตเวย์ไปยัง Dapp โดยพื้นฐานแล้วในการเข้าถึง Dapp คุณจะต้องถือโทเค็น.
- สิทธิในการโหวต: โทเค็นอาจมีคุณสมบัติทำให้ผู้ถือมีสิทธิออกเสียงบางอย่าง ลองนึกถึง EOS การถือโทเค็น EOS จะช่วยให้คุณสามารถโหวตผู้ผลิตบล็อกได้ EOS Blockchain มีเป้าหมายที่จะเป็นระบบปฏิบัติการแบบกระจายอำนาจซึ่งสามารถรองรับการใช้งานแบบกระจายอำนาจในระดับอุตสาหกรรม.
- การแลกเปลี่ยนมูลค่า: นี่เป็นหนึ่งในบทบาททั่วไปของโทเค็นภายในระบบนิเวศ โทเค็นสามารถช่วยสร้างระบบเศรษฐกิจภายในภายในแอปพลิเคชัน.
- การปรับปรุงประสบการณ์ผู้ใช้: โทเค็นยังช่วยให้ผู้ถือสามารถเพิ่มพูนประสบการณ์ของผู้ใช้ได้ภายในขอบเขตของสภาพแวดล้อมเฉพาะ เช่น. ใน Brave (เว็บเบราว์เซอร์) ผู้ถือ BAT (โทเค็นที่ใช้ใน Brave) จะได้รับสิทธิ์ในการเสริมสร้างประสบการณ์ของลูกค้าโดยใช้โทเค็นเพื่อเพิ่มโฆษณาหรือบริการตามความสนใจอื่น ๆ บนแพลตฟอร์ม Brave.
- สกุลเงิน: สามารถใช้เป็นที่เก็บมูลค่าซึ่งสามารถใช้ในการทำธุรกรรมทั้งภายในและภายนอกระบบนิเวศที่กำหนด.
ERC-20 คืออะไร?
ERC-20 เป็นมาตรฐานทางเทคนิคที่ใช้สำหรับสัญญาอัจฉริยะบน Ethereum blockchain สำหรับการนำโทเค็นไปใช้ โทเค็นส่วนใหญ่ที่ออกใน Ethereum blockchain นั้นสอดคล้องกับ ERC-20.
ERC-20 เป็นมาตรฐานโปรโตคอลที่กำหนดกฎและมาตรฐานบางประการสำหรับการออกโทเค็นบนเครือข่ายของ Ethereum ใน “ERC-20” ERC ย่อมาจาก Ethereum Request For Comments และ 20 ย่อมาจากหมายเลข ID เฉพาะเพื่อแยกความแตกต่างของมาตรฐานนี้จากมาตรฐานอื่น ๆ.
เพื่อให้ง่าย ERC-20 เป็นแนวทางของกฎและข้อบังคับที่จะช่วยสร้างพิมพ์เขียวสำหรับสัญญาอัจฉริยะที่ใช้ Ethereum เพื่อสร้างโทเค็น.
โทเค็นบน Ethereum นั้นเป็นเพียงสัญญาอัจฉริยะที่เป็นไปตามกฎทั่วไปกล่าวคือใช้ชุดฟังก์ชันมาตรฐานที่สัญญาโทเค็นอื่น ๆ ทั้งหมดใช้ร่วมกันเช่น transferFrom (address _from, address _to, uint256 _tokenId) และ balanceOf (address _owner).
โดยพื้นฐานแล้วโทเค็นเป็นเพียงสัญญาที่ติดตามว่าใครเป็นเจ้าของโทเค็นนั้นมากน้อยเพียงใดและฟังก์ชันบางอย่างเพื่อให้ผู้ใช้สามารถโอนโทเค็นไปยังที่อยู่อื่นได้.
เหตุใดมาตรฐาน ERC-20 จึงมีความสำคัญ?
เนื่องจากโทเค็น ERC-20 ทั้งหมดแชร์ชุดฟังก์ชันเดียวกันที่มีชื่อเดียวกันจึงสามารถโต้ตอบได้ในลักษณะเดียวกัน.
ซึ่งหมายความว่าหากคุณสร้างแอปพลิเคชันที่สามารถโต้ตอบกับโทเค็น ERC-20 หนึ่งโทเค็นก็ยังสามารถโต้ตอบกับโทเค็น ERC-20 ได้ ด้วยวิธีนี้สามารถเพิ่มโทเค็นลงในแอปของคุณได้อย่างง่ายดายในอนาคตโดยไม่จำเป็นต้องกำหนดรหัสเอง คุณสามารถเสียบที่อยู่สัญญาโทเค็นใหม่และบูมแอปของคุณมีโทเค็นอื่นที่สามารถใช้ได้.
ตัวอย่างหนึ่งของสิ่งนี้คือการแลกเปลี่ยน เมื่อการแลกเปลี่ยนเพิ่มโทเค็น ERC-20 ใหม่จริงๆแล้วจำเป็นต้องเพิ่มสัญญาอัจฉริยะอื่นที่พูดถึง ผู้ใช้สามารถบอกสัญญานั้นว่าจะส่งโทเค็นไปยังที่อยู่กระเป๋าเงินของผู้แลกเปลี่ยนและการแลกเปลี่ยนสามารถบอกสัญญาให้ส่งโทเค็นคืนให้กับผู้ใช้เมื่อพวกเขาขอถอน.
การแลกเปลี่ยนจำเป็นต้องใช้ตรรกะการโอนนี้เพียงครั้งเดียวจากนั้นเมื่อต้องการเพิ่มโทเค็น ERC-20 ใหม่ก็เป็นเพียงเรื่องของการเพิ่มที่อยู่สัญญาใหม่ในฐานข้อมูล.
มาเริ่มสร้าง Token กันเลย
เราจะใช้ Remix IDE เพื่อพัฒนา Smart Contract สำหรับโทเค็น ERC-20 ของเรา.
Remix เป็นเครื่องมือออนไลน์ที่ให้คุณเขียน Solidity smart contract จากนั้นปรับใช้และเรียกใช้งาน.
เพียงไปที่ https://remix.ethereum.org จากเบราว์เซอร์ของคุณและเราสามารถเริ่มเขียนโค้ดได้.
คลิกปุ่ม Solidity จากนั้นคลิกปุ่ม Plus ที่มุมซ้ายบน.
ฉันจะตั้งชื่อว่า BlockonomiToken คุณสามารถเลือกชื่ออะไรก็ได้ที่คุณต้องการสำหรับสกุลเงินดิจิทัลของคุณเอง.
ดีทุกอย่างได้รับการติดตั้งแล้ว.
กฎโทเค็น ERC-20
โทเค็น ERC-20 เป็นไปตามรายการกฎเพื่อให้สามารถแชร์แลกเปลี่ยนเป็นโทเค็นอื่น ๆ หรือโอนไปยังกระเป๋าเงินดิจิทัล.
มาตรฐาน ERC20 ประกอบด้วยกฎทางเลือก 3 กฎและกฎบังคับ 6 ข้อ.
หากต้องการกล่าวถึงคนธรรมดาถ้าคุณรวมฟังก์ชันบางอย่างไว้ในสัญญาอัจฉริยะของโทเค็นแสดงว่าคุณปฏิบัติตาม ERC20 หากคุณไม่รวมฟังก์ชันที่จำเป็นแสดงว่าคุณไม่ใช่ ERC20.
กฎบังคับมีดังนี้:
- totalSupply
- balanceOf
- โอน
- โอนจาก
- อนุมัติ
- เบี้ยเลี้ยง
ในทางกลับกันกฎที่เป็นทางเลือก ได้แก่ :
- ชื่อโทเค็น
- สัญลักษณ์
- ทศนิยม (สูงสุด 18)
เป็นเรื่องปกติที่จะกำหนดกฎเหล่านี้ในอินเทอร์เฟซ ไม่มีสิ่งที่เรียกว่าอินเทอร์เฟซใน Solidity แต่เป็นเพียง Smart Contract อีกแบบหนึ่ง โชคดีที่เราสามารถสืบทอดสัญญาอัจฉริยะในภาษาโปรแกรม Solidity ได้.
การสืบทอดในความเป็นปึกแผ่น
ใน Solidity การสืบทอดค่อนข้างคล้ายกับภาษาโปรแกรมเชิงวัตถุแบบคลาสสิก ก่อนอื่นคุณต้องเขียนสัญญาพื้นฐานและบอกว่าสัญญาใหม่ของคุณจะสืบทอดจากสัญญาพื้นฐาน.
Contract IBank {
// รหัสสัญญาพื้นฐาน…
}
Contract Bank คือ IBank {
// รหัสสัญญาที่รับมา…
}
คุณต้องรู้ด้วยว่า Solidity รองรับการสืบทอดหลาย ๆ แบบโดยการคัดลอกโค้ดรวมถึงความหลากหลาย.
การเรียกใช้ฟังก์ชันทั้งหมดเป็นแบบเสมือนซึ่งหมายความว่าฟังก์ชันที่ได้รับมาส่วนใหญ่จะถูกเรียกใช้ยกเว้นเมื่อมีการระบุชื่อสัญญาอย่างชัดเจน.
เมื่อสัญญารับช่วงจากหลายสัญญาจะมีการสร้างเพียงสัญญาเดียวบนบล็อกเชนและรหัสจากสัญญาพื้นฐานทั้งหมดจะถูกคัดลอกไปยังสัญญาที่สร้างขึ้น.
กลับไปที่โทเค็น ERC-20 ของเรากัน เรามีกฎบังคับเพื่อสร้างโทเค็น ERC-20.
เราจะกำหนดเป็น 6 ฟังก์ชันและเขียนลงในอินเทอร์เฟซ จากนั้นสัญญาโทเค็นจริงของเราจะสืบทอดอินเทอร์เฟซการโทรดังกล่าว.
รหัสของคุณจะต้องมีลักษณะเช่นนี้.
สัญญา ERC20Interface {
ฟังก์ชัน totalSupply ()
สาธารณะ
ดู
ผลตอบแทน (uint);
ฟังก์ชัน balanceOf (address tokenOwner)
สาธารณะ
ดู
ผลตอบแทน (ยอดคงเหลือ uint);
ค่าเผื่อฟังก์ชัน
(address tokenOwner, address spender)
สาธารณะ
ดู
ผลตอบแทน (uint ที่เหลือ);
การถ่ายโอนฟังก์ชัน (ที่อยู่ไปยังโทเค็น uint) สาธารณะ
ผลตอบแทน (ความสำเร็จบูล);
ฟังก์ชั่นอนุมัติ (ผู้ใช้ที่อยู่โทเค็น uint) สาธารณะ
ผลตอบแทน (ความสำเร็จบูล);
ฟังก์ชั่นการถ่ายโอนจาก
(ที่อยู่จากที่อยู่ไปยังโทเค็น uint) สาธารณะ
ผลตอบแทน (ความสำเร็จบูล);
การถ่ายโอนเหตุการณ์ (ที่อยู่ที่จัดทำดัชนีจากที่อยู่ที่ทำดัชนีไปยังโทเค็น uint);
การอนุมัติเหตุการณ์ (ที่อยู่ที่จัดทำดัชนี tokenOwner, ที่อยู่ผู้ใช้จ่ายที่จัดทำดัชนี, โทเค็น uint);
}
สัญญาโทเค็น
มาสร้างสัญญาโทเค็นของเรากัน ประเภท สัญญา {}
ตอนนี้เราจะทำตามกฎทางเลือก 3 ข้อ.
แม้ว่าจะไม่จำเป็นต้องตั้งชื่อโทเค็นของคุณ แต่ก็ยังคงเป็นสิ่งสำคัญที่จะต้องระบุตัวตน.
ถัดไปเรามีสัญลักษณ์ เราไม่สามารถพูดถึงความสำคัญของพวกเขาได้ สัญลักษณ์ลวงช่วยในการสร้างแบรนด์ที่ดีขึ้น.
สุดท้ายเรามีความหารลงตัวซึ่งจะช่วยให้เรากำหนดมูลค่าต่ำสุดที่เป็นไปได้ของโทเค็น การหาร 0 จะหมายความว่าค่าต่ำสุดของโทเค็นคือ 1 ในทางกลับกันการหาร 2 หมายความว่าค่าต่ำสุดจะเป็น 0.01 จำนวนตำแหน่งทศนิยมสูงสุดที่อนุญาตคือ 18 18 ทศนิยมเป็นค่าเริ่มต้นที่แนะนำอย่างยิ่งให้หลีกเลี่ยงการเปลี่ยนแปลง
มากำหนดและเริ่มต้นในตัวสร้าง.
สัญญา BlockonomiToken คือ ERC20Interface {
สตริงสาธารณะชื่อ;
สัญลักษณ์สาธารณะสตริง
uint8 ทศนิยมสาธารณะ
constructor () สาธารณะ {
ชื่อ = "BlockonomiToken";
สัญลักษณ์ = "กทม";
ทศนิยม = 18;
}
}
โทเค็นของเรายังต้องมีการจัดหาครั้งแรกและบันทึกยอดคงเหลือทั้งหมด เราสามารถเก็บข้อมูลนั้นไว้ในอาร์เรย์.
ในตัวสร้างเราจะเริ่มต้นสัญญาของเราด้วยโทเค็นการจัดหาเริ่มต้นให้กับผู้สร้างสัญญา (นั่นคือ msg.sender). เพิ่มบรรทัดเหล่านี้ลงในโค้ดของเราและเราจะพูดถึงจุดประสงค์ของทั้งหมด.
สัญญา BlockonomiToken คือ ERC20Interface {
สตริงสาธารณะชื่อ;
สัญลักษณ์สาธารณะสตริง
uint8 ทศนิยมสาธารณะ
uint256 สาธารณะ _totalSupply;
การทำแผนที่ (ที่อยู่ => uint) ยอดคงเหลือ;
การทำแผนที่ (ที่อยู่ => การทำแผนที่ (ที่อยู่ => uint)) อนุญาต;
constructor () สาธารณะ {
ชื่อ = "BlockonomiToken";
สัญลักษณ์ = "กทม";
ทศนิยม = 18;
_totalSupply = 100000000000000000000000000;
ยอดคงเหลือ [msg.sender] = _totalSupply;
ปล่อยโอน (ที่อยู่ (0), msg.sender, _totalSupply);
}
}
ประเภทข้อมูล Solidity
อย่างที่คุณเห็น _totalSupply มีไฟล์ uint256 ประเภทข้อมูลและทศนิยม uint8.
Solidity เป็นภาษาที่พิมพ์แบบคงที่ซึ่งหมายความว่าต้องระบุประเภทของตัวแปรแต่ละตัว (สถานะและโลคัล) ในเวลาคอมไพล์ Solidity มีพื้นฐานหลายประเภทซึ่งสามารถรวมกันเป็นประเภทที่ซับซ้อนได้.
ตอนนี้เรามาพูดคุยเกี่ยวกับประเภทจำนวนเต็มกัน.
จำนวนเต็มได้ int หรือ uint: จำนวนเต็มที่ลงชื่อและไม่ได้ลงนามในขนาดต่างๆ หากคุณคุ้นเคยกับทฤษฎีวิทยาการคอมพิวเตอร์หรือคุณรู้ความแตกต่างระหว่างจำนวนเต็มที่ลงชื่อและไม่มีเครื่องหมายในภาษา C ทุกอย่างจะเหมือนกันอย่างแน่นอนใน Solidity.
ถ้าคุณไม่เป็นเช่นนั้นเราก็สามารถพูดได้ ไม่ได้ลงนามคือจำนวนเต็มที่ไม่มีวันเป็นลบ! การลงนามในทางกลับกันอาจเป็นได้ทั้งลบและบวก แต่เราจะใช้เฉพาะหน่วยในสัญญาของเรา.
คำหลัก uint8 ถึง uint256 ในขั้นตอนที่ 8 (ไม่ได้ลงนาม 8 ถึง 256 บิต) และ int8 ถึง int256 uint และ int เป็นนามแฝงสำหรับ uint256 และ int256 ตามลำดับ.
เราคุยกันว่าเราจะจัดเก็บยอดคงเหลือในอาร์เรย์บางประเภท ทางออกที่ดีกว่าคือการใช้ตารางแฮชหรือในการแมป Solidity.
โดยทั่วไปเราทำแผนที่ ที่อยู่ (นั่นคือประเภทข้อมูลด้วย) ถึง uint.
msg.sender (ที่อยู่): ผู้ส่งข้อความ (สายปัจจุบัน)
msg.sender จะเป็นบุคคลที่กำลังเชื่อมต่อกับสัญญา.
หลังจากนั้นคุณอาจจะจัดการกับสัญญาที่เกี่ยวข้องกับสัญญา ในกรณีนั้นสัญญาที่สร้างการโทรจะเป็น msg.sender.
การแมป
ประเภทการแมปถูกประกาศเป็น การทำแผนที่ (_KeyType => _ValueType). ที่นี่ _KeyType สามารถเป็นได้เกือบทุกประเภทยกเว้นการแมปอาร์เรย์ขนาดไดนามิกสัญญา enum และโครงสร้าง _ValueType สามารถเป็นประเภทใดก็ได้รวมถึงการแมป.
การแมปสามารถมองเห็นได้ว่าเป็นตารางแฮชซึ่งมีการเตรียมใช้งานแบบเสมือนจริงเพื่อให้ทุกคีย์ที่เป็นไปได้มีอยู่และแมปกับค่าที่การแทนค่าไบต์เป็นศูนย์ทั้งหมด: ค่าเริ่มต้นของประเภท ความคล้ายคลึงกันสิ้นสุดที่นี่: ข้อมูลสำคัญไม่ได้ถูกเก็บไว้ในการแมปจริงมีเพียงแฮช keccak256 เท่านั้นที่ใช้ในการค้นหาค่า.
ด้วยเหตุนี้การแมปจึงไม่มีความยาวหรือแนวคิดของคีย์หรือค่าที่ “ตั้งค่า”.
การแมปใช้ได้เฉพาะกับตัวแปรสถานะเท่านั้น (หรือเป็นประเภทอ้างอิงที่จัดเก็บในฟังก์ชันภายใน).
เป็นไปได้ที่จะทำเครื่องหมายการแม็ปสาธารณะและให้ Solidity สร้าง getter _KeyType จะกลายเป็นพารามิเตอร์ที่จำเป็นสำหรับ getter และจะส่งคืน _ValueType.
_ValueType สามารถทำการแมปได้เช่นกัน getter จะมีพารามิเตอร์หนึ่งตัวสำหรับแต่ละ _KeyType แบบวนซ้ำ.
เหตุการณ์
blockchain คือรายการของบล็อกซึ่งเป็นรายการพื้นฐานของธุรกรรม ธุรกรรมแต่ละรายการมีใบเสร็จรับเงินที่แนบมาซึ่งมีรายการบันทึกเป็นศูนย์ขึ้นไป รายการบันทึกแสดงถึงผลลัพธ์ของเหตุการณ์ที่เกิดขึ้นจากสัญญาอัจฉริยะ.
ในซอร์สโค้ด Solidity ในการกำหนดเหตุการณ์คุณทำเครื่องหมายโดยนำหน้าด้วย เหตุการณ์ คำสำคัญ (คล้ายกับการใช้งานคำสำคัญของฟังก์ชัน) ย
จากนั้นเรียกหรือเริ่มเหตุการณ์ในเนื้อหาของฟังก์ชันใด ๆ ที่คุณต้องการทำให้เกิดเหตุการณ์ (ฉันสงสัยว่ามีถ้อยคำมาตรฐานสำหรับมัน) คุณสามารถเริ่มเหตุการณ์จากฟังก์ชั่นใดก็ได้โดยใช้ไฟล์ เปล่ง คำสำคัญ.
ERC-20 อินเทอร์เฟซ
มาใช้ ERC-20 Interface กันเลย ในการทำเช่นนั้นเราต้องเขียนโค้ดสำหรับฟังก์ชันบังคับทั้งหกของเรา.
1. totalSupply
ระบุจำนวนโทเค็น ERC-20 ทั้งหมดที่สร้างขึ้น จุดประสงค์ของวิธีนี้คือเพื่อกำหนดจำนวนโทเค็นทั้งหมดที่ลอยอยู่รอบ ๆ ระบบนิเวศ.
ฟังก์ชัน totalSupply ()
สาธารณะ
ดู
ผลตอบแทน (uint)
{
ส่งคืน _totalSupply – ยอดคงเหลือ [ที่อยู่ (0)];
}
2. balanceOf
ส่งคืนจำนวนโทเค็นที่ที่อยู่เฉพาะซึ่งในกรณีนี้เจ้าของสัญญามีอยู่ในบัญชีของตน.
ฟังก์ชัน balanceOf (address tokenOwner)
สาธารณะ
ดู
ผลตอบแทน (ยอดคงเหลือ uint)
{
ส่งคืนยอดคงเหลือ [tokenOwner];
}
3. ค่าเผื่อ
ในการดำเนินธุรกรรมข้อมูลที่สำคัญที่สุดอย่างหนึ่งที่สัญญาควรรู้คือยอดคงเหลือของผู้ใช้ ท้ายที่สุดผู้ใช้ควรมีจำนวนโทเค็นขั้นต่ำที่จำเป็นในการทำธุรกรรม.
ด้วยเหตุนี้สัญญา ERC-20 จึงรวมฟังก์ชัน allowance () ไว้ด้วย หากผู้ใช้ไม่มีจำนวนโทเค็นขั้นต่ำที่ต้องการฟังก์ชันจะยกเลิกธุรกรรม.
ค่าเผื่อฟังก์ชัน
(address tokenOwner, address spender)
สาธารณะ
ดู
ผลตอบแทน (uint ที่เหลือ)
{
กลับได้รับอนุญาต [tokenOwner] [spender];
}
4. อนุมัติ
เมื่อตรวจสอบยอดคงเหลือแล้วเจ้าของสัญญาสามารถให้การอนุมัติแก่ผู้ใช้ในการรวบรวมโทเค็นตามจำนวนที่ต้องการจากที่อยู่ของสัญญา.
ฟังก์ชั่นอนุมัติยังตรวจสอบธุรกรรมเทียบกับการจัดหาโทเค็นทั้งหมดเพื่อให้แน่ใจว่าไม่มีส่วนใดขาดหายไปหรือเกิน.
กล่าวอีกนัยหนึ่งก็คือทำให้แน่ใจว่าการปลอมแปลงเป็นไปไม่ได้.
ฟังก์ชั่นอนุมัติ (ผู้ใช้ที่อยู่โทเค็น uint) สาธารณะ
ผลตอบแทน
(ความสำเร็จบูล)
{
อนุญาต [msg.sender] [spender] = โทเค็น;
ปล่อยการอนุมัติ (msg.sender, spender, tokens);
กลับจริง}
ห้องสมุดคณิตศาสตร์ที่ปลอดภัย
ในการใช้ฟังก์ชันที่เหลืออีกสองฟังก์ชันอย่างถูกต้องเราจำเป็นต้องมี Safe Math Library.
Safe Math Library ห่อหุ้มด้วยการดำเนินการทางคณิตศาสตร์ของ Solidity ด้วยการตรวจสอบเพิ่มเติม.
การคำนวณทางคณิตศาสตร์ใน Solidity wrap on overflow สิ่งนี้สามารถส่งผลให้เกิดข้อบกพร่องได้อย่างง่ายดายเนื่องจากโปรแกรมเมอร์มักคิดว่าการล้นทำให้เกิดข้อผิดพลาดซึ่งเป็นพฤติกรรมมาตรฐานในภาษาโปรแกรมระดับสูง.
Safe Math กู้คืนสัญชาตญาณนี้โดยการคืนค่าธุรกรรมเมื่อการดำเนินการล้น.
การใช้ไลบรารีนี้แทนการดำเนินการที่ไม่ได้ตรวจสอบจะช่วยกำจัดข้อบกพร่องทั้งคลาสดังนั้นจึงขอแนะนำให้ใช้เสมอ.
สิ่งที่เราต้องทำตอนนี้คือคัดลอกรหัสนี้ไว้เหนือสัญญาของเราจากนั้นจึงรับช่วงต่อ.
สัญญา SafeMath {
ฟังก์ชัน safeAdd (uint a, uint b) ผลตอบแทนที่บริสุทธิ์สาธารณะ (uint c) {
ค = a + b;
ต้องการ (ค >= ก);
}
ฟังก์ชัน safeSub (uint a, uint b) ผลตอบแทนที่บริสุทธิ์สาธารณะ (uint c) {
ต้องการ (ข <= ก); ค = a – b; } function safeMul (uint a, uint b) public pure return (uint c) {c = a * b; ต้องการ (a == 0 || c / a == b); } function safeDiv (uint a, uint b) public pure return (uint c) {require (b > 0);
ค = a / b;
}
}
อย่าลืมสืบทอด.
BlockonomiToken สัญญาคือ ERC20Interface, SafeMath
5. โอน
ดังนั้นตอนนี้การตรวจสอบทั้งหมดได้ดำเนินการเสร็จสิ้นและสัญญาทราบว่าผู้ใช้มีจำนวนโทเค็นที่จำเป็นในการทำธุรกรรมเจ้าของสัญญาสามารถส่งโทเค็นให้พวกเขาโดยใช้ฟังก์ชันการโอน ().
ฟังก์ชันนี้ช่วยให้เจ้าของสัญญาส่งโทเค็นจำนวนหนึ่งไปยังที่อยู่อื่นเช่นเดียวกับธุรกรรมสกุลเงินดิจิทัลทั่วไปอนุญาตให้โอนโทเค็นจำนวนหนึ่งจากอุปทานทั้งหมดไปยังบัญชีผู้ใช้.
การถ่ายโอนฟังก์ชัน (ที่อยู่ไปยังโทเค็น uint)
สาธารณะ
ผลตอบแทน (ความสำเร็จบูล)
{
ยอดคงเหลือ [msg.sender] = safeSub (ยอดคงเหลือ [msg.sender], โทเค็น);
ยอดคงเหลือ [ถึง] = safeAdd (ยอดคงเหลือ [ถึง], โทเค็น);
ปล่อยโอน (msg.sender, to, tokens);
กลับจริง;
}
6. โอนเงินจาก
เราได้กล่าวถึงฟังก์ชันการถ่ายโอนแล้วทำไมเราถึงมีอีก?
เรามาดูตัวอย่างกันดีกว่าว่าเหตุใด TransferFrom จึงเป็นส่วนเสริมที่ยอดเยี่ยมสำหรับสัญญา ERC20.
เราทุกคนต้องจ่ายเงินจำนวนหนึ่งทุกเดือนเหมือนเครื่องจักร อาจเป็นค่าเช่าตั๋วเงิน ฯลฯ คุณไม่จำเป็นต้องจ่ายเงินทั้งหมดนี้ด้วยตัวเอง คุณสามารถตั้งค่าระบบการชำระเงินอัตโนมัติกับธนาคารของคุณเพื่อดูแลการชำระเงินเหล่านี้ได้ตลอดเวลา.
นั่นคือสิ่งที่ TransferFrom () ช่วยให้คุณทำได้ ช่วยให้คุณโอนการชำระเงินไปยังบัญชีใดบัญชีหนึ่งโดยอัตโนมัติ.
ฟังก์ชั่นการถ่ายโอนจาก
(ที่อยู่จากที่อยู่ไปยังโทเค็น uint)
สาธารณะ
ผลตอบแทน (ความสำเร็จบูล)
{
ยอดคงเหลือ [จาก] = safeSub (ยอดคงเหลือ [จาก], โทเค็น);
อนุญาต [จาก] [msg.sender] = safeSub (อนุญาต [จาก] [msg.sender], โทเค็น);
ยอดคงเหลือ [ถึง] = safeAdd (ยอดคงเหลือ [ถึง], โทเค็น);
ส่งการโอน (จากถึงโทเค็น);
กลับจริง;
}
รหัสเต็ม
นี่คือรหัสเต็มสำหรับโทเค็น Blockonomi ของเรา.
ความแข็งแกร่งของ pragma ^ 0.5.0;
// —————————————————————————-
// ERC Token Standard # 20 อินเทอร์เฟซ
//
// —————————————————————————-
สัญญา ERC20Interface {
ฟังก์ชัน totalSupply () ผลตอบแทนมุมมองสาธารณะ (uint);
ฟังก์ชั่น balanceOf (address tokenOwner) ผลตอบแทนมุมมองสาธารณะ (uint balance);
ค่าเผื่อฟังก์ชัน (address tokenOwner, address spender) public view return (uint left);
การถ่ายโอนฟังก์ชัน (ที่อยู่ไปยังโทเค็น uint) ผลตอบแทนสาธารณะ (ความสำเร็จบูล);
ฟังก์ชั่นอนุมัติ (ผู้ใช้ที่อยู่โทเค็น uint) ผลตอบแทนสาธารณะ (ความสำเร็จบูล);
ฟังก์ชั่น transferFrom (ที่อยู่จากที่อยู่ไปยังโทเค็น uint) ผลตอบแทนสาธารณะ (ความสำเร็จบูล);
การถ่ายโอนเหตุการณ์ (ที่อยู่ที่จัดทำดัชนีจากที่อยู่ที่ทำดัชนีไปยังโทเค็น uint);
การอนุมัติเหตุการณ์ (ที่อยู่ที่จัดทำดัชนี tokenOwner, ที่อยู่ผู้ใช้จ่ายที่จัดทำดัชนี, โทเค็น uint);
}
// —————————————————————————-
// ห้องสมุดคณิตศาสตร์ปลอดภัย
// —————————————————————————-
สัญญา SafeMath {
ฟังก์ชัน safeAdd (uint a, uint b) ผลตอบแทนที่บริสุทธิ์สาธารณะ (uint c) {
ค = a + b;
ต้องการ (ค >= ก);
}
ฟังก์ชัน safeSub (uint a, uint b) ผลตอบแทนที่บริสุทธิ์สาธารณะ (uint c) {
ต้องการ (ข <= ก); ค = a – b; } function safeMul (uint a, uint b) public pure return (uint c) {c = a * b; ต้องการ (a == 0 || c / a == b); } function safeDiv (uint a, uint b) public pure return (uint c) {require (b > 0);
ค = a / b;
}
}
BlockonomiToken สัญญาคือ ERC20Interface, SafeMath {
สตริงสาธารณะชื่อ;
สัญลักษณ์สาธารณะสตริง
uint8 ทศนิยมสาธารณะ // 18 ทศนิยมเป็นค่าเริ่มต้นที่แนะนำอย่างยิ่งให้หลีกเลี่ยงการเปลี่ยนแปลง
uint256 สาธารณะ _totalSupply;
การทำแผนที่ (ที่อยู่ => uint) ยอดคงเหลือ;
การทำแผนที่ (ที่อยู่ => การทำแผนที่ (ที่อยู่ => uint)) อนุญาต;
/ **
* ฟังก์ชัน Constrctor
*
* เริ่มต้นสัญญาด้วยโทเค็นอุปทานเริ่มต้นให้กับผู้สร้างสัญญา
* /
constructor () สาธารณะ {
ชื่อ = "BlockonomiToken";
สัญลักษณ์ = "กทม";
ทศนิยม = 18;
_totalSupply = 100000000000000000000000000;
ยอดคงเหลือ [msg.sender] = _totalSupply;
ปล่อยโอน (ที่อยู่ (0), msg.sender, _totalSupply);
}
ฟังก์ชัน totalSupply () ผลตอบแทนมุมมองสาธารณะ (uint) {
ส่งคืน _totalSupply – ยอดคงเหลือ [ที่อยู่ (0)];
}
ฟังก์ชัน balanceOf (address tokenOwner) ผลตอบแทนจากมุมมองสาธารณะ (uint balance) {
ส่งคืนยอดคงเหลือ [tokenOwner];
}
ค่าเผื่อฟังก์ชัน (address tokenOwner, address spender) public view return (uint left) {
กลับได้รับอนุญาต [tokenOwner] [spender];
}
ฟังก์ชั่นอนุมัติ (ผู้ใช้ที่อยู่โทเค็น uint) ผลตอบแทนสาธารณะ (ความสำเร็จบูล) {
อนุญาต [msg.sender] [spender] = โทเค็น;
ปล่อยการอนุมัติ (msg.sender, spender, tokens);
กลับจริง;
}
การถ่ายโอนฟังก์ชัน (ที่อยู่ไปยังโทเค็น uint) ผลตอบแทนสาธารณะ (ความสำเร็จของบูล) {
ยอดคงเหลือ [msg.sender] = safeSub (ยอดคงเหลือ [msg.sender], โทเค็น);
ยอดคงเหลือ [ถึง] = safeAdd (ยอดคงเหลือ [ถึง], โทเค็น);
ปล่อยโอน (msg.sender, to, tokens);
กลับจริง;
}
function transferFrom (address from, address to, uint tokens) public return (bool success) {
ยอดคงเหลือ [จาก] = safeSub (ยอดคงเหลือ [จาก], โทเค็น);
อนุญาต [จาก] [msg.sender] = safeSub (อนุญาต [จาก] [msg.sender], โทเค็น);
ยอดคงเหลือ [ถึง] = safeAdd (ยอดคงเหลือ [ถึง], โทเค็น);
ส่งการโอน (จากถึงโทเค็น);
กลับจริง;
}
}
ยินดีด้วย! คุณพัฒนาโทเค็น ethereum ของคุณเองได้สำเร็จ.
ขั้นตอนสุดท้ายคือการปรับใช้กับเครือข่ายจริง.
การปรับใช้โทเค็นของคุณ
ในการดำเนินการนี้เราจะต้องใช้กระเป๋าสตางค์ Metamask.
Metamask เป็นส่วนขยายที่ช่วยให้คุณสามารถเรียกใช้ Ethereum dApps ได้โดยตรงในเบราว์เซอร์ของคุณโดยไม่ต้องเรียกใช้โหนด Ethereum แบบเต็ม.
ไปที่ https://metamask.io/ จากเบราว์เซอร์ของคุณ (Chrome, Firefox หรือ Opera) และเพิ่มเข้าไป.
สร้าง Wallet ใหม่ใน MetaMask
เมื่อติดตั้งส่วนขยายแล้วให้คลิกที่ไอคอนที่มุมขวาบนของเบราว์เซอร์เพื่อเริ่มสร้างกระเป๋าเงิน.
อ่านและยอมรับข้อกำหนดจากนั้นป้อนรหัสผ่านที่คาดเดายากแล้วคลิก “สร้าง”.
คุณจะเห็นวลีเมล็ดพันธุ์ 12 คำ บันทึกคำศัพท์เป็นไฟล์หรือคัดลอกไปไว้ในที่ปลอดภัยแล้วคลิก “ฉันคัดลอกไว้ที่ไหนสักแห่งที่ปลอดภัย”.
ตอนนี้คุณได้สร้างบัญชีสำเร็จใน MetaMask ด้วยที่อยู่กระเป๋าเงินใหม่!
คุณจะสังเกตเห็นว่าปัจจุบันคุณมี 0 ETH ในกระเป๋าเงินของคุณ ในการปรับใช้สัญญาบนเครือข่าย Ethereum จำเป็นต้องมี Ether จำนวนหนึ่ง เราจะไม่ปรับใช้สัญญาของเรากับเครือข่ายหลักเนื่องจากเป็นเพียงการสาธิต.
เราจะเผยแพร่สัญญานี้ไปยังเครือข่ายทดสอบ มีการทดสอบ Ethereum blockchain อยู่ไม่กี่ตัว – Ropsten, Rinkeby, Kovan …
ลองใช้ Ropsten สำหรับตัวอย่างนี้.
ก่อนอื่นคุณต้องมีอีเธอร์ใช่ไหม? บนเครือข่ายทดสอบเราทำงานร่วมกับอีเธอร์ฟรีปลอม หนึ่งเพียงแค่ต้องอ้างสิทธิ์บางส่วนจาก Faucet.
ไปที่: https://faucet.ropsten.be/ , วางที่อยู่กระเป๋าเงินของคุณแล้วคลิก “ส่งอีเธอร์ทดสอบให้ฉัน”.
หลังจากผ่านไปสองสามวินาทีคุณจะเห็น ETH ในกระเป๋าเงินของคุณ.
ถ่ายทอดสด
ตอนนี้ถึงเวลาทำให้ทุกอย่างมีชีวิต!
ไปที่ Remix IDE และรวบรวมสัญญา หากไม่มีข้อผิดพลาดเราก็พร้อมสำหรับการทำให้ใช้งานได้.
สำหรับสภาพแวดล้อมให้เลือก Injected Web3 มันจะตรวจจับกระเป๋าเงิน metamask ของคุณโดยอัตโนมัติ.
กดปุ่ม Deploy.
ตอนนี้ Metamask จะขอให้คุณถอนเงินบางส่วนจากกระเป๋าเงินของคุณเพื่อซื้อธุรกรรมนี้.
ยืนยันว่า จากนั้นกลับไปที่ Remix IDE และให้ความสนใจกับเทอร์มินัล เราเห็นว่าการทำธุรกรรมประสบความสำเร็จ.
เราได้รับแฮชธุรกรรมแล้ว คลิกที่ uri จากเทอร์มินัลซึ่งดูเหมือนว่า: ropsten.etherscan.io/
มันจะนำทางเราไป etherscan.io นั่นคือ Ethereum Blockchain explorer และที่นี่คุณสามารถติดตามทุกสิ่งที่เกิดขึ้นบนเครือข่ายหลักและทดสอบได้เพราะทุกอย่างเป็นแบบสาธารณะบน blockchain แน่นอน.
เมื่อเราไปที่ uri นี้เราจะเห็นรายละเอียดเกี่ยวกับธุรกรรมของเรา คลิกที่แฮชสัญญาเพื่อสำรวจเพิ่มเติม.
ทุกอย่างเป็นสาธารณะบน blockchain แม้แต่รหัสของเรา นักพัฒนา Solidity ไม่มีที่ว่างสำหรับข้อผิดพลาด!
คลิกที่ แท็บสัญญา และคุณจะเห็น bytecode ที่รวบรวมไว้ของเรา
ตอนนี้คุณสามารถไปที่ Token Tracer เพื่อดูรายละเอียดของ โทเค็น Blockonomi. คุณสามารถดูกฎทางเลือก 3 ข้อที่เรากำหนดไว้ก่อนหน้านี้.
ตอนนี้ตรวจสอบกระเป๋าเงินของคุณ คุณจะเห็นว่า Ether ที่เราจ่ายไปสำหรับการปรับใช้สัญญาอัจฉริยะบน Ropsten ถูกลบออกแล้ว.
สรุป
สรุปบทช่วยสอนของเราโดยทำตามขั้นตอนเหล่านี้และตัวอย่างโค้ดของเราคุณจะสามารถปรับใช้โทเค็น Ethereum ERC-20 ของคุณเองได้.
มีความสุข!