Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 1)

Dans ce tutoriel, nous allons apprendre à créer un site Web pour collecter des objets de collection numériques (ou NFT) sur la blockchain Flow. Nous utiliserons le langage de contrat intelligent Cadence avec React pour que tout cela se réalise. Nous découvrirons également Flow, ses avantages et les outils amusants que nous pouvons utiliser. À la fin de cet article, vous disposerez des outils et des connaissances dont vous avez besoin pour créer votre propre application décentralisée sur la blockchain Flow. Allons-y ! Que construisons-nous ? Nous construisons une application pour les objets de collection numériques. Chaque objet de collection est un jeton non fongible (NFT). Notre application vous permettra de collecter des NFT, et chaque élément sera unique par rapport aux autres. (Si vous êtes nouveau et ne comprenez pas NFT, jetez un œil ici.) Pour que tout cela fonctionne, nous utiliserons la norme NonFungibleToken de Flow, qui est un ensemble de règles qui nous aident à gérer ces éléments numériques spéciaux (similaires à l'ERC-721 dans Ethereum). Conditions préalables Avant de commencer, assurez-vous d'installer Flow CLI sur votre système. Si vous ne l'avez pas fait, suivez ces . instructions d'installation Configuration Si vous êtes prêt à démarrer votre projet, saisissez d'abord la configuration du flux de commandes. Cette commande fait de la magie en coulisse pour établir les bases de votre projet. Il crée un système de dossiers et configure un fichier appelé flow.json pour configurer votre projet, en s'assurant que tout est organisé et prêt à fonctionner ! Structure du projet Le projet contiendra un dossier et un fichier . (Un fichier flow.json est un fichier de configuration pour votre projet, automatiquement maintenu.) Le dossier Cadence contient les éléments suivants : cadence flow.json /contracts : contient tous les contrats Cadence. /scripts : contient tous les scripts Cadence. /transactions : stocke toutes les transactions Cadence. Suivez les étapes ci-dessous pour utiliser Flow NFT Standard. Étape 1 : Créez un fichier. Tout d’abord, accédez au dossier et recherchez le dossier . Ensuite, ouvrez le dossier . Créez un nouveau fichier et nommez-le . flow-collectibles-portal cadence contracts NonFungibleToken.cdc Étape 2 : copier et coller. Maintenant, ouvrez le lien nommé qui contient le standard NFT. Copiez tout le contenu de ce fichier et collez-le dans le nouveau fichier que vous venez de créer (« NonFungibleToken.cdc »). NonFungibleToken C'est ça! Vous avez mis en place avec succès les normes de votre projet. Maintenant, écrivons du code ! Cependant, avant de nous lancer dans le codage, il est important que les développeurs établissent un modèle mental sur la manière de structurer leur code. Au niveau supérieur, notre base de code se compose de trois composants principaux : NFT : Chaque objet de collection est représenté comme un NFT. Collection : Une collection fait référence à un groupe de NFT appartenant à un utilisateur spécifique. Fonctions et variables globales : ce sont des fonctions et des variables définies au niveau global pour le contrat intelligent et ne sont associées à aucune ressource particulière. Structure de contrat intelligent Structure de base du contrat intelligent Créez un nouveau fichier nommé dans . C'est ici que nous écrirons le code. Collectibles.cdc cadence/contracts Structure du contrat import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ pub var totalSupply: UInt64 // other code will come here init(){ self.totalSupply = 0 } } Décomposons le code ligne par ligne : Tout d'abord, nous devrons standardiser le fait que nous construisons un NFT en incluant ce que l'on appelle le « NonFungibleToken ». Il s'agit d'une norme NFT construite par Flow qui définit l'ensemble de fonctionnalités suivant qui doit être inclus par chaque contrat intelligent NFT. Après l'importation, créons notre contrat. Pour ce faire, nous utilisons . Utilisez la même syntaxe chaque fois que vous créez un nouveau contrat. Vous pouvez remplir le avec le nom que vous souhaitez pour votre contrat. Dans notre cas, appelons-le . pub contract [contract name] contract name Collectibles Ensuite, nous voulons nous assurer que notre contrat suit un certain ensemble de fonctionnalités et de règles de NonFungibleToken. Pour ce faire, nous ajoutons une interface NonFungibleToken à l'aide de `:`. Comme ça ( ) `pub contract Collectibles: NonFungibleToken{}` Chaque contrat avoir la fonction . Il est appelé lors du déploiement initial du contrat. Ceci est similaire à ce que Solidity appelle un constructeur. DOIT init() Créons maintenant une variable globale appelée avec un type de données . Cette variable gardera une trace de votre total d’objets de collection. totalSupply UInt64 Maintenant, initialisez avec la valeur . totalSupply 0 C'est ça! Nous avons jeté les bases de notre contrat . Maintenant, nous pouvons commencer à ajouter plus de fonctionnalités pour le rendre encore plus excitant. Collectibles Avant de continuer, veuillez consulter l'extrait de code pour comprendre comment nous définissons les variables dans Cadence : Ressource NFT Ajoutez le code suivant à votre contrat intelligent : 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()... } Comme vous l'avez vu précédemment, le contrat implémente l'interface standard NFT, représentée par . De même, les ressources peuvent également implémenter diverses interfaces de ressources. pub contract Collectibles: NonFungibleToken Ajoutons donc l'interface à la ressource NFT, qui impose l'existence d'une propriété publique appelée id au sein de la ressource. Voici les variables que nous utiliserons dans la ressource NFT : NonFungibleToken.INFT conserve l’ID de NFT id: Nom du NFT. name: URL de l’image de NFT. image: Après avoir défini la variable, assurez-vous d'initialiser la variable dans la fonction . init() Allons de l'avant et créons une autre ressource appelée . Collection Resource Ressource de collecte Tout d’abord, vous devez comprendre le fonctionnement . Collection Resources Si vous aviez besoin de stocker un fichier musical et plusieurs photos sur votre ordinateur portable, que feriez-vous ? En règle générale, vous accédez à un lecteur local (disons votre D-Drive) et créez un dossier et un dossier . Vous copierez et collerez ensuite les fichiers de musique et de photo dans vos dossiers de destination. De même, c'est ainsi que fonctionnent vos objets de collection numériques sur Flow. music photos Imaginez votre ordinateur portable comme un , votre D-Drive comme et votre dossier comme . Flow Blockchain Account Account Storage Collection Ainsi, lorsque vous interagissez avec un projet pour acheter des NFT, le projet crée sa dans , de la même manière que vous créez un dossier sur votre D-Drive. Lorsque vous interagissez avec 10 projets NFT différents, vous vous retrouverez avec 10 collections différentes dans votre compte. collection account storage C'est comme avoir un espace personnel pour stocker et organiser vos trésors numériques uniques ! import NonFungibleToken from "./NonFungibleToken.cdc" pub contract Collectibles: NonFungibleToken{ //Above code NFT Resource… // Collection Resource pub resource Collection{ } // Below code… } Chaque possède une variable pour contenir les . collection ownedNFTs NFT Resources pub resource Collection { pub var ownedNFTs: @{UInt64: NonFungibleToken.NFT} init(){ self.ownedNFTs <- {} } } Interfaces de ressources Une interface dans Flow est similaire aux interfaces d’autres langages de programmation. Il se trouve au-dessus d'une ressource et garantit que la ressource qui l'implémente dispose des fonctionnalités requises telles que définies par l'interface. resource Il peut également être utilisé pour restreindre l'accès à l'ensemble de la ressource et être plus restrictif en termes de modificateurs d'accès que la ressource elle-même. Dans la norme , il existe plusieurs interfaces de ressources telles que , , et . NonFungibleToken INFT Provider Receiver CollectionPublic Chacune de ces interfaces possède des fonctions et des champs spécifiques qui doivent être implémentés par la ressource qui les utilise. Dans ce contrat, nous utiliserons ces trois interfaces de , et . Ces interfaces définissent des fonctions telles que , , et . Nous expliquerons chacun d’eux en détail au fur et à mesure. NonFungibleToken: Provider Receiver CollectionPublic deposit withdraw borrowNFT getIDs Nous ajouterons également certains événements que nous émettrons à partir de ces fonctions, ainsi que déclarerons certaines variables que nous utiliserons plus loin dans le didacticiel. 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 <- {} } } } Retirer Maintenant, créons la fonction requise par l'interface. 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()... } À l'aide de cette fonction, vous pouvez déplacer la ressource NFT hors de la collection. Si ça: : panique et renvoie une erreur. Échec : il émet un événement de retrait et renvoie la ressource à l'appelant. Réussi L'appelant peut ensuite utiliser cette ressource et la sauvegarder dans le stockage de son compte. Dépôt Il est maintenant temps de passer à la fonction requise par . deposit() NonFungibleToken.Receiver 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()... } Emprunter et obtenir un ID Concentrons-nous maintenant sur les deux fonctions requises par et . 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()... } Destructeur La dernière chose dont nous avons besoin pour la ressource de collection est un destructeur. destroy (){ destroy self.ownedNFTs } Puisque la ressource Collection contient d’autres ressources (ressources NFT), nous devons spécifier un destructeur. Un destructeur s'exécute lorsque l'objet est détruit. Cela garantit que les ressources ne se retrouvent pas « sans abri » lorsque leur ressource parent est détruite. Nous n'avons pas besoin de destructeur pour la ressource NFT car elle ne contient aucune autre ressource. Examinons le code source complet des ressources de la collection : 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() } } Maintenant, nous avons terminé toutes les ressources. Ensuite, nous examinerons la fonction globale. Fonction globale Les fonctions globales sont des fonctions définies au niveau global du contrat intelligent, ce qui signifie qu'elles ne font partie d'aucune ressource. Ceux-ci sont accessibles et appelés par le public, et exposent les fonctionnalités de base du contrat intelligent au public. : Cette fonction initialise un vide dans le stockage du compte de l'appelant. createEmptyCollection Collectibles.Collection : Cette fonction pratique vous aide à découvrir si votre compte dispose déjà d'une ressource . checkCollection collection : Cette fonction est super cool car elle permet à n'importe qui de créer un NFT. 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()... Conclusion du contrat intelligent Et maintenant, ENFIN, avec tout en place, nous avons fini d'écrire notre contrat intelligent. Jetez un œil au code final . ici Voyons maintenant comment un utilisateur interagit avec les contrats intelligents déployés sur la blockchain Flow. Il y a deux étapes pour interagir avec la blockchain Flow : Mutez l'état en exécutant des transactions. Interrogez la blockchain en exécutant un script. Muter l'état en exécutant des transactions Les transactions sont des données signées cryptographiquement qui contiennent un ensemble d'instructions qui interagissent avec le contrat intelligent pour mettre à jour l'état du flux. En termes simples, cela ressemble à un appel de fonction qui modifie les données sur la blockchain. Les transactions impliquent généralement un certain coût, qui peut varier en fonction de la blockchain sur laquelle vous vous trouvez. Une transaction comprend plusieurs phases facultatives : phase , , et . prepare pre execute post . Chaque phase a un objectif ; les deux phases les plus importantes sont et . Vous pouvez en savoir plus à ce sujet dans le document de référence Cadence sur les transactions prepare execute : Cette phase est utilisée pour accéder aux données et informations contenues dans le compte du signataire (autorisé par le type AuthAccount). Prepare Phase : Cette phase est utilisée pour exécuter des actions. Execute Phase Maintenant, créons une transaction pour notre projet. Suivez les étapes ci-dessous pour créer une transaction dans votre dossier de projet. Étape 1 : Créez un fichier. Tout d’abord, allez dans le dossier du projet et ouvrez le dossier . À l'intérieur, ouvrez le dossier et créez un nouveau fichier portant le nom et cadence transaction Create_Collection.cdc mint_nft.cdc Étape 2 : ajoutez le code de transaction de création de collecte. 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) } } } Décomposons ce code ligne par ligne : Cette transaction interagit avec le contrat intelligent Collectibles. Ensuite, il vérifie si l'expéditeur (signataire) a une ressource Collection stockée dans son compte en empruntant une référence à la ressource Collection à partir du chemin de stockage spécifié . Si la référence est nulle, cela signifie que le signataire n'a pas encore de collection. Collectibles.CollectionStoragePath Si le signataire n'a pas de collection, il crée alors une collection vide en appelant la fonction . createEmptyCollection() Après avoir créé la collection vide, placez-la dans le compte du signataire sous le chemin de stockage spécifié . Collectibles.CollectionStoragePath Cela établit un lien entre le compte du signataire et la collection nouvellement créée à l'aide . link() Étape 3 : Ajoutez le code de transaction Mint NFT. 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) } } Décomposons ce code ligne par ligne : Nous importons d'abord le et Collectibles. Collectibles contract NonFungibleToken Cette ligne définit une nouvelle transaction. Il prend deux arguments, nom et image, tous deux de type String. Ces arguments sont utilisés pour transmettre le nom et l'image du NFT en cours de création. transaction(name: String, image: String) Cette ligne déclare une nouvelle variable Il s'agit d'une référence à une collection publique de NFT de type . Cette référence sera utilisée pour interagir avec la collection où nous déposerons le nouveau NFT. let receiverCollectionRef: &{NonFungibleToken.CollectionPublic} receiverCollectionRef. NonFungibleToken.CollectionPublic Cette ligne démarre le bloc de préparation, qui est exécuté avant la transaction. Il faut un argument signataire de type . représente le compte du signataire de la transaction. prepare(signer: AuthAccount) AuthAccount AuthAccount Il emprunte une référence à à partir du stockage du signataire à l'intérieur du bloc de préparation. Il utilise la fonction d'emprunt pour accéder à la référence à la collection et la stocker dans la variable . Collectibles.Collection receiverCollectionRef Si la référence n'est pas trouvée (si la collection n'existe pas dans le stockage du signataire, par exemple), le message d'erreur « Impossible d'emprunter la référence de la collection ». Le bloc contient la logique d'exécution principale de la transaction. Le code à l’intérieur de ce bloc sera exécuté une fois le bloc terminé avec succès. execute prepare À l'intérieur du bloc , cette ligne appelle la fonction du contrat avec le nom et les arguments d'image fournis. Cette fonction devrait créer un nouveau NFT avec le nom et l'image donnés. Le symbole indique que le NFT est reçu comme un objet pouvant être déplacé (une ressource). nft <- Collectibles.mintNFT(_name: name, image: image) execute mintNFT Collectibles <- Cette ligne dépose le NFT nouvellement créé dans la collection spécifiée. Il utilise la fonction de dépôt sur pour transférer la propriété du NFT du compte d'exécution de la transaction vers la collection. Le symbole indique également ici que le NFT est déplacé en tant que ressource pendant le processus . self.receiverCollectionRef.deposit(token: <-nft) receiverCollectionRef <- deposit Interrogez la blockchain en exécutant un script Nous utilisons un script pour afficher ou lire les données de la blockchain. Les scripts sont gratuits et ne nécessitent pas de signature. Suivez les étapes ci-dessous pour créer un script dans votre dossier de projet. Étape 1 : Créez un fichier. Tout d’abord, allez dans le dossier du projet et ouvrez le dossier . À l'intérieur, ouvrez le dossier et créez un nouveau fichier portant le nom . cadence script view_nft.cdc Étape 2 : Afficher le script NFT 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) } Décomposons ce code ligne par ligne : Tout d’abord, nous importons le contrat et . NonFungibleToken Collectibles Cette ligne définit le point d'entrée du script, qui est une fonction publique nommée main. La fonction prend deux paramètres : pub fun main(acctAddress: Address, id: UInt64): &NonFungibleToken.NFT? : Un paramètre de type représentant l'adresse d'un compte sur la blockchain Flow. acctAddress Address : Un paramètre de type représentant l'identifiant unique du NFT au sein de la collection. id UInt64 Ensuite, nous utilisons pour récupérer la capacité pour l' spécifiée. Une capacité est une référence à une ressource qui permet d'accéder à ses fonctions et à ses données. Dans ce cas, il récupère la capacité du type de ressource . getCapability Collectibles.Collection acctAddress Collectibles.Collection Ensuite, nous empruntons un NFT à à l’aide de la fonction . La fonction prend le paramètre , qui est l'identifiant unique du NFT au sein de la collection. La fonction sur une capacité permet de lire les données de la ressource. collectionRef borrowNFT borrowNFT id borrow Enfin, nous renvoyons le NFT de la fonction. Étape 3 : Déploiement Testnet Il est maintenant temps de déployer notre contrat intelligent sur le réseau de test Flow. 1. Créez un compte Flow. Exécutez la commande suivante dans le terminal pour générer un compte Flow : flow keys generate Assurez-vous de noter votre clé publique et votre clé privée. Ensuite, nous nous dirigerons vers , créez une nouvelle adresse basée sur nos clés et approvisionnez notre compte avec quelques jetons de test. Suivez les étapes suivantes pour créer votre compte : le robinet de débit Collez votre clé publique dans le champ de saisie spécifié. Conservez les algorithmes de signature et de hachage par défaut. Complétez le Captcha. Cliquez sur Créer un compte. Après avoir créé un compte, nous recevons un dialogue avec notre nouvelle adresse Flow contenant 1 000 jetons Flow de test. . Copiez l'adresse afin que nous puissions l'utiliser à l'avenir 2. Configurez le projet. Maintenant, configurons notre projet. Initialement, lorsque nous avons configuré le projet, il a créé un fichier . flow.json Il s'agit du fichier de configuration de Flow CLI et définit la configuration des actions que Flow CLI peut effectuer pour vous. Considérez cela comme à peu près équivalent à sur Ethereum. hardhat.config.js Maintenant, ouvrez votre éditeur de code, copiez et collez le code ci-dessous dans votre fichier . 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" ] } } } Copier et coller. Collez votre clé privée générée à l'endroit (clé : « ENTREZ VOTRE CLÉ PRIVÉE GÉNÉRÉE ICI ») dans le code. Exécuter. Maintenant, exécutez le code sur le testnet. Accédez au terminal et exécutez le code suivant : flow project deploy --network testnet 5. Attendez la confirmation. Après avoir soumis la transaction, vous recevrez un identifiant de transaction. Attendez que la transaction soit confirmée sur le testnet, indiquant que le contrat intelligent a été déployé avec succès. Vérifiez votre contrat déployé . ici Vérifiez le code complet sur . GitHub Pensées finales et félicitations ! Toutes nos félicitations! Vous avez maintenant créé un portail d'objets de collection sur la blockchain Flow et l'avez déployé sur le testnet. Et après? Maintenant, vous pouvez travailler sur la construction du frontend que nous aborderons dans la partie 2 de cette série. Passez une très bonne journée ! Également publié ici