Beispiele dafür, wie wir einen Vertrag erstellen, Token prägen, eine App erstellen, um über diesen Vertrag generierte NFTs anzuzeigen, und einen Marktplatz erstellen, um NFTs an andere Benutzer zu übertragen. Beginnen wir mit der Vertragserstellung und dem Token-Minting.
Einrichtungstool
Installieren Sie Flow CLI auf Ihrem System. Je nach Betriebssystem gibt es unterschiedliche Befehle zur Installation des CLI.
Um beispielsweise Flow CLI unter macOS zu installieren, verwenden Sie den folgenden Befehl:
brew install flow-cli
Unter Windows: iex "& { $ ( irm 'https://storage.googleapis.com/flow-cli/install.ps1 ') }"
unter Linux: sh -ci "$ ( curl -fsSL https://storage.googleapis.com/flow-cli/install.sh )"
Asset-Dateien werden auf IPFS gespeichert. In diesem Beispiel verwenden wir Pinata zum Speichern der Dateien. Sie können sich hier für ein kostenloses Konto anmelden und einen API-Schlüssel erhalten. Es ist auch wichtig, dass NodeJS und ein Texteditor installiert sind, um den Smart-Contract-Code von Flow hervorzuheben.
Der zweite Schritt besteht darin, mit dem Befehl ein Verzeichnis für das Projekt zu erstellen: mkdir pinata-party Initialisieren Sie ein neues Prozessprojekt und ändern Sie es in dieses Verzeichnis: cd pinata-party
Lassen Sie uns nun mit dem im Code-Editor geöffneten Projekt an die Arbeit gehen. Erstellen Sie zunächst einen Ordner mit dem Namen cadence. Fügen Sie in diesem Ordner einen weiteren Ordner namens Contracts hinzu. Erstellen Sie abschließend eine Datei mit dem Namen PinataPartyContract.cdc im Vertragsordner.
Bevor wir fortfahren, lohnt es sich, auf alles hinzuweisen, was wir mit der Flow-Blockchain-Plattform gemacht haben. Richten Sie die Dateien für die Simulatorumgebung ein, und dann können wir mit dem Schreiben von Verträgen beginnen. Wir müssen das Vertragsobjekt in flow.json mit dem folgenden Code aktualisieren:
"contract": { "PinataPartyContract": "./cadence/contracts/PinataPartyContract.cdc" }
aktualisieren Sie das Bereitstellungsobjekt in dieser Datei mit dem folgenden Code: " deploy ": { "emulator": { "emulator account": [ "PinataPartyContract" ] } } Dadurch kann Flow CLI den Emulator verwenden, um unseren Vertrag bereitzustellen. Der Code verweist auch auf die Konten und Verträge, die wir schreiben werden.
Vertrag
Wir müssen den Vertrag zum Prägen der NFT erstellen, Metadaten mit der NFT verknüpfen und sicherstellen, dass die Metadaten auf das zugrunde liegende Asset verweisen, das auf IPFS gespeichert ist.
Öffnen Sie PinataPartyContract.cdc und führen Sie den folgenden Code aus:
pub contract PinataPartyContract { publish resource NFT { bar let id: UInt64 init(init id: UInt64) { self. id = initID }}}
Der erste Schritt besteht darin, den Vertrag zu definieren. Beginnen wir damit, einen PinataPartyContract zu definieren und darin eine Ressource zu erstellen. Ressourcen sind Elemente, die in Benutzerkonten gespeichert und über Zugriffskontrollen zugänglich sind. NFTs müssen identifizierbar sein, und das id-Attribut ermöglicht es Ihnen, das Token zu identifizieren.
Erstellen Sie dann eine Ressourcenschnittstelle, um zu definieren, welche Funktionalität anderen zur Verfügung steht.
Kneipenspaß getIDs () : [ UInt64 ] Kneipenspaß idExists ( id: UInt64 ) : Bool Kneipenspaß getMetadata ( id: UInt64 ) : { String : String } }
Setzen Sie den obigen Code unter den NFT-Ressourcencode. Die NFTReceiver-Ressourcenschnittstelle gibt an, dass Ressourcen die folgenden Methoden aufrufen können:
ID abrufen Identität vorhanden Hinterlegen Metadaten abrufen
Dann müssen wir die Token-Sammelschnittstelle definieren. Stellen Sie es sich als eine Brieftasche vor, in der die NFTs aller Benutzer gespeichert sind.
Ressourcensammlung veröffentlichen: NFTReceiver { pub varownedNFTs: @ { UInt64: NFT } pub var metadataObjs: { UInt64: { String : String }} init() { self. Eigenes NFT <- {} selbst. metadata object = {} } Bar Spaß zurückziehen (ID zurückziehen: UInt64): @NFT { let token <- self. Im Besitz von NFT. entfernen (Schlüssel: Auszahlungs-ID)! return <-token } pub fun deposit ( token: @NFT, metadata: { String : String }) { self. Metadatenobjekt [Token. id] = Metadaten selbst. Eigene NFTs [Token. id] <-! token} pub fun idExists ( id: UInt64 ) : Bool { return self. Eigene NFTs [id]! = nil } post fun getIDs(): [ UInt64 ] { return self. Im Besitz von NFT. key} pub fun updateMetadata (id: UInt64, metadata: {String: String}) {self. metadataObjs [ id ] = metadata} Kneipenspaß getMetadata ( id: UInt64 ) : { String : String } { return self. Metadatenobjekt[id]! } Destroy() { Zerstöre dich selbst. Eigenes NFT }}
Die Variable ownNFTs verfolgt alle NFTs, die ein Benutzer von Kontakten besitzen kann. Eine Variable namens metadataObjs ist einzigartig, da wir die Flow-NFT-Vertragsfunktionalität erweitern, um Metadatenzuordnungen für jede NFT zu speichern. Es ordnet die Token-ID den zugehörigen Metadaten zu, was bedeutet, dass die Token-ID erforderlich ist, bevor wir sie festlegen können. Variablen werden initialisiert, um sie in Ressourcen in Flow zu definieren.
Schließlich werden wir alle Funktionen haben, die für NFT-Erfassungsressourcen verfügbar sind. So wie der Standard-NFT-Vertrag um eine metadataObjs-Zuordnung erweitert wird, erweitern wir die Standard-Einzahlungsfunktion um einen zusätzlichen Metadatenparameter. Dies geschieht, um sicherzustellen, dass nur der Token-Minter dem Token Metadaten hinzufügen kann. Wir beschränken die ursprünglich hinzugefügten Metadaten auf die Minting-Ausführung, um sie privat zu halten. Fügen Sie den folgenden Code unter der Collection-Ressource hinzu:
Pub-Spaß createEmptyCollection() : @Collection { return <- createCollection() } publish resource NFTMinter { pub var idCount: UInt64 init() { self. idCount = 1 } bar fun mintNFT() : @NFT { var newNFT <- NFT( initID: self.idCount ) selbst erstellen. idCount = selbst. idCount + 1 gibt als UInt64 <- newNFT }} zurück
Zuerst haben wir eine Funktion, die beim Aufruf eine leere NFT-Sammlung erstellt. Benutzer, die mit dem Vertrag interagieren, haben einen Speicherort für die von der Karte definierte Sammlungsressource. Wir werden später eine weitere Ressource erstellen. Ohne sie können wir keine Token prägen. NFTMinter enthält einen idCount, der jedes Mal erhöht wird, um sicherzustellen, dass wir keine doppelten IDs für NFTs haben. Es enthält auch Funktionen zum Erstellen von NFTs. Fügen Sie den Hauptvertragsinitialisierer unterhalb der NFTMinter-Ressource hinzu:
init() {selbst. Konto. save(<-self.createEmptyCollection(), also: /storage/NFTCollection) self. Konto. Verknüpfen Sie < & { NFTReceiver }> ( /public/NFTReceiver,target:/storage/NFTCollection ) mit sich selbst. Konto. save(<- create NFTMinter(), also: /storage/NFTMinter) }
Die Initialisierungsfunktion wird nur aufgerufen, wenn der Vertrag bereitgestellt wird. Es macht drei Dinge:
Erstellen Sie eine leere Sammlung für den Sammlungsbereitsteller, damit der Eigentümervertrag NFTs aus dem Vertrag erstellen und besitzen kann.
NFTMinter-Ressourcen werden im Kontospeicher des Vertragserstellers gespeichert. Das bedeutet, dass nur der Vertragsersteller Token prägen kann.
Die zu Beginn der Sammlungsressourcenreferenz erstellte NFTReceiver-Schnittstelle wird an einem öffentlichen Speicherort veröffentlicht. So teilen wir dem Vertrag mit, dass jeder die auf dem NFTReceiver definierten Funktionen aufrufen kann. Sobald wir unseren Vertrag fertig haben, stellen wir ihn bereit.
Vor der Bereitstellung:
- Testen Sie es auf dem Flow Playground.
- Gehen Sie zu Flow Playground und klicken Sie auf das erste Konto in der linken Seitenleiste.
- Ersetzen Sie den gesamten Code durch den Vertragscode und klicken Sie auf Bereitstellen.
Wenn alles gut geht, sollten Sie das Protokoll unten auf dem Bildschirm sehen: 16:48:55 Bereitstellen Vertrag bereitstellen an: 0x01 Jetzt ist es an der Zeit, den Vertrag für den lokal ausgeführten Emulator bereitzustellen. Führen Sie den folgenden Befehl aus: process project start emulator Führen Sie den Emulator aus. Nach dem Konfigurieren der flow.json-Datei können Sie den Vertrag mit dem folgenden Befehl bereitstellen: Bereitstellung des Flow-Projekts
Nun wenden wir uns der Prägung von NFTs zu.