ด้วยตลาดโทเค็นแบบใช้ร่วมกันไม่ได้ (NFT)ถึงจุดสุดยอดมองย้อนกลับไปที่ NFT ที่ค่อนข้างเร็วและนึกถึงCryptoKittiesความท้าทายเป็นเรื่องสนุก นี้โดยDapper Labsกรณีการใช้งานขนาดใหญ่ครั้งแรกที่ทีมสร้างขึ้นยังทำให้ Ethereum ตกอยู่ภายใต้แรงกดดันจากการจราจรเป็นครั้งแรก
และRarible，OpenSea，FoundationและSorareแพลตฟอร์มแบบนี้เริ่มเกิดขึ้น เงินหลายล้านดอลลาร์ไหลผ่านแพลตฟอร์มเหล่านี้ทุกเดือน แต่ส่วนใหญ่เกิดขึ้นบน Ethereum blockchain อย่างไรก็ตาม เมื่อทีมงานของ Dapper Labs มีประสบการณ์ในการพัฒนา CryptoKitties แล้ว พวกเขาก็ออกเดินทางสร้างห่วงโซ่สาธารณะใหม่ห่วงโซ่สาธารณะจะเป็นสากล แต่ยังเหมาะสำหรับการพัฒนา NFT เป้าหมายของการดำเนินการนี้คือเพื่อแก้ปัญหาต่างๆ ที่พบกับ NFT บน Ethereum ในขณะเดียวกันก็มอบประสบการณ์ที่ดีขึ้นสำหรับนักพัฒนาและนักสะสมในพื้นที่ Flow บล็อกเชนใหม่ของพวกเขาได้พิสูจน์ตัวเองแล้วว่ามีความสามารถในการชนะพันธมิตรกับแบรนด์ชื่อดัง ตัวอย่างเช่นNBA, UFC และแม้แต่ Dr. Seuss ก็เป็นกระแสเช่นกัน
เราเพิ่งเขียนเกี่ยวกับสร้าง NFT ด้วยการสนับสนุนเนื้อหาในตัวบน IPFSบทความ และเราจะหารือเกี่ยวกับปัญหาความรับผิดในพื้นที่ NFT และวิธีที่เราคิดว่า IPFS สามารถช่วยได้ ตอนนี้ได้เวลาหารือเกี่ยวกับวิธีสร้าง nfts บนโฟลว์ที่ขับเคลื่อนด้วย IPFS แอปพลิเคชั่นต้น ๆ ที่สำคัญอย่างหนึ่งของ Flow blockchain คือNBA Top Shot. เราจะสร้างตัวอย่างพื้นฐานแล้วสำรองข้อมูลเมตาของ NFT บน IPFS
เพราะเราชอบpiñatasแทนที่จะเป็นวิดีโอไฮไลท์ของ NBA ดังนั้นเราจะสร้างวิดีโอพินยาตาที่แลกเปลี่ยนได้ซึ่งถูกทุบในงานปาร์ตี้
นี่คือบทช่วยสอนสามส่วน:
1. สร้างสัญญาและเหรียญกษาปณ์
2. สร้างแอปเพื่อดู NFT ที่สร้างโดยสัญญานี้
3. สร้างตลาดเพื่อโอน NFT ให้กับผู้อื่น และโอนสินทรัพย์อ้างอิงของ NFT นี้บน IPFS
มาเริ่มบทช่วยสอนแรกกันเลย
การกำหนดค่า
เราต้องติดตั้ง Flow CLI เอกสารประกอบของ Flow มีคำแนะนำในการติดตั้งที่ดี แต่ฉันจะทำซ้ำที่นี่:
ระบบแอปเปิ้ล
brew install flow-cli
Linux
sh -ci “$(curl -fsSL https://storage.googleapis.com/flow-cli/install.sh)"
Windows
iex “& { $(irm ‘https://storage.googleapis.com/flow-cli/install.ps1') }”
เราจะจัดเก็บไฟล์ทรัพย์สินบน IPFS เพื่อให้สิ่งต่าง ๆ ง่ายขึ้น เราสามารถใช้Pinata. คุณสามารถลงทะเบียนได้ที่นี่บัญชีฟรีและรับรหัส API ที่นี่ ในบทความที่สองของบทช่วยสอนนี้ เราจะใช้APIแต่ในบทความนี้เราจะใช้เว็บไซต์ Pinata
เรายังจำเป็นต้องติดตั้ง NodeJS และโปรแกรมแก้ไขข้อความเพื่อช่วยเน้นโค้ด Flow smart contract (เริ่มต้นด้วยCadenceภาษา) ไวยากรณ์ คุณสามารถติดตั้งโหนดได้ที่นี่ รหัส Visual Studio มีรองรับส่วนขยาย Cadence。
มาสร้างไดเร็กทอรีเพื่อเริ่มโครงการของเรากันเถอะ
mkdir pinata-party
เปลี่ยนเป็นไดเรกทอรีนั้นและเริ่มต้นโครงการโฟลว์ใหม่:
cd pinata-party
flow project init
ตอนนี้ เปิดโปรเจ็กต์ในตัวแก้ไขโค้ดที่คุณชื่นชอบ (อีกครั้ง หากคุณใช้ Visual Studio Code ให้ติดตั้งส่วนขยาย Cadence) และเริ่มพัฒนา
คุณจะเห็นไฟล์ flow.json ซึ่งเราจะใช้ในไม่ช้า ขั้นแรก สร้างโฟลเดอร์ชื่อ cadence ภายในโฟลเดอร์นั้น ให้เพิ่มโฟลเดอร์อื่นที่เรียกว่าสัญญา สุดท้าย สร้างไฟล์ชื่อ PinataPartyContract.cdc ในโฟลเดอร์สัญญา
ก่อนที่จะดำเนินการต่อ สิ่งสำคัญคือต้องชี้ให้เห็นว่าทุกสิ่งที่เราทำกับ Flow blockchain จากนี้ไปจะทำบนโปรแกรมจำลอง อย่างไรก็ตาม การปรับใช้โปรเจ็กต์กับ testnet หรือ mainnet นั้นง่ายพอๆ กับการอัปเดตการตั้งค่าการกำหนดค่าในไฟล์ flow.json ตอนนี้มาตั้งค่าไฟล์นี้สำหรับสภาพแวดล้อมของโปรแกรมจำลอง จากนั้นเราจะเริ่มเขียนสัญญาได้
อัปเดตสัญญาใน flow.json ให้เป็นดังนี้:
"contracts": {
"PinataPartyContract": "./cadence/contracts/PinataPartyContract.cdc"
}
จากนั้น อัปเดตการปรับใช้ใน flow.json ดังนี้:
"deployments": {
"emulator": {
"emulator-account": ["PinataPartyContract"]
}
}
นี่เป็นการบอกให้ Flow CLI ใช้โปรแกรมจำลองเพื่อปรับใช้สัญญาของเรา มันยังอ้างอิงถึงบัญชี (บนโปรแกรมจำลอง) และสัญญาที่เรากำลังจะเขียน
สัญญา
สัญญา
Flow ให้บทช่วยสอนที่ยอดเยี่ยมเกี่ยวกับการสร้างสัญญา NFT นี่เป็นจุดอ้างอิงที่ดี แต่เป็นโฟลว์ดังที่ได้กล่าวไว้พวกเขายังไม่ได้แก้ไขปัญหาข้อมูลเมตา NFT พวกเขาต้องการจัดเก็บข้อมูลเมตาบนเครือข่าย นั่นเป็นความคิดที่ดีและพวกเขาจะได้แนวทางที่สมเหตุสมผลอย่างแน่นอน อย่างไรก็ตาม ตอนนี้เราต้องการสร้างโทเค็นด้วยข้อมูลเมตา และเราต้องการไฟล์มีเดียที่เกี่ยวข้องกับ NFT ข้อมูลเมตาเป็นเพียงองค์ประกอบหนึ่งเท่านั้น เรายังจำเป็นต้องระบุไฟล์สื่อที่โทเค็นเป็นตัวแทนในท้ายที่สุด
หากคุณคุ้นเคยกับ NFT บน Ethereum blockchain คุณอาจรู้ว่าสินทรัพย์จำนวนมากที่ส่งคืนโดยโทเค็นเหล่านี้ถูกเก็บไว้ในผู้ให้บริการพื้นที่จัดเก็บข้อมูลและคลาวด์แบบดั้งเดิมกลาง. ไม่เป็นไรตราบใดที่พวกเขาไม่ลงไป เราเคยเขียนเกี่ยวกับการค้นหาและจัดเก็บเนื้อหาบนแพลตฟอร์มคลาวด์แบบดั้งเดิมเทียบกับบล็อกเชน มันเดือดลงไปสองจุด:
ทรัพย์สินควรตรวจสอบได้
การถ่ายโอนพื้นที่เก็บข้อมูลควรเป็นเรื่องง่าย
IPFSพิจารณาทั้งสองด้าน จากนั้น Pinata จะถูกจัดชั้นด้วยวิธีง่ายๆ ในการจัดเก็บเนื้อหาระยะยาวบน IPFS นั่นคือสิ่งที่เราต้องการสำหรับสื่อที่เราต้องการสนับสนุน NFT ใช่ไหม เราต้องการให้แน่ใจว่าเราสามารถพิสูจน์ความเป็นเจ้าของ (NFT) ให้ข้อมูลเกี่ยวกับ NFT (NFT) และตรวจสอบให้แน่ใจว่าเราสามารถควบคุมสินทรัพย์อ้างอิง (IPFS) - (ไฟล์มีเดียหรืออะไรก็ตาม) ไม่ใช่ของจำลอง เมื่อคำนึงถึงทั้งหมดนี้แล้ว เรามาเขียนสัญญาที่สร้าง NFT เชื่อมโยงข้อมูลเมตากับ NFT และตรวจสอบให้แน่ใจว่าข้อมูลเมตานั้นชี้ไปยังสินทรัพย์อ้างอิงที่จัดเก็บไว้ใน IPFS
เปิด PinataPartyContract.cdc แล้วมาเริ่มกันเลย
pub contract PinataPartyContract {
pub resource NFT {
pub let id: UInt64
init(initID: UInt64) {
self.id = initID
}
}
}
ขั้นตอนแรกคือการกำหนดสัญญาของเรา เราจะเพิ่มมากขึ้นในเรื่องนี้ แต่ก่อนอื่นเราจะกำหนด PinataPartyContract และสร้างทรัพยากรภายในนั้น ทรัพยากรคือรายการที่จัดเก็บไว้ในบัญชีผู้ใช้และสามารถเข้าถึงได้ผ่านการควบคุมการเข้าถึง ในกรณีนี้ ทรัพยากร NFT จะถูกครอบครองในที่สุดโดยการเป็นเจ้าของสิ่งที่ใช้เป็นตัวแทนของ NFT NFT จะต้องสามารถระบุตัวตนได้โดยไม่ซ้ำกัน แอตทริบิวต์ id ช่วยให้เราสามารถระบุโทเค็นได้
ต่อไป เราต้องสร้างส่วนต่อประสานทรัพยากรที่จะใช้เพื่อกำหนดว่าฟังก์ชันใดที่ผู้อื่นสามารถใช้ได้ (เช่น ผู้ที่ไม่ใช่เจ้าของสัญญา):
pub resource interface NFTReceiver {
pub fun deposit(token: @NFT, metadata: {String : String})
pub fun getIDs(): [UInt64]
pub fun idExists(id: UInt64): Bool
pub fun getMetadata(id: UInt64) : {String : String}
}
วางไว้ด้านล่างรหัสทรัพยากร NFT อินเทอร์เฟซ NFTReceiver หมายความว่าใครก็ตามที่เรากำหนดให้เข้าถึงทรัพยากรจะสามารถเรียกใช้เมธอดต่อไปนี้:
deposit
getIDs
idExists
getMetadata
ต่อไป เราต้องกำหนดอินเทอร์เฟซการรวบรวมโทเค็นของเรา ให้คิดว่าเป็นกระเป๋าเงินที่เก็บ NFT ของผู้ใช้ทั้งหมด
pub resource Collection: NFTReceiver {
pub var ownedNFTs: UInt64: NFT}
pub var metadataObjs: {UInt64: { String : String }}
init () {
self.ownedNFTs <- {}
self.metadataObjs = {}
}
pub fun withdraw(withdrawID: UInt64): @NFT {
let token <- self.ownedNFTs.remove(key: withdrawID)!
return <-token }
pub fun deposit(token: @NFT, metadata: {String : String}) {
self.ownedNFTs[token.id] <-! token }
pub fun idExists(id: UInt64): Bool {
return self.ownedNFTs[id] != nil }
pub fun getIDs(): [UInt64] {
return self.ownedNFTs.keys }
pub fun updateMetadata(id: UInt64, metadata: {String: String}) {
self.metadataObjs[id] = metadata }
pub fun getMetadata(id: UInt64): {String : String} {
return self.metadataObjs[id]!
}
destroy() {
destroy self.ownedNFTs }}
มีหลายอย่างเกิดขึ้นในแหล่งข้อมูลนี้ อันดับแรก เรามีตัวแปรชื่อ ownedNFTs มันง่ายมาก ติดตาม NFT ทั้งหมดที่ผู้ใช้เป็นเจ้าของในสัญญานั้น
ต่อไป เรามีตัวแปรชื่อ metadataObjs นี่เป็นเรื่องพิเศษเล็กน้อยตรงที่เรากำลังขยายการทำงานของสัญญา Flow NFT เพื่อจัดเก็บการแมปข้อมูลเมตาสำหรับแต่ละ NFT ตัวแปรนี้จับคู่รหัสโทเค็นกับข้อมูลเมตาที่เกี่ยวข้อง ซึ่งหมายความว่าเราต้องตั้งค่ารหัสโทเค็นก่อนจึงจะสามารถตั้งค่าได้
จากนั้น เราเริ่มต้นตัวแปร สิ่งนี้จำเป็นสำหรับตัวแปรที่กำหนดในทรัพยากรในโฟลว์
สุดท้าย เรามีคุณสมบัติทั้งหมดสำหรับแหล่งข้อมูลการรวบรวม NFT โปรดทราบว่าคุณสมบัติเหล่านี้ไม่สามารถใช้งานได้ทั้งหมด หากคุณจำได้ เราได้กำหนดฟังก์ชันที่พร้อมใช้งานสำหรับทุกคนก่อนหน้านี้ในอินเทอร์เฟซทรัพยากร NFTReceiver
ฉันต้องการชี้ให้เห็นถึงฟังก์ชันการฝากเงิน เช่นเดียวกับที่เราขยายสัญญา Flow NFT เริ่มต้นเพื่อรวมแผนที่ metadataObjs เรายังขยายฟังก์ชันฝากเริ่มต้นเพื่อรับข้อมูลเมตาของพารามิเตอร์เพิ่มเติม ทำไมเราถึงทำสิ่งนี้ที่นี่? เราจำเป็นต้องตรวจสอบให้แน่ใจว่ามีเพียงตัวประมวลผลของโทเค็นเท่านั้นที่สามารถเพิ่มข้อมูลเมตานั้นลงในโทเค็นได้ เพื่อรักษาความเป็นส่วนตัว เราจำกัดการเพิ่มเมทาดาทาเริ่มต้นในการดำเนินการสร้างเหรียญกษาปณ์
รหัสสัญญาของเราใกล้จะสมบูรณ์แล้ว ดังนั้น ใต้ทรัพยากรคอลเลกชัน ให้เพิ่มสิ่งต่อไปนี้:
pub fun createEmptyCollection(): @Collection {
return <- create Collection()}pub resource NFTMinter {
pub var idCount: UInt64
init() {
self.idCount = 1
}
pub fun mintNFT(): @NFT {
var newNFT <- create NFT(initID: self.idCount)
self.idCount = self.idCount + 1 as UInt64 return <-newNFT }}
อันดับแรก เรามีฟังก์ชันที่เมื่อเรียกใช้แล้ว จะสร้างคอลเล็กชัน NFT ที่ว่างเปล่า ด้วยวิธีนี้ ผู้ใช้ที่โต้ตอบกับสัญญาของเราเป็นครั้งแรกจะมีสถานที่จัดเก็บที่สร้างขึ้นในการรวบรวมทรัพยากรที่เรากำหนด
หลังจากนั้นเราสร้างทรัพยากรอื่น นี่เป็นสิ่งสำคัญเพราะหากไม่มีเราจะไม่สามารถสร้างโทเค็นได้ ทรัพยากร NFTMinter รวมถึง idCount ซึ่งเพิ่มขึ้นเพื่อให้แน่ใจว่าเราไม่มีรหัสซ้ำใน NFT ของเรา นอกจากนี้ยังมีฟังก์ชันในการสร้าง NFT ของเรา
ด้านล่างทรัพยากร NFTMinter ให้เพิ่มตัวเริ่มต้นสัญญาหลัก:
init() {
self.account.save(<-self.createEmptyCollection(), to: /storage/NFTCollection)
self.account.link<&{NFTReceiver}>(/public/NFTReceiver, target: /storage/NFTCollection)
self.account.save(<-create NFTMinter(), to: /storage/NFTMinter)
}
ฟังก์ชันการเริ่มต้นนี้จะถูกเรียกใช้เมื่อมีการปรับใช้สัญญาเท่านั้น มันทำสามสิ่ง:
1. สร้างคอลเลกชันเปล่าสำหรับผู้ปรับใช้คอลเลกชัน เพื่อให้เจ้าของสัญญาสามารถสร้าง NFT ของสัญญาและเป็นเจ้าของ NFT
2.Collection Reference NFTReceiver อินเทอร์เฟซที่เราสร้างขึ้นเมื่อเริ่มต้น ทรัพยากรนี้เผยแพร่ในสถานที่สาธารณะ นี่คือวิธีที่เราบอกสัญญาว่าทุกคนสามารถเรียกใช้ฟังก์ชันที่กำหนดไว้ใน NFTReciver ได้
3. ทรัพยากร NFTMinter จะถูกบันทึกไว้ในผู้สร้างสัญญาการจัดเก็บบัญชี ซึ่งหมายความว่ามีเพียงผู้สร้างสัญญาเท่านั้นที่สามารถสร้างโทเค็นได้
สัญญาที่สมบูรณ์ได้ที่นี่.
ตอนนี้เรามีสัญญาพร้อมแล้ว เรามาปรับใช้กันดีไหม เราน่าจะอยู่ที่Flow Playgroundทดสอบบน. ไปที่นั่นแล้วคลิกที่บัญชีแรกในแถบด้านข้างซ้าย แทนที่รหัสทั้งหมดในสัญญาตัวอย่างด้วยรหัสสัญญาของเรา แล้วคลิกปรับใช้ หากทุกอย่างเรียบร้อยดี คุณจะเห็นบันทึกในลักษณะนี้ในหน้าต่างบันทึกที่ด้านล่างของหน้าจอ:
16:48:55 Deployment Deployed Contract To: 0x01
ตอนนี้เราพร้อมที่จะปรับใช้สัญญากับโปรแกรมจำลองที่ทำงานในเครื่องแล้ว ที่บรรทัดรับคำสั่ง ให้รันคำสั่งต่อไปนี้:
flow project start\-emulator
ขณะนี้ เมื่อโปรแกรมจำลองทำงานและไฟล์ flow.json ได้รับการกำหนดค่าอย่างถูกต้อง เราก็สามารถปรับใช้สัญญาได้ เพียงเรียกใช้คำสั่งต่อไปนี้:
flow project deploy
หากทุกอย่างเป็นไปด้วยดี คุณจะเห็นผลลัพธ์ที่คล้ายกับต่อไปนี้:
ปรับใช้ 1 สัญญาสำหรับบัญชี: บัญชีจำลอง
Deploying 1 contracts for accounts: emulator-account
PinataPartyContract -> 0xf8d6e0586b0a20c7
การสร้าง NFTs
การสร้าง NFTs
ในบทความที่สองของบทช่วยสอนนี้ เราจะพยายามทำให้กระบวนการแคสต์เป็นมิตรกับผู้ใช้มากขึ้นผ่านแอปพลิเคชันและอินเทอร์เฟซผู้ใช้ เพื่อแสดงให้เห็นและแสดงว่าเมตาดาต้าจะทำงานร่วมกับ NFT บน Flow ได้อย่างไร เราจะใช้สคริปต์ Cadence และบรรทัดคำสั่ง
มาสร้างไดเร็กทอรีใหม่ที่รูทของโปรเจ็กต์ pinata-party และเรียกมันว่าทรานแซคชัน หลังจากสร้างโฟลเดอร์แล้ว ให้สร้างไฟล์ใหม่ชื่อ MintPinataParty.cdc ภายในโฟลเดอร์
ในการเขียนธุรกรรม เราจำเป็นต้องอ้างอิงไฟล์ในข้อมูลเมตาที่ให้ไว้กับ NFT ในการทำเช่นนี้ เราจะอัปโหลดไฟล์ไปยัง IPFS ผ่าน Pinata ในบทช่วยสอนนี้ เนื่องจาก NFT ของเรามุ่งเน้นไปที่วิดีโอที่ซื้อขายได้ของพินยาตาที่ถูกทุบในงานปาร์ตี้ เราจึงจะอัปโหลดวิดีโอของเด็กๆ ที่ตีพินยาตาในงานเลี้ยงวันเกิด คุณสามารถอัปโหลดไฟล์วิดีโอที่คุณต้องการ คุณสามารถอัปโหลดไฟล์เนื้อหาใดๆ และเชื่อมโยงกับ NFT ได้ แต่บทความที่สองในชุดบทช่วยสอนนี้จะตั้งตาคอยเนื้อหาวิดีโอ เมื่อไฟล์วิดีโอพร้อมที่จะเล่นแล้วกรุณาอัพโหลดที่นี่. หลังจากอัปโหลดไฟล์ คุณจะได้รับแฮช IPFS (มักเรียกว่า Content Identifier หรือ CID) คัดลอกแฮชนี้เนื่องจากเราจะใช้ในระหว่างกระบวนการสร้างเหรียญ
ตอนนี้ เพิ่มสิ่งต่อไปนี้ในไฟล์ MintPinataParty.cdc:
import PinataPartyContract from 0xf8d6e0586b0a20c7transaction {
let receiverRef: &{PinataPartyContract.NFTReceiver}
let minterRef: &PinataPartyContract.NFTMinter
prepare(acct: AuthAccount) {
self.receiverRef = acct.getCapability<&{PinataPartyContract.NFTReceiver}>(/public/NFTReceiver)
.borrow()
?? panic("Could not borrow receiver reference")
self.minterRef = acct.borrow<&PinataPartyContract.NFTMinter>(from: /storage/NFTMinter)
?? panic("could not borrow minter reference")
}
execute {
let metadata : {String : String} = {
"name": "The Big Swing",
"swing_velocity": "29",
"swing_angle": "45",
"rating": "5",
"uri": "ipfs://QmRZdc3mAMXpv6Akz9Ekp1y4vDSjazTx2dCQRkxVy1yUj6"
}
let newNFT <- self.minterRef.mintNFT()
self.receiverRef.deposit(token: <-newNFT, metadata: metadata)
log("NFT Minted and deposited to Account 2's Collection")
}}
นี่เป็นเรื่องที่ค่อนข้างง่าย ขอบคุณไม่น้อยเลยที่ Work Flow ได้ทำให้สิ่งต่างๆ ง่ายขึ้น แต่มาอธิบายกัน ขั้นแรก คุณจะสังเกตเห็นคำสั่งนำเข้าที่ด้านบน หากคุณจำได้ เมื่อเราปรับใช้สัญญา เราได้รับบัญชี นั่นคือสิ่งที่เราต้องอ้างถึง ดังนั้น ให้แทนที่ 0xf8d6e0586b0a20c7 ด้วยที่อยู่บัญชีในการปรับใช้ของคุณ
ต่อไป เรากำหนดธุรกรรม ทุกสิ่งที่เกิดขึ้นที่นี่เกี่ยวข้องกับธุรกรรมที่เราวางแผนจะดำเนินการ
สิ่งแรกที่เราทำในธุรกรรมของเราคือกำหนดตัวแปรอ้างอิงสองตัวคือ receiverRef และ minterRef ในกรณีนี้ เราเป็นทั้งผู้รับ NFT และผู้ขุด NFT ตัวแปรทั้งสองนี้อ้างอิงถึงทรัพยากรที่เราสร้างขึ้นในสัญญา หากบุคคลที่ทำธุรกรรมไม่มีสิทธิ์เข้าถึงทรัพยากร ธุรกรรมจะล้มเหลว
ต่อไปเรามีฟังก์ชั่นเตรียม ฟังก์ชันนี้ใช้ข้อมูลบัญชีของบุคคลที่พยายามทำธุรกรรมและทำการยืนยันบางอย่าง เราพยายาม "ยืม" NFTMinter ที่เรากำหนดและฟังก์ชัน NFTReciver ที่มีอยู่ในทรัพยากรทั้งสอง หากบุคคลที่ทำธุรกรรมไม่สามารถเข้าถึงทรัพยากรเหล่านั้นได้ สิ่งต่างๆ ก็จะล้มเหลว
ในที่สุดเราก็มีฟังก์ชั่นการดำเนินการของเรา ฟังก์ชันนี้เป็นที่ที่เราสร้างข้อมูลเมตาสำหรับ NFT สร้าง NFT จากนั้นเชื่อมโยงข้อมูลเมตาก่อนที่จะฝาก NFT ไว้ในบัญชีของเรา หากคุณสังเกตเห็น ฉันได้สร้างตัวแปรข้อมูลเมตา ในตัวแปรนั้น ฉันได้เพิ่มข้อมูลบางอย่างเกี่ยวกับโทเค็น เนื่องจากโทเค็นของเราแสดงถึงกิจกรรมการทุบพิซซ่าในงานปาร์ตี้ และเนื่องจากเรากำลังพยายามจำลองสิ่งที่คุณเห็นใน NBA Top Shot ส่วนใหญ่ ฉันจึงกำหนดสถิติบางอย่างในข้อมูลเมตา เด็กแกว่งไม้เพื่อตีความเร็วของpiñata มุมการแกว่งและเกรด ฉันแค่เล่นกับสถิติเหล่านี้ อย่างไรก็ตาม คุณจะป้อนข้อมูลใดๆ ที่เหมาะสมกับโทเค็นของคุณในลักษณะเดียวกัน
คุณจะสังเกตเห็นว่าฉันได้กำหนดแอตทริบิวต์ในข้อมูลเมตาของ uri ด้วย ซึ่งจะชี้ไปที่แฮช IPFS ที่โฮสต์ไฟล์เนื้อหาที่เกี่ยวข้องกับ NFT ในกรณีนี้คือวิดีโอที่แท้จริงของ Piñata ที่กำลังถูกโจมตี คุณสามารถแทนที่แฮชด้วยแฮชที่คุณได้รับหลังจากอัปโหลดไฟล์ก่อนหน้านี้
เรานำหน้าแฮชด้วย ipfs:// นี่เป็นข้อมูลอ้างอิงที่เหมาะสมสำหรับไฟล์บน IPFS และสามารถใช้ได้กับทั้งเดสก์ท็อปไคลเอ็นต์และส่วนขยายของเบราว์เซอร์สำหรับ IPFS กล้าหาญยังให้การสนับสนุนเรายังสามารถวางโดยตรงในเบราว์เซอร์ที่กล้าหาญ。
เราเรียกฟังก์ชัน mintNFT ที่สร้างโทเค็น จากนั้นเราต้องเรียกฟังก์ชั่นการฝากเงินเพื่อฝากเข้าบัญชีของเรา นี่คือที่ที่เราส่งข้อมูลเมตา โปรดจำไว้ว่า เราได้กำหนดความสัมพันธ์ของตัวแปรในฟังก์ชันการฝากที่เพิ่มข้อมูลเมตาให้กับรหัสโทเค็นที่เกี่ยวข้อง
ตอนนี้เราเกือบจะพร้อมที่จะส่งธุรกรรมและสร้าง NFT แล้ว แต่ก่อนอื่นเราต้องเตรียมบัญชีของเรา จากบรรทัดคำสั่งในโฟลเดอร์รูทของโปรเจ็กต์ มาสร้างไพรเวตคีย์ใหม่สำหรับการเซ็นชื่อกัน เรียกใช้คำสั่งต่อไปนี้:
flow keys generate
สิ่งนี้จะให้รหัสสาธารณะและรหัสส่วนตัวแก่คุณ ปกป้องคีย์ส่วนตัวของคุณเสมอ
เราจะต้องใช้รหัสส่วนตัวเพื่อลงนามการทำธุรกรรม เพื่อให้เราสามารถวางลงในไฟล์ flow.json ของเราได้ เราต้องระบุอัลกอริทึมลายเซ็นด้วย นี่คือวัตถุบัญชีในไฟล์ flow.json ตอนนี้ควรมีลักษณะดังนี้:
“ accounts”：{
“ emulator-account”：{
"ที่อยู่": "ที่อยู่บัญชีของคุณ",
"privateKey": "รหัสส่วนตัวของคุณ",
"เชน": "โปรแกรมจำลองสตรีม",
“ sigAlgorithm”：“ ECDSA_P256”，
“ hashAlgorithm”：“ SHA3_256”
}
}，
หากคุณวางแผนที่จะจัดเก็บโปรเจ็กต์นี้บน GitHub หรือที่เก็บ Git ระยะไกล ตรวจสอบให้แน่ใจว่าไม่ได้รวมคีย์ส่วนตัว คุณสามารถเพิ่ม flow.json ใน .gitignore แม้ว่าเราจะใช้เฉพาะโปรแกรมจำลองในเครื่อง แต่ก็เป็นแนวทางปฏิบัติที่ดีในการปกป้องคีย์ของคุณ
ตอนนี้เราได้อัปเดตแล้ว เราสามารถส่งธุรกรรมได้ การทำเช่นนี้ทำได้ง่ายเพียงแค่เรียกใช้คำสั่งต่อไปนี้:
flow transactions send --code ./transactions/MintPinataParty.cdc --signer emulator-account
เราอ้างอิงไฟล์ธุรกรรมและบัญชีผู้ลงนามที่เราเขียนจาก flow.json หากทุกอย่างเป็นไปด้วยดี คุณจะเห็นผลลัพธ์ที่คล้ายกับต่อไปนี้:
Getting information for account with address 0xf8d6e0586b0a20c7 ...
Submitting transaction with ID
4a79102747a450f65b6aab06a77161af196c3f7151b2400b3b3d09ade3b69823 ...
Successfully submitted transaction with ID
4a79102747a450f65b6aab06a77161af196c3f7151b2400b3b3d09ade3b69823
ตอนนี้ สิ่งสุดท้ายที่เราต้องทำคือยืนยันว่าโทเค็นอยู่ในบัญชีของเราและรับข้อมูลเมตา ในการทำเช่นนั้น เราจะเขียนสคริปต์ง่ายๆ และเรียกใช้จากบรรทัดคำสั่ง
ในรูทของโปรเจ็กต์ ให้สร้างโฟลเดอร์ใหม่ชื่อสคริปต์ สร้างไฟล์ชื่อ CheckTokenMetadata.cdc ข้างใน ในไฟล์นั้น ให้เพิ่มสิ่งต่อไปนี้:
import PinataPartyContract from 0xf8d6e0586b0a20c7pub fun main() : {String : String} {
let nftOwner = getAccount(0xf8d6e0586b0a20c7)
// log("NFT Owner")
let capability = nftOwner.getCapability<&{PinataPartyContract.NFTReceiver}>(/public/NFTReceiver)
let receiverRef = capability.borrow()
?? panic("Could not borrow the receiver reference")
return receiverRef.getMetadata(id: 1)}
สคริปต์นี้สามารถคิดในลักษณะที่คล้ายกับวิธีอ่านอย่างเดียวในสัญญาอัจฉริยะของ Ethereum พวกเขาฟรีเพียงส่งคืนข้อมูลจากสัญญา
ในสคริปต์ เรานำเข้าสัญญาจากที่อยู่ที่ใช้งาน จากนั้น เรากำหนดฟังก์ชันหลัก (นี่คือชื่อของฟังก์ชันที่จำเป็นในการเรียกใช้สคริปต์) ภายในฟังก์ชันนี้ เรากำหนดตัวแปรสามตัว:
nftOwner: นี่เป็นเพียงบัญชีที่เป็นเจ้าของ NFT เราสร้าง NFT จากบัญชีที่ใช้สัญญาด้วย ดังนั้นในตัวอย่างของเรา ที่อยู่ทั้งสองจึงเหมือนกัน ขึ้นอยู่กับการออกแบบสัญญาในอนาคต สิ่งนี้อาจไม่จริงเสมอไป
ความสามารถ: เราจำเป็นต้อง "ยืม" จากสัญญาที่ปรับใช้ โปรดจำไว้ว่าฟังก์ชันเหล่านี้มีการควบคุมการเข้าถึง ดังนั้นหากฟังก์ชันไม่พร้อมใช้งานสำหรับที่อยู่ที่พยายามยืม สคริปต์จะล้มเหลว เรากำลังยืมทรัพยากรจาก NFTReceiver
receiverRef: ตัวแปรนี้แค่ยกระดับความสามารถของเราและบอกให้สคริปต์ยืมจากสัญญาที่ปรับใช้
ตอนนี้ เราสามารถเรียกใช้ฟังก์ชัน (ฟังก์ชันที่ใช้ได้) ในกรณีนี้ เราต้องการให้แน่ใจว่าที่อยู่ดังกล่าวได้รับ NFT ที่เราสร้างขึ้นจริง จากนั้นเราต้องการดูข้อมูลเมตาที่เกี่ยวข้องกับโทเค็น
ลองเรียกใช้สคริปต์ของเราและดูว่าเราได้อะไร เรียกใช้คำสั่งต่อไปนี้บนบรรทัดคำสั่ง:
flow scripts execute --code ./scripts/CheckTokenMetadata.cdc
สำหรับเอาต์พุตข้อมูลเมตา คุณควรเห็นเอาต์พุตที่คล้ายกับต่อไปนี้:
{"name": "The Big Swing", "swing_velocity": "29", "swing_angle": "45", "rating": "5", "uri": "ipfs://QmRZdc3mAMXpv6Akz9Ekp1y4vDSjazTx2dCQRkxVy1yUj6"}
ยินดีด้วย! คุณสร้าง Flow smart contract สำเร็จ สร้างโทเค็นและข้อมูลเมตาที่เกี่ยวข้องกับโทเค็นนั้น และจัดเก็บสินทรัพย์ดิจิทัลของโทเค็นบน IPFS ไม่เลวสำหรับส่วนแรกของบทช่วยสอน
IOS
Android