So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 1)

In diesem Tutorial lernen wir, wie man eine Website zum Sammeln digitaler Sammlerstücke (oder NFTs) auf der Blockchain Flow erstellt. Um dies zu ermöglichen, verwenden wir die intelligente Vertragssprache Cadence zusammen mit React. Außerdem erfahren wir mehr über Flow, seine Vorteile und die unterhaltsamen Tools, die wir verwenden können. Am Ende dieses Artikels verfügen Sie über die Tools und Kenntnisse, die Sie zum Erstellen Ihrer eigenen dezentralen Anwendung auf der Flow-Blockchain benötigen. Lasst uns gleich eintauchen! Was bauen wir? Wir entwickeln eine Anwendung für digitale Sammlerstücke. Jedes Sammlerstück ist ein Non-Fungible Token (NFT). Mit unserer App können Sie NFTs sammeln, und jeder Artikel ist einzigartig. (Wenn Sie neu sind und NFT nicht verstehen, dann schauen Sie hier.) Damit das alles funktioniert, verwenden wir den NonFungibleToken-Standard von Flow, einen Regelsatz, der uns bei der Verwaltung dieser besonderen digitalen Gegenstände hilft (ähnlich ERC-721 in Ethereum). Voraussetzungen Bevor Sie beginnen, stellen Sie sicher, dass Sie die Flow CLI auf Ihrem System installieren. Wenn Sie dies noch nicht getan haben, befolgen Sie diese . Installationsanweisungen Einrichten Wenn Sie bereit sind, Ihr Projekt zu starten, geben Sie zunächst das Befehlsfluss-Setup ein. Dieser Befehl wirkt hinter den Kulissen zauberhaft, um die Grundlage für Ihr Projekt zu schaffen. Es erstellt ein Ordnersystem und richtet eine Datei namens flow.json ein, um Ihr Projekt zu konfigurieren und sicherzustellen, dass alles organisiert und einsatzbereit ist! Projektstruktur Das Projekt enthält einen Ordner und Datei. (Eine flow.json-Datei ist eine Konfigurationsdatei für Ihr Projekt, die automatisch verwaltet wird.) Der Cadence-Ordner enthält Folgendes: cadence flow.json /contracts: Enthält alle Cadence-Verträge. /scripts: Enthält alle Cadence-Skripte. /transactions: Speichert alle Cadence-Transaktionen. Befolgen Sie die folgenden Schritte, um Flow NFT Standard zu verwenden. Schritt 1: Erstellen Sie eine Datei. Gehen Sie zunächst zum Ordner und suchen Sie den Ordner . Öffnen Sie dann den . Erstellen Sie eine neue Datei und nennen Sie sie . flow-collectibles-portal cadence contracts NonFungibleToken.cdc Schritt 2: Kopieren und Einfügen. Öffnen Sie nun den Link , der den NFT-Standard enthält. Kopieren Sie den gesamten Inhalt aus dieser Datei und fügen Sie ihn in die neue Datei ein, die Sie gerade erstellt haben („NonFungibleToken.cdc“). NonFungibleToken Das ist es! Sie haben die Standards für Ihr Projekt erfolgreich eingerichtet. Jetzt schreiben wir etwas Code! Bevor wir uns jedoch mit dem Codieren befassen, ist es für Entwickler wichtig, ein mentales Modell für die Strukturierung ihres Codes zu entwickeln. Auf der obersten Ebene besteht unsere Codebasis aus drei Hauptkomponenten: NFT: Jedes Sammlerstück wird als NFT dargestellt. Sammlung: Eine Sammlung bezieht sich auf eine Gruppe von NFTs, die einem bestimmten Benutzer gehören. Globale Funktionen und Variablen: Dies sind Funktionen und Variablen, die auf globaler Ebene für den Smart Contract definiert werden und keiner bestimmten Ressource zugeordnet sind. Intelligente Vertragsstruktur Grundstruktur von Smart Contracts Erstellen Sie eine neue Datei mit dem Namen in . Hier werden wir den Code schreiben. Collectibles.cdc cadence/contracts Vertragsstruktur import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 // other code will come here init(){ self.totalSupply = 0 } } Lassen Sie uns den Code Zeile für Zeile aufschlüsseln: Zuerst müssen wir standardisieren, dass wir einen NFT erstellen, indem wir das sogenannte „NonFungibleToken“ einbeziehen. Dabei handelt es sich um einen von Flow entwickelten NFT-Standard, der die folgenden Funktionen definiert, die in jedem NFT-Smart-Vertrag enthalten sein müssen. Nach dem Import erstellen wir unseren Vertrag. Dazu verwenden wir . Verwenden Sie jedes Mal dieselbe Syntax, wenn Sie einen neuen Vertrag erstellen. Sie können den mit dem von Ihnen gewünschten Namen für Ihren Vertrag angeben. In unserem Fall nennen wir es . pub contract [contract name] contract name Collectibles Als Nächstes möchten wir sicherstellen, dass unser Vertrag bestimmte Funktionen und Regeln von NonFungibleToken einhält. Dazu fügen wir mit Hilfe von „:“ eine NonFungibleToken-Schnittstelle hinzu. So ( ) `pub contract Collectibles: NonFungibleToken{}` Jeder einzelne Vertrag über die Funktion verfügen. Es wird aufgerufen, wenn der Vertrag zum ersten Mal bereitgestellt wird. Dies ähnelt dem, was Solidity als Konstruktor bezeichnet. MUSS init() Erstellen wir nun eine globale Variable namens mit einem Datentyp . Diese Variable verfolgt Ihre gesamten Sammlerstücke. totalSupply UInt64 Initialisieren Sie nun mit dem Wert . totalSupply 0 Das ist es! Wir legen den Grundstein für unseren . Jetzt können wir damit beginnen, weitere Features und Funktionalitäten hinzuzufügen, um es noch spannender zu machen. Collectibles Bevor Sie fortfahren, schauen Sie sich bitte das Code-Snippet an, um zu verstehen, wie wir Variablen in Cadence definieren: Ressourcen-NFT Fügen Sie Ihrem Smart-Vertrag den folgenden Code hinzu: import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ // above code… pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } // init()... } Wie Sie bereits gesehen haben, implementiert der Vertrag die NFT-Standardschnittstelle, dargestellt durch . Ebenso können Ressourcen auch verschiedene Ressourcenschnittstellen implementieren. pub contract Collectibles: NonFungibleToken Fügen wir also der NFT-Ressource die Schnittstelle hinzu, die die Existenz einer öffentlichen Eigenschaft namens id innerhalb der Ressource vorschreibt. Hier sind die Variablen, die wir in der NFT-Ressource verwenden werden: NonFungibleToken.INFT Behält die ID von NFT bei id: Name des NFT. name: Bild-URL von NFT. image: Stellen Sie nach dem Definieren der Variablen sicher, dass Sie die Variable in der Funktion initialisieren. init() Machen wir weiter und erstellen eine weitere Ressource namens . Collection Resource Sammlungsressource Zunächst müssen Sie verstehen, wie funktionieren. Collection Resources Was würden Sie tun, wenn Sie eine Musikdatei und mehrere Fotos auf Ihrem Laptop speichern müssten? Normalerweise navigieren Sie zu einem lokalen Laufwerk (z. B. Ihrem D-Drive) und erstellen einen und . Anschließend kopieren Sie die Musik- und Fotodateien und fügen sie in Ihre Zielordner ein. Genauso funktionieren auch Ihre digitalen Sammlerstücke auf Flow. music photos Stellen Sie sich Ihren Laptop als , Ihr D-Laufwerk als und den Ordner als vor. Flow Blockchain Account Account Storage Collection Wenn Sie also mit einem Projekt zum Kauf von NFTs interagieren, erstellt das Projekt seine in Ihrem , ähnlich wie beim Erstellen eines Ordners auf Ihrem D-Drive. Wenn Sie mit 10 verschiedenen NFT-Projekten interagieren, erhalten Sie 10 verschiedene Sammlungen in Ihrem Konto. collection account storage Es ist, als hätten Sie einen persönlichen Raum zum Aufbewahren und Organisieren Ihrer einzigartigen digitalen Schätze! import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ //Above code NFT Resource… // Collection Resource pub resource Collection{ } // Below code… } Jede verfügt über eine Variable zum Speichern der . collection ownedNFTs NFT Resources pub resource Collection { pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } } Ressourcenschnittstellen Eine in Flow ähnelt Schnittstellen in anderen Programmiersprachen. Es sitzt über einer Ressource und stellt sicher, dass die Ressource, die es implementiert, über die erforderliche Funktionalität verfügt, wie durch die Schnittstelle definiert. resource Es kann auch verwendet werden, um den Zugriff auf die gesamte Ressource einzuschränken und hinsichtlich der Zugriffsmodifikatoren restriktiver zu sein als die Ressource selbst. Im Standard gibt es mehrere Ressourcenschnittstellen wie , , und . NonFungibleToken INFT Provider Receiver CollectionPublic Jede dieser Schnittstellen verfügt über spezifische Funktionen und Felder, die von der Ressource, die sie verwendet, implementiert werden müssen. In diesem Vertrag verwenden wir diese drei Schnittstellen von , und . Diese Schnittstellen definieren Funktionen wie , , und . Wir werden diese im weiteren Verlauf im Detail erklären. NonFungibleToken: Provider Receiver CollectionPublic deposit withdraw borrowNFT getIDs Wir werden auch einige Ereignisse hinzufügen, die wir von diesen Funktionen ausgeben, und einige Variablen deklarieren, die wir im weiteren Verlauf des Tutorials verwenden werden. pub contract Collectibles:NonFungibleToken{ // rest of the code… pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } } } Zurückziehen Erstellen wir nun die für die Schnittstelle erforderliche Funktion . withdraw() pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } init()... } Mit Hilfe dieser Funktion können Sie die NFT-Ressource aus der Sammlung verschieben. Wenn es: : Panik und löst einen Fehler aus. Schlägt fehl : Es wird ein Rückzugsereignis ausgegeben und die Ressource an den Aufrufer zurückgegeben. Erfolgreich Der Anrufer kann diese Ressource dann nutzen und in seinem Kontospeicher speichern. Kaution Jetzt ist es Zeit für die von benötigte Funktion . NonFungibleToken.Receiver deposit() pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } init()... } Ausleihen und GetID Konzentrieren wir uns nun auf die beiden von und . NonFungibleToken.CollectionPublic: borrowNFT() getID() pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ // other code pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } init()... } Zerstörer Das Letzte, was wir für die Sammlungsressource benötigen, ist ein Destruktor. destroy (){ destroy self.ownedNFTs } Da die Collection-Ressource andere Ressourcen (NFT-Ressourcen) enthält, müssen wir einen Destruktor angeben. Ein Destruktor wird ausgeführt, wenn das Objekt zerstört wird. Dadurch wird sichergestellt, dass Ressourcen nicht „obdachlos“ bleiben, wenn ihre übergeordnete Ressource zerstört wird. Wir benötigen keinen Destruktor für die NFT-Ressource, da diese keine anderen Ressourcen enthält. Schauen wir uns den vollständigen Quellcode der Sammlungsressource an: import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 pub resource NFT: NonFungibleToken.INFT{ pub let id: UInt64 pub var name: String pub var image: String init(_id:UInt64, _name:String, _image:String){ self.id = _id self.name = _name self.image = _image } } pub resource interface CollectionPublic{ pub fun deposit(token: @NonFungibleToken.NFT) pub fun getIDs(): [UInt64] pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT } pub event ContractInitialized() pub event Withdraw(id: UInt64, from: Address?) pub event Deposit(id: UInt64, to: Address?) pub let CollectionStoragePath: StoragePath pub let CollectionPublicPath: PublicPath pub resource Collection: CollectionPublic, NonFungibleToken.Provider, NonFungibleToken.Receiver, NonFungibleToken.CollectionPublic{ pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } destroy (){ destroy self.ownedNFTs } pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT { let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT") emit Withdraw(id: token.id, from: self.owner?.address) return <- token } pub fun deposit(token: @NonFungibleToken.NFT) { let id = token.id let oldToken <- self.ownedNFTs[id] <-token destroy oldToken emit Deposit(id: id, to: self.owner?.address) } pub fun borrowNFT(id: UInt64): &NonFungibleToken.NFT { if self.ownedNFTs[id] != nil { return (&self.ownedNFTs[id] as &NonFungibleToken.NFT?)! } panic("NFT not found in collection.") } pub fun getIDs(): [UInt64]{ return self.ownedNFTs.keys } } init(){ self.CollectionPublicPath = /public/NFTCollection self.CollectionStoragePath = /storage/NFTCollection self.totalSupply = 0 emit ContractInitialized() } } Jetzt haben wir alle Ressourcen aufgebraucht. Als nächstes schauen wir uns die globale Funktion an. Globale Funktion Globale Funktionen sind Funktionen, die auf der globalen Ebene des Smart Contracts definiert sind, d. h. sie sind nicht Teil einer Ressource. Diese sind für die Öffentlichkeit zugänglich und abrufbar und stellen der Öffentlichkeit die Kernfunktionalität des Smart Contracts zur Verfügung. : Diese Funktion initialisiert eine leere im Anruferkontospeicher. createEmptyCollection Collectibles.Collection : Mit dieser praktischen Funktion können Sie herausfinden, ob Ihr Konto bereits über eine verfügt. checkCollection collection : Diese Funktion ist super cool, weil sie es jedem ermöglicht, ein NFT zu erstellen. mintNFT // pub resource Collection… pub fun createEmptyCollection(): @Collection{ return (Collectibles.CollectionPublicPath)! .check() } pub fun mintNFT(name:String, image:String): @NFT{ Collectibles.totalSupply = Collectibles.totalSupply + 1 let nftId = Collectibles.totalSupply var newNFT <- create NFT(_id:nftId, _name:name, _image:image) return <- newNFT } init()... Zusammenfassung des Smart Contracts Und jetzt, ENDLICH, da alles vorbereitet ist, sind wir mit dem Schreiben unseres Smart Contracts fertig. Schauen Sie sich den endgültigen Code an. hier Schauen wir uns nun an, wie ein Benutzer mit intelligenten Verträgen interagiert, die auf der Flow-Blockchain bereitgestellt werden. Die Interaktion mit der Flow-Blockchain erfolgt in zwei Schritten: Ändern Sie den Status, indem Sie Transaktionen ausführen. Fragen Sie die Blockchain ab, indem Sie ein Skript ausführen. Ändern Sie den Status, indem Sie Transaktionen ausführen Transaktionen sind kryptografisch signierte Daten, die eine Reihe von Anweisungen enthalten, die mit dem Smart Contract interagieren, um den Flow-Status zu aktualisieren. Vereinfacht ausgedrückt ist dies wie ein Funktionsaufruf, der die Daten auf der Blockchain ändert. Transaktionen sind in der Regel mit gewissen Kosten verbunden, die je nach Blockchain, auf der Sie sich befinden, variieren können. Eine Transaktion umfasst mehrere optionale Phasen: , , und . prepare pre execute post . Jede Phase hat einen Zweck; Die beiden wichtigsten Phasen sind und . Weitere Informationen hierzu finden Sie im Cadence-Referenzdokument zu Transaktionen prepare execute : Diese Phase wird verwendet, um auf Daten und Informationen im Konto des Unterzeichners zuzugreifen (durch den AuthAccount-Typ zulässig). Prepare Phase : In dieser Phase werden Aktionen ausgeführt. Execute Phase Lassen Sie uns nun eine Transaktion für unser Projekt erstellen. Führen Sie die folgenden Schritte aus, um eine Transaktion in Ihrem Projektordner zu erstellen. Schritt 1: Erstellen Sie eine Datei. Gehen Sie zunächst in den Projektordner und öffnen Sie den Ordner. Öffnen Sie darin den und erstellen Sie eine neue Datei mit den Namen und cadence transaction Create_Collection.cdc mint_nft.cdc Schritt 2: Fügen Sie den Transaktionscode „Sammlung erstellen“ hinzu. import Collectibles from "../contracts/Collectibles.cdc" transaction { prepare(signer: AuthAccount) { if signer.borrow (from: Collectibles.CollectionStoragePath) == nil { let collection (Collectibles.CollectionStoragePath) signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath) } } } Lassen Sie uns diesen Code Zeile für Zeile aufschlüsseln: Diese Transaktion interagiert mit dem Smart-Vertrag Collectibles. Anschließend prüft es, ob der Absender (Unterzeichner) eine Collection-Ressource in seinem Konto gespeichert hat, indem es einen Verweis auf die Collection-Ressource aus dem angegebenen Speicherpfad entlehnt. Wenn die Referenz Null ist, bedeutet dies, dass der Unterzeichner noch keine Sammlung hat. Collectibles.CollectionStoragePath Wenn der Unterzeichner keine Sammlung hat, erstellt er eine leere Sammlung, indem er die Funktion aufruft. createEmptyCollection() Nachdem Sie die leere Sammlung erstellt haben, platzieren Sie sie im Konto des Unterzeichners unter dem angegebenen Speicherpfad . Collectibles.CollectionStoragePath Dadurch wird mithilfe von eine Verknüpfung zwischen dem Konto des Unterzeichners und der neu erstellten Sammlung hergestellt. link() Schritt 3: Fügen Sie den Mint NFT-Transaktionscode hinzu. import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" transaction(name:String, image:String){ let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} prepare(signer:AuthAccount){ self.receiverCollectionRef = signer.borrow (from: Collectibles.CollectionStoragePath) ?? panic("could not borrow Collection reference") } execute{ let nft <- Collectibles.mintNFT(name:name, image:image) self.receiverCollectionRef.deposit(token: <-nft) } } Lassen Sie uns diesen Code Zeile für Zeile aufschlüsseln: Wir importieren zunächst den und . NonFungibleToken Collectibles contract Diese Zeile definiert eine neue Transaktion. Es benötigt zwei Argumente, name und image, beide vom Typ String. Diese Argumente werden verwendet, um den Namen und das Bild des zu prägenden NFT zu übergeben. transaction(name: String, image: String) Diese Zeile deklariert eine neue Variable Es handelt sich um einen Verweis auf eine öffentliche Sammlung von NFTs vom Typ . Diese Referenz wird verwendet, um mit der Sammlung zu interagieren, in der wir den neu geprägten NFT hinterlegen. let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} receiverCollectionRef. NonFungibleToken.CollectionPublic Diese Zeile startet den Prepare-Block, der vor der Transaktion ausgeführt wird. Es benötigt einen Argumentunterzeichner vom Typ . stellt das Konto des Unterzeichners der Transaktion dar. prepare(signer: AuthAccount) AuthAccount AuthAccount Es entlehnt einen Verweis auf die aus dem Speicher des Unterzeichners im Prepare-Block. Mithilfe der Funktion „borgen“ greift es auf den Verweis auf die Sammlung zu und speichert ihn in der Variablen . Collectibles.Collection receiverCollectionRef Wenn die Referenz nicht gefunden wird (z. B. wenn die Sammlung nicht im Speicher des Unterzeichners vorhanden ist), wird die Fehlermeldung „Sammlungsreferenz konnte nicht ausgeliehen werden“ ausgegeben. Der enthält die Hauptausführungslogik für die Transaktion. Der Code in diesem Block wird ausgeführt, nachdem der erfolgreich abgeschlossen wurde. execute prepare Innerhalb des ruft diese Zeile die Funktion aus dem Vertrag mit den bereitgestellten Namens- und Bildargumenten auf. Von dieser Funktion wird erwartet, dass sie ein neues NFT mit dem angegebenen Namen und Bild erstellt. Das -Symbol zeigt an, dass der NFT als verschiebbares Objekt (Ressource) empfangen wird. nft <- Collectibles.mintNFT(_name: name, image: image) execute mintNFT Collectibles <- Diese Zeile hinterlegt den neu geprägten NFT in der angegebenen Sammlung. Es verwendet die Einzahlungsfunktion auf der , um das Eigentum an der NFT vom ausführenden Konto der Transaktion auf die Sammlung zu übertragen. Das -Symbol weist hier auch darauf hin, dass der NFT während des als Ressource verschoben wird. self.receiverCollectionRef.deposit(token: <-nft) receiverCollectionRef <- deposit Fragen Sie die Blockchain ab, indem Sie ein Skript ausführen Wir verwenden ein Skript, um Daten aus der Blockchain anzuzeigen oder zu lesen. Skripte sind kostenlos und müssen nicht signiert werden. Führen Sie die folgenden Schritte aus, um ein Skript in Ihrem Projektordner zu erstellen. Schritt 1: Erstellen Sie eine Datei. Gehen Sie zunächst in den Projektordner und öffnen Sie den Ordner. Öffnen Sie darin den und erstellen Sie eine neue Datei mit dem Namen . cadence script view_nft.cdc Schritt 2: Sehen Sie sich das NFT-Skript an import NonFungibleToken from "../contracts/NonFungibleToken.cdc" import Collectibles from "../contracts/Collectibles.cdc" pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? { let collectionCap= getAccount(user).capabilities .get (/public/NFTCollection) ?? panic("This public capability does not exist.") let collectionRef = collectionCap.borrow()! return collectionRef.borrowNFT(id: id) } Lassen Sie uns diesen Code Zeile für Zeile aufschlüsseln: Zuerst importieren wir den und -Vertrag. NonFungibleToken Collectibles Diese Zeile definiert den Einstiegspunkt des Skripts, bei dem es sich um eine öffentliche Funktion namens main handelt. Die Funktion benötigt zwei Parameter: pub fun main(acctAddress: Address, id: UInt64): &NonFungibleToken.NFT? : Ein Parameter vom Typ , der die Adresse eines Kontos in der Flow-Blockchain darstellt. acctAddress Address : Ein Parameter vom Typ , der die eindeutige Kennung des NFT innerhalb der Sammlung darstellt. id UInt64 Dann verwenden wir , um die Funktion für die angegebene abzurufen. Eine Fähigkeit ist ein Verweis auf eine Ressource, die den Zugriff auf ihre Funktionen und Daten ermöglicht. In diesem Fall wird die Funktion für den Ressourcentyp abgerufen. getCapability Collectibles.Collection acctAddress Collectibles.Collection Anschließend leihen wir mithilfe der Funktion ein NFT aus der aus. Die Funktion verwendet den Parameter , der die eindeutige Kennung des NFT innerhalb der Sammlung darstellt. Die Funktion einer Fähigkeit ermöglicht das Lesen der Ressourcendaten. borrowNFT collectionRef borrowNFT id borrow Schließlich geben wir die NFT von der Funktion zurück. Schritt 3: Testnet-Bereitstellung Jetzt ist es an der Zeit, unseren Smart Contract im Flow-Testnetz bereitzustellen. 1. Richten Sie ein Flow-Konto ein. Führen Sie den folgenden Befehl im Terminal aus, um ein Flow-Konto zu generieren: flow keys generate Notieren Sie sich unbedingt Ihren öffentlichen und privaten Schlüssel. Als nächstes machen wir uns auf den Weg zu , erstellen Sie eine neue Adresse basierend auf unseren Schlüsseln und füllen Sie unser Konto mit einigen Testtokens auf. Führen Sie die folgenden Schritte aus, um Ihr Konto zu erstellen: der Durchflusshahn Fügen Sie Ihren öffentlichen Schlüssel in das angegebene Eingabefeld ein. Behalten Sie die Standardeinstellungen für die Signatur- und Hash-Algorithmen bei. Füllen Sie das Captcha aus. Klicken Sie auf Konto erstellen. Nach dem Einrichten eines Kontos erhalten wir einen Dialog mit unserer neuen Flow-Adresse, der 1.000 Test-Flow-Token enthält. . Kopieren Sie die Adresse, damit wir sie künftig verwenden können 2. Konfigurieren Sie das Projekt. Jetzt konfigurieren wir unser Projekt. Als wir das Projekt einrichteten, wurde zunächst eine Datei erstellt. flow.json Dies ist die Konfigurationsdatei für die Flow CLI und definiert die Konfiguration für Aktionen, die die Flow CLI für Sie ausführen kann. Stellen Sie sich dies als ungefähr gleichbedeutend mit auf Ethereum vor. hardhat.config.js Öffnen Sie nun Ihren Code-Editor, kopieren Sie den folgenden Code und fügen Sie ihn in Ihre Datei ein. flow.json { "contracts": { "Collectibles": "./cadence/contracts/Collectibles.cdc", "NonFungibleToken": { "source": "./cadence/contracts/NonFungibleToken.cdc", "aliases": { "testnet": "0x631e88ae7f1d7c20" } } }, "networks": { "testnet": "access.devnet.nodes.onflow.org:9000" }, "accounts": { "testnet-account": { "address": "ENTER YOUR ADDRESS FROM FAUCET HERE", "key": "ENTER YOUR GENERATED PRIVATE KEY HERE" } }, "deployments": { "testnet": { "testnet-account": [ "Collectibles" ] } } } Kopieren und Einfügen. Fügen Sie Ihren generierten privaten Schlüssel an der Stelle (Schlüssel: „GEBEN SIE IHREN GENERIERTEN PRIVATEN SCHLÜSSEL HIER EIN“) im Code ein. Ausführen. Führen Sie nun den Code im Testnetz aus. Gehen Sie zum Terminal und führen Sie den folgenden Code aus: flow project deploy --network testnet 5. Warten Sie auf die Bestätigung. Nach dem Absenden der Transaktion erhalten Sie eine Transaktions-ID. Warten Sie, bis die Transaktion im Testnetz bestätigt wird, was anzeigt, dass der Smart Contract erfolgreich bereitgestellt wurde. Überprüfen Sie Ihren bereitgestellten Vertrag. hier Überprüfen Sie den vollständigen Code auf . GitHub Abschließende Gedanken und Glückwünsche! Glückwunsch! Sie haben jetzt ein Sammlerportal auf der Flow-Blockchain erstellt und es im Testnetz bereitgestellt. Was kommt als nächstes? Jetzt können Sie an der Erstellung des Frontends arbeiten, das wir in Teil 2 dieser Serie behandeln werden. Ich wünsche Ihnen einen wirklich tollen Tag! Auch veröffentlicht hier