ประสบการณ์ครั้งแรกของฉันกับNEAR blockchain

ฉันชื่อ Alex และฉันได้สร้างElixir API สำหรับ NEAR blockchain เราหวังว่าข้อมูลนี้จะเป็นประโยชน์สำหรับคุณ และโปรดติดต่อฉันหากคุณมีคำถามใดๆ

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

หากคุณต้องการข้ามไปยังตัวอย่างโค้ดและข้ามเรื่องราวของฉันและความชื่นชมใน NEAR blockchain ให้เลื่อนลงไปที่ "ตัวอย่างการใช้งานและโค้ด"

ทำไมฉันถึงต้องการ Elixir API สำหรับ NEAR

วันหนึ่งเพื่อนของฉันบอกฉันว่าเขากำลังสร้างเกมวางแผนผลัดกันเล่นที่ดูเหมือน Clash of Clans และเกมนี้จะทำงานบน NEAR blockchain ฉันถามว่าทำไม NEAR ในเมื่อเรามี Ethereum พร้อม Solidity smart contracts? คำตอบของเขาคือ: “ลองจินตนาการว่าธุรกรรมบล็อคเชนของคุณเสร็จสิ้นภายในไม่กี่วินาที และไม่มีค่าใช้จ่ายประมาณ 10 ดอลลาร์ แต่เป็นเพียงเศษเสี้ยวหนึ่ง” ฉัน (และยังใหม่) ต่อการพัฒนาบล็อคเชน แต่ฉันได้ยินมาว่า Ethereum มีปัญหาเช่นนี้ — ธุรกรรมที่ช้าและมีราคาแพง

ดังนั้นฉันจึงตัดสินใจทำบางสิ่งเพื่อตัวเอง NEAR และตัวเลือกของฉันคือเกม TicTacToe แบบผู้เล่นหลายคนแบบเรียลไทม์ที่เรียบง่ายพร้อมการแข่งขันและเงินรางวัล (สปอยเลอร์: ในที่สุดฉันก็สร้างอย่างอื่น)

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

การรวมสองสิ่งนี้เข้าด้วยกันน่าจะให้สิ่งที่ยอดเยี่ยมแก่เรา!

NEAR Protocol คืออะไร

ฉันคิดว่าพวกคุณมีประสบการณ์ในการพัฒนาซอฟต์แวร์ เคยได้ยินเกี่ยวกับ Elixir และรู้ว่าทำไม Elixir และ Phoenix ถึงยอดเยี่ยมมาก ให้ฉันบอกสักสองสามคำเกี่ยวกับ NEAR Protocol

ใกล้แล้ว — เป็นบล็อกเชนที่ปรับขนาดได้ รวดเร็ว และราคาถูกด้วยSmart Contracts ใน Rust และ AssemblyScript

ก่อนอื่น ฉันชอบ NEAR สำหรับ ราคา น้ำมัน /ราคาซื้อขาย

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

ด้วยราคาใกล้จะถูกกว่า - ต้นทุนการทำธุรกรรมต่ำกว่า 0.1 ดอลลาร์ ถ้าเราพูดถึงตัวเลข ในขณะที่เขียนบทความนี้ ราคาเฉลี่ยสำหรับธุรกรรมใน Ethereum คือ$6–$180ใน NEAR เป็น~$0.017ความแตกต่างที่มีนัยสำคัญใช่ไหม

ต่อไป ฉันชอบความเร็วของการเพิ่มธุรกรรมใน NEAR แพลตฟอร์ม NEAR มี "นาฬิกา" - บล็อกใหม่เกือบทุกวินาทีจะถูกสร้างขึ้นในบล็อกเชน วิธีนี้ช่วยให้จำกัดราคาน้ำมันและบล็อกได้เร็วขึ้น NEAR มีการออกแบบแบบแบ่งส่วนและด้วยความเร็วบล็อกขนาดเล็ก 1 วินาทีในการเพิ่มธุรกรรมของคุณนั้นสูงมาก

สุดท้าย smart contracts อยู่ในRustและAssemblyScript ทั้งสองภาษาค่อนข้างใช้งานง่ายสำหรับสัญญาและมีตัวอย่างมากมาย

ตัวอย่างการใช้งานและโค้ด

โอเค พอคุยเล่นพอแล้ว จะใช้ยังไงดี และตัวอย่างโค้ดที่คุณพูดอยู่ที่ไหน?

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

“ดู-Blockchain” ตัวอย่าง

ในการดูธุรกรรมบล็อคเชน คุณไม่จำเป็นต้องมีคีย์การเข้าถึงเสมอไป NEAR API บางตัวอนุญาตให้คุณดูบล็อคและธุรกรรมโดยไม่ต้องใช้คีย์โดยใช้ฟังก์ชันRPC

ตัวอย่างเช่น หากต้องการดูบล็อกที่มีอยู่ คุณต้องเรียกBlockใช้ฟังก์ชัน RPC

ขั้นแรก เราบอกห้องสมุดของเราว่าเราจะทำงานกับเครือข่ายใด: — นี่คือexport NEAR_NODE_URL=https://rpc.testnet.near.orgtestnet

จากนั้นเพียงแค่เรียกง่ายๆ ว่าNearApi.RPC.Block.block()ให้ข้อมูลที่สมบูรณ์ของบล็อกที่ได้รับการยืนยันล่าสุดในบล็อคเชน (ฉันตัดทอนคำตอบ ในความเป็นจริงจะมีมากกว่านั้น):

มีฟังก์ชัน RPC แบบดูอย่างเดียวอีกมากมายใน APIสำหรับแต่ละฟังก์ชัน ฉันได้สร้าง ตัวอย่าง Livebookดังนั้นคุณจะสามารถเรียกใช้ฟังก์ชันทั้งหมดที่อยู่ในเครื่อง (หรือบนFly.io ) และดูการตอบกลับสดจาก NEAR RPC API

“Modify-Blockchain” ตัวอย่าง

ในการสร้างธุรกรรมใหม่ใน NEAR คุณจะต้อง "รับรองความถูกต้อง" — blockchain จำเป็นต้องมีเจ้าของธุรกรรม กล่าวอีกนัยหนึ่ง คุณต้องมีคู่คีย์ผู้ลงนาม (สาธารณะ & ส่วนตัว) เพื่อให้คุณสามารถลงนามในธุรกรรมก่อนที่จะส่งไปยังบล็อคเชน ในการรับ คู่คีย์ คุณจะต้องสร้าง NEAR Wallet

สิ่งสำคัญเกี่ยวกับคีย์ผู้ลงนาม — มีสองประเภท:

• Full Access Keysคุณจะได้รับเมื่อคุณสร้างกระเป๋าสตางค์ มันถูกเก็บไว้ในเบราว์เซอร์ของคุณ
• FunctionCall Access Keysดังนั้น คุณสามารถจำกัดการเข้าถึง Wallet ของคุณให้กับ Smart Contract โดยไม่ต้องโอนโทเค็น NEAR
  ( เพิ่มเติมเกี่ยวกับคีย์การเข้าถึง )

ส่งตัวอย่างโทเค็น NEAR

ตัวอย่างเช่น ให้ส่งโทเค็น NEAR บางส่วน คุณจะต้องใช้FullAccessกุญแจในการทำเช่นนั้น ในการรับFullAccessกุญแจ คุณสามารถคว้ามันจากที่เก็บข้อมูลของเบราว์เซอร์ เช่นเดียวกับรูปภาพด้านบน หรือเข้าสู่ระบบด้วยNEAR CLIและหยิบกุญแจจากที่จัดเก็บไฟล์ในเครื่อง เช่น หากที่อยู่ NEAR Wallet ของคุณ testnetคือmintbot.testnetไฟล์กุญแจของคุณจะอยู่ที่นี่:
~/.near-credentials/testnet/mintbot.testnet.jsonและ เนื้อหาจะเป็นดังนี้:

{
  "account_id": "mintbot.testnet",
  "public_key": "ed25519:XXXXXXXXXXXXXXXXXXX",
  "private_key": "ed25519:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}

ผลลัพธ์ที่สำเร็จจะเป็น JSON ที่มีข้อมูลทั้งหมดเกี่ยวกับธุรกรรมและใบเสร็จรับเงินที่สร้างขึ้น

นี่คือ ตัวอย่าง Send Tokens Livebookพร้อมคำตอบที่คุณสามารถลองใช้ในเครื่องได้

ตัวอย่างการโทรสัญญาอัจฉริยะใกล้บ้าน

การเรียกสัญญาอัจฉริยะ — เป็นอีกวิธีหนึ่งในการเปลี่ยนสถานะบล็อคเชน เป็นธุรกรรม NEAR ประเภทหนึ่งโดยเฉพาะFunctionCall— สัญญาอัจฉริยะใน NEAR มีที่อยู่ของตัวเอง เช่นnft.mintbot.comและรายการวิธีที่เราสามารถโทรติดต่อได้

ในการลงนามในFunctionCallธุรกรรมคุณไม่จำเป็นต้องมีFullAccessคีย์ในกรณีส่วนใหญ่LimitedAccessคีย์ก็เพียงพอแล้ว

Elixir NEAR API มีฟังก์ชันเรียกสัญญาอัจฉริยะ:

{:ok, result} = 
  NearApi.Contract.call(
    caller_account, 
    contract_address,
    contract_function,
    function_params
  )

พารามิเตอร์ของฟังก์ชันคือ:

• caller_account— บัญชีที่เรียกใช้ฟังก์ชัน
• "nft.mintbot.near"— ที่อยู่ของสัญญาอัจฉริยะ
• nft_mint— หน้าที่ของสัญญาอัจฉริยะ
• params— พารามิเตอร์ของฟังก์ชันสัญญาอัจฉริยะที่คุณกำลังผ่าน

NEAR FunctionCallTransaction Livebook อยู่ที่นี่พร้อมตัวอย่างคำขอและคำตอบ

มีอะไรอยู่ใต้กระโปรงหน้ารถ?

ตัวอย่าง modified-blockchain ด้านบนใช้NearApi.Transactionmodule & struct กับActions ที่แตกต่างกันตั้งแต่หนึ่งรายการขึ้น ไป

สร้างธุรกรรม NEAR ใน Elixir

กระบวนการประกอบด้วย 4 ขั้นตอน:

1. สร้างโครงสร้างธุรกรรม
2. ทำธุรกรรมให้เป็นเลขฐานสองด้วยBorsh
3. ลงนามในการทำธุรกรรมด้วย KeyPair . ของคุณ
4. base64 เข้ารหัสและส่งธุรกรรมไปยัง blockchain

โดยพื้นฐานแล้ว ธุรกรรมใน NEAR คือรายการการดำเนินการที่ใช้กับบล็อคเชนพร้อมข้อมูลเสริมบางอย่าง

ธุรกรรมทั้งหมดจะต้องถูกจัดลำดับเป็นรหัสไบนารีเนื่องจาก NEAR ยอมรับรูปแบบไบนารีเท่านั้น ฉันทำอย่างนั้นด้วยการใช้งานBorsh binary serialiser สำหรับ Elixir

ฉันกำลังข้ามรายละเอียดทั้งหมดที่คุณต้องทำเพื่อส่งธุรกรรมไปยัง blockchain คุณสามารถดูซอร์สโค้ดได้ที่นี่และที่นี่แต่โปรดดูที่การเรียกใช้ฟังก์ชันสุดท้ายที่คุณทำเมื่อคุณส่งลายเซ็น ธุรกรรมต่อเนื่อง:

tx =
"DwAAAG1pbnRib3QudGVzdG5ldABBxGVmSnc0VBAFqP1zcbviUut4vLbS/JK9UyECT5xGUgFeAb8uTgAAGgAAAG5mdF90ZXN0MTAubWludGJvdC50ZXN0bmV0AD7PlYhteyB6OGGxA6jG557JRwkL9vKXNlXlz0VTn9cBAAAAAggAAABuZnRfbWludDoBAAB7Im1ldGFkYXRhIjp7ImNvcGllcyI6MSwiZGVzY3JpcHRpb24iOiJORlQgZm9yIG1pbnRib3QudGVzdG5ldCBieSBNaW50Ym90IiwibWVkaWEiOiJodHRwczovL2lwZnMuaW8vaXBmcy9iYWZrcmVpYndxdGFkbmMyc3A0ZHNsMmt6ZDRqemFsNGR2eWo1bWx6czJhanNnNmRteGxrdXY1YTY1ZSIsInRpdGxlIjoiTkZUIGZvciBtaW50Ym90LnRlc3RuZXQgYnkgTWludGJvdCJ9LCJyZWNlaXZlcl9pZCI6Im1pbnRib3QudGVzdG5ldCIsInRva2VuX2lkIjoibWludGJvdC1uZnQtR2VYeDZwYTRybjVNSHBGcVlKUlJLeVAxaDZzVjJtWDZBdVg2MWdNOFE2aTMifQDAbjHZEAEAAAAAAAAAAAAAAAAAAAAAAAAQ3ktoL2UqPz0oTlYklUgUsNfhhd6MbdYubdrZsdRTCwIv3cYK7+zDHyvW2gLec1NR5AsipbGy405NyqMyvV0J"

NearApi.RPC.Transactions.send_transaction_commit(tx)

NearApi.RPC.Transactions.send_transaction_commit— ฟังก์ชันซิงโครนัสที่ส่งtxไปยังบล็อคเชนและwaits สำหรับผลลัพธ์ (แบบอะซิงโครนัสคือNearApi.RPC.Transactions.send_transaction_async)

Elixir NEAR API ในการผลิต

อย่างที่ฉันพูดไปก่อนหน้านี้ว่าแผนของฉันคือการสร้างเกม TicTacToe แต่ต่อมา หลังจากที่ฉันคุยกับผู้ชายจากHumanGuildฉันเปลี่ยนใจและตัดสินใจสร้างสิ่งที่ซับซ้อนน้อยลง — เครื่องมือสำหรับการสร้าง NFT

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

ด้วย Elixir API MVP พร้อม (พร้อมNearApi.RPCและความสามารถในการส่งFunctionCallธุรกรรม) ฉันเริ่มทำงานในโครงการ

นี่คือที่มาของ Mintbot Mintbot — เป็นแพลตฟอร์มแชทบอทสำหรับสร้าง NFT บนบล็อคเชน NEAR

ด้วย Mintbot ฉันตั้งเป้าหมาย 3 เป้าหมายพร้อมกัน:

• สร้างเครื่องมือที่ง่ายมากสำหรับการทำ NFT (ดูการสาธิตบน YouTube ที่นี่ )
• สร้างหลักฐานการทำงานของElixir NEAR API
• ส่งโครงการMETABULD Hackathonแล้ววิน (สปอย ผมไม่ชนะ 555)

นั่นก็เพียงพอแล้วที่จะส่งMintbotโครงการไปสู่ ​​​​hackathon ได้สำเร็จก่อนถึงกำหนด yay!

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

ทรัพยากร

นอกเหนือจากนี้ ต่อไปนี้คือแหล่งข้อมูล/แหล่งอ่านดีๆ เกี่ยวกับ NEAR และ Elixir:

• บทนำสู่ NEAR สำหรับนักพัฒนาอาวุโส (โดยทั่วไป บทนี้ครอบคลุมทุกสิ่งที่คุณจำเป็นต้องรู้เพื่อเริ่มต้นด้วย NEAR)
• บทช่วยสอน NFT สำหรับ NEAR
• ตัวอย่างโค้ด NEAR
• หากคุณต้องการเริ่มต้นด้วย Elixir คุณควรไปที่นี่
• ฟอรัม Elixirสถานที่ที่ยอดเยี่ยมสำหรับนักพัฒนาน้ำอมฤต
• Borsh Serialiser ไบนารีใน Elixir