Ir al contenido principal

Cómo escribir & desplegar un NFT (parte 1/3 de la serie de tutoriales sobre NFT)

ERC-721AlchemySoliditycontratos inteligentes
Principiante
Sumi Mudgil
22 de abril de 2021
14 minuto leído minute read

Con toda la atención pública hacia la cadena de bloques que han supuesto los NFT, ¡esta es una excelente ocasión para entender el furor que han causado, publicando su propio contrato NFT (ERC-721 Token) en la cadena de bloques de Ethereum.

Alchemy se enorgullece de promocionar a los protagonistas del espacio NFT, incluyendo Makersplace (que recientemente logró una venta récord de obras de arte digitales en Christie's por 69 millones de dólares), Dapper Labs (creadores de NBA Top Shot & Crypto Kitties), OpenSea (el mayor mercado de NFT del mundo), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol e Immutable, entre muchos otros.

En este tutorial, recorreremos la creación e implementación de un contrato inteligente ERC-721 en la red de pruebas de Sepolia usando MetaMask(opens in a new tab), Solidity(opens in a new tab), Hardhat(opens in a new tab), Pinata(opens in a new tab) y Alchemy(opens in a new tab) (no se preocupe si aún no entiende lo que significa esto, ¡lo explicaremos!).

En la parte 2 de este tutorial, explicaremos cómo podemos utilizar nuestro contrato inteligente para acuñar un NFT, y en la parte 3 explicaremos cómo ver su NFT en MetaMask.

Y, por supuesto, si le surge alguna duda en cualquier momento, no dude en consultar Alchemy Discord(opens in a new tab) o visitar los documentos de la API de NFT en Alchemy(opens in a new tab)!

Paso 1: Conectarse a la red Ethereum

Hay muchas maneras de hacer peticiones a la cadena de bloques Ethereum, pero para simplificarnos la vida, usaremos una cuenta gratuita en Alchemy(opens in a new tab), una plataforma de desarrollo de cadena de bloques y API que nos permite comunicarnos con la cadena Ethereum sin tener que ejecutar nuestros propios nodos.

En este tutorial, también aprovecharemos las herramientas de desarrollo de Alchemy para monitorizar y analizar lo que está ocurriendo dentro de nuestro despliegue de contratos inteligentes. Si aún no tiene una cuenta de Alchemy, puede registrarse gratis en aquí(opens in a new tab).

Paso 2: Crear su aplicación (y llave API)

Una vez que haya creado una cuenta de Alchemy, puede generar una clave de API creando una aplicación. Esto nos permitirá realizar solicitudes a la red de pruebas de Sepolia. Consulte esta guía(opens in a new tab) si tiene curiosidad para saber más sobre redes de pruebas.

  1. Navegue a la página «Crear App» en su tablero Alchemy pasando el cursor sobre «Apps» en la barra de navegación y haciendo clic en «Crear App».

Crear su app

  1. Dele un nombre a su aplicación (Nosotros elegimos «¡Mi primer NFT!»), incluya una breve descripción, seleccione «Ethereum» para la cadena y «Sepolia» para su red. Desde La Fusión, las otras redes de pruebas han quedado obsoletas.

Configure y publíque su aplicación

  1. ¡Haga clic en «Crear app» y eso es todo! Su aplicación debería aparecer en el tablero de abajo.

Paso 3: Crear una cuenta Ethereum (dirección)

Necesitamos una cuenta Ethereum para enviar y recibir transacciones. Para este tutorial, usaremos Metamask, una cartera virtual en el navegador usada para manejar la dirección de su cuenta Ethereum. Si quiere más información sobre cómo funcionan las transacciones en Ethereum, eche un vistazo a esta página de Ethereum Foundation.

Puede descargar y crear una cuenta Metamask gratis aquí(opens in a new tab). Cuando esté creando una cuenta, o si ya tiene una cuenta, asegurese de alternar a la «red de pruebas Sepolia» en la parte superior derecha (para que no estemos usando dinero real).

Establezca Sepolia como su red

Paso 4: Añadir ether de un faucet

Para desarrollar nuestro contrato inteligente en la red de prueba, necesitaremos algunos ETH de prueba. Para conseguir ETH, puede ir a la Faucet (o grifo) Sepolia(opens in a new tab) hospedado por Alchemy, iniciar sesión e introducir la dirección de su cuenta y luego hacer clic en «Send Me ETH» (Enviarme ETH). Deberían aparecer ETH en su cuenta de Metamask poco después.

Paso 5: Comprobar su balance

Para comprobar que nuestro balance está ahí, hagamos una solicitud de eth_getBalance(opens in a new tab) usando la herramienta de composición de Alchemy(opens in a new tab). Esto devolverá la cantidad de ETH a nuestra cartera. Después de introducir la dirección de su cuenta de Metamask y hacer clic en «Send Request» (Enviar Solicitud), debería ver una respuesta como esta:

1`{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}`

Nota Este resultado es en wei, no ETH. Wei se usa como la denominación más pequeña de Ether. La conversión de wei a ETH es 1 eth = 1018 wei. Así que si convertimos 0xde0b6b3a7640000 a decimal, obtenemos 1*1018 wei, que es igual a 1 ETH.

¡Fiu! Nuestro dinero de prueba está ahí sano y salvo.

Paso 6: Iniciar su proyecto

Primero, necesitaremos crear una carpeta para nuestro proyecto. Vaya a su línea de comando y escriba:

1mkdir my-nft
2cd my-nft

Ahora que estamos dentro de nuestra carpeta de proyecto, usaremos npm init para iniciar el proyecto. Si no tiene instalado npm, siga estas instrucciones(opens in a new tab) (también necesitaremos Node.js(opens in a new tab), así que ¡descárgueselo también!).

1npm init

Realmente no importa la respuesta que dé a las preguntas de instalación, he aquí un ejemplo de cómo lo hicimos nosotros:

1package name: (my-nft)
2version: (1.0.0)
3description: My first NFT!
4entry point: (index.js)
5test command:
6git repository:
7keywords:
8author:
9license: (ISC)
10About to write to /Users/thesuperb1/Desktop/my-nft/package.json:
11
12{
13 "name": "my-nft",
14 "version": "1.0.0",
15 "description": "My first NFT!",
16 "main": "index.js",
17 "scripts": {
18 "test": "echo \"Error: no test specified\" && exit 1"
19 },
20 "author": "",
21 "license": "ISC"
22}
Mostrar todo

Apruebe package.json y ¡ya puede comenzar!

Paso 7: Instalar Hardhat(opens in a new tab)

Hardhat es un entorno de desarrollo para compilar, implementar, probar y depurar su software de Ethereum. Ayuda a los desarrolladores cuando crean contratos inteligentes y dApps localmente antes de la implementación en la cadena real.

Dentro de nuestro proyecto my-nft, ejecute:

1npm install --save-dev hardhat

Revise esta página para obtener más información acerca de las intrucciones de instalación(opens in a new tab).

Paso 8: Crear proyecto Hardhat

Dentro de la carpeta de nuestro proyecto, ejecute:

1npx hardhat

Debería aparecer un mensaje de bienvenida y la opción de seleccionar lo que desee hacer. Seleccione «create an empty hardhat.config.js»:

1888 888 888 888 888
2888 888 888 888 888
3888 888 888 888 888
48888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
5888 888 "88b 888P" d88" 888 888 "88b "88b 888
6888 888 .d888888 888 888 888 888 888 .d888888 888
7888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
8888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
9👷 Welcome to Hardhat v2.0.11 👷‍
10? What do you want to do? …
11Create a sample project
12❯ Create an empty hardhat.config.js
13Quit
Mostrar todo

Esta acción nos creará un archivo hardhat.config.js, que es donde especificaremos todos los ajustes para nuestro proyecto (en el paso 13).

Paso 9: Añadir carpetas de proyecto

Para mantener nuestro proyecto organizado, crearemos dos nuevas carpetas. Navegue al directorio raíz de su proyecto en su línea de comandos y escriba:

1mkdir contracts
2mkdir scripts
  • contratos/es donde guardaremos nuestro código de contrato inteligente NFT

  • scripts/ es donde mantendremos scripts para desplegar e interactuar con nuestro contrato inteligente

Paso 10: Escribir nuestro contrato

Ahora que nuestro entorno está configurado, es hora de dedicarse a cosas más emocionantes, como por ejemplo, ¡escribir nuestro código de contrato inteligente!

Abra el proyecto my-nft en su editor favorito (a nosotros nos gusta VSCode(opens in a new tab)). Los contratos inteligentes están escritos en un lenguaje llamado Solidity que es el que utilizaremos para escribir nuestro contrato inteligente MyNFT.sol

  1. Vaya a la carpeta contratos y cree un nuevo archivo llamado MyNFT.sol

  2. A continuación se muestra nuestro código NFT de contrato inteligente, el cual se basa en la implementación ERC-721 de la biblioteca OpenZeppelin(opens in a new tab). Copie y pegue el contenido de abajo en su archivo MyNFT.sol.

    1//Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
    2// SPDX-License-Identifier: MIT
    3pragma solidity ^0.8.0;
    4
    5import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    6import "@openzeppelin/contracts/utils/Counters.sol";
    7import "@openzeppelin/contracts/access/Ownable.sol";
    8import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
    9
    10contract MyNFT is ERC721URIStorage, Ownable {
    11 using Counters for Counters.Counter;
    12 Counters.Counter private _tokenIds;
    13
    14 constructor() ERC721("MyNFT", "NFT") {}
    15
    16 function mintNFT(address recipient, string memory tokenURI)
    17 public onlyOwner
    18 returns (uint256)
    19 {
    20 _tokenIds.increment();
    21
    22 uint256 newItemId = _tokenIds.current();
    23 _mint(recipient, newItemId);
    24 _setTokenURI(newItemId, tokenURI);
    25
    26 return newItemId;
    27 }
    28}
    Mostrar todo
    Copiar
  3. Como estamos heredando clases de la biblioteca de contratos de OpenZeppelin, en la línea de comandos, ejecute npm install @openzeppelin/contracts para instalar la biblioteca en nuestra carpeta.

Entonces, ¿qué hace exactamente este código? Desglosémoslo, línea por línea.

En la parte superior de nuestro contrato inteligente, importamos tres clases de contrato inteligente de OpenZeppelin(opens in a new tab):

Después de nuestras declaraciones de importación, tenemos nuestro contrato inteligente NFT personalizado, que es sorprendentemente corto, ¡sólo contiene un contador, un constructor y una sola función! Esto es gracias a nuestros contratos de OpenZeppelin heredados, los cuales implementan la mayoría de los métodos que necesitamos para crear un NFT, como ownerOf (dueño de) que indica el dueño del NFT, y transferFrom (transferir desde), que transfiere la propiedad del NFT de una cuenta a otra.

En nuestro constructor ERC-721, notará que pasamos 2 cadenas, «MyNFT» y «NFT». La primera variable es el nombre del contrato inteligente, y la segunda es su símbolo. ¡Puede darle el nombre que quiera a cada una de estas variables!

Por último, tenemos nuestra función mintNFT(address recipient, string memory tokenURI) que nos permite acuñar un NFT. Notará que esta función toma dos variables:

  • address recipient especifica la dirección que recibirá su NFT recién acuñado

  • string memory tokenURI es una cadena que debe resolver un documento JSON que describe los metadatos de NFT. Los metadatos de un NFT es realmente lo que lo lleva a la vida, permitiéndole tener características configurables, como el nombre, descripción, imagen y otros atributos. En la parte 2 de este tutorial, describiremos cómo configurar estos metadatos.

mintNFT activa algunos métodos de la biblioteca ERC-721 heredada, y en última instancia muestra un número que representa la ID del NFT recién acuñado.

Paso 11: Conectar MetaMask & Alchemy a su proyecto

Ahora que hemos creado una cartera de MetaMask, una cuenta de Alchemy y hemos escrito nuestro contrato inteligente, es hora de conectarlos a los tres.

Cada transacción enviada desde su billetera virtual requiere una firma utilizando su clave privada única. Para proporcionar este permiso a nuestro programa, podemos almacenar de manera segura nuestra clave privada (y clave Alchemy API) en un archivo de entorno.

Si quiere ahondar sobre el envío de transacciones, consulte este tutorial sobre el envío de transacciones usando web3.

Primero, instale el paquete dotenv en su directorio de proyecto:

1npm install dotenv --save

Después, cree un archivo .env en el directorio raíz de nuestro proyecto, y añádale la llave inteligente de Metamask y la API URL de HTTP Alchemy.

Copie el URL de su API Alchemy

Su .env debería ser parecido a:

1API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
2PRIVATE_KEY="your-metamask-private-key"

Para conectarlos a nuestro código, haremos referencia a estas variables en nuestro archivo hardhat.config.js en el paso 13.

page-tutorials-env-banner

Paso 12: Instalar Ethers.js

Ethers.js es una biblioteca que facilita la interacción y la realización de solicitudes a Ethereum agrupando métodos JSON-RPC estándar con métodos más fáciles para el usuario.

Hardhat hace que integrar plugins(opens in a new tab) sea ultrafácil para herramientas adicionales y funcionalidades ampliadas. Aprovecharemos el plugin Ethers(opens in a new tab) para la implementación de contratos (Ethers.js(opens in a new tab) tiene algunos métodos de implementación de contratos ultralimpios).

En el directorio de su proyecto, teclee:

1npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0

También necesitaremos ethers en nuestro hardhat.config.js en el siguiente paso.

Paso 13: Actualizar hardhat.config.js

Hasta el momento, hemos añadido varias dependencias y plugins, ahora necesitamos actualizar hardhat.config.js para que nuestro proyecto los reconozca.

Actualice su hardhat.config.js para que tenga este aspecto:

1/**
2* @type import('hardhat/config').HardhatUserConfig
3*/
4require('dotenv').config();
5require("@nomiclabs/hardhat-ethers");
6const { API_URL, PRIVATE_KEY } = process.env;
7module.exports = {
8 solidity: "0.8.1",
9 defaultNetwork: "sepolia",
10 networks: {
11 hardhat: {},
12 sepolia: {
13 url: API_URL,
14 accounts: [`0x${PRIVATE_KEY}`]
15 }
16 },
17}
Mostrar todo

Paso 14: Compilar nuestro contrato

Para asegurarnos de que todo funciona correctamente hasta ahora, compilemos nuestro contrato. La tarea de compilación es una de las tareas de Hardhat incorporadas.

Desde la linea de comandos, ejecute:

1npx hardhat compile

Puede que reciba una advertencia sobre el identificador de licencia SPDX no proporcionado en el archivo fuente, pero no se preocupe si la recibe, ¡esperemos que todo lo demás esté correcto! Si no es así, siempre puede escribir un mensaje en Alchemy discord(opens in a new tab).

Paso 15: Escribir nuestro script de despliegue

Ahora que nuestro contrato está escrito y nuestro archivo de configuración está listo, es momento de escribir nuestro script de implementación del contrato.

Vaya a la carpeta scripts/ y cree un nuevo archivo llamado deploy.js, añadiendo los siguientes contenidos:

1async function main() {
2 const MyNFT = await ethers.getContractFactory("MyNFT")
3
4 // Start deployment, returning a promise that resolves to a contract object
5 const myNFT = await MyNFT.deploy()
6 await myNFT.deployed()
7 console.log("Contract deployed to address:", myNFT.address)
8}
9
10main()
11 .then(() => process.exit(0))
12 .catch((error) => {
13 console.error(error)
14 process.exit(1)
15 })
Mostrar todo
Copiar

Hardhat hace un trabajo increíble al explicar lo que hace cada una de estas líneas de código en su tutorial de contratos(opens in a new tab), aquí hemos asumido sus explicaciones.

1const MyNFT = await ethers.getContractFactory("MyNFT");

Un ContractFactory en ethers.js es una abstracción utilizada para implementar nuevos contratos inteligentes, por lo que MyNFT aquí es una fábrica para las instancias de nuestro contrato NFT. Cuando se utiliza el plugin ContractFactory y las instancias de contrato del plugin de hardhat-ethers están conectadas al primer firmante por defecto.

1const myNFT = await MyNFT.deploy();

Ejecutar un despliegue() en un ContractFactory iniciará el despliegue y devolverá una Promesa que se resuelva a un Contrato. Este es el objeto que tiene un método para cada una de nuestras funciones de contrato inteligente.

Paso 16: Desplegar nuestro contrato

¡Por fin estamos listos para desplegar nuestro contrato inteligente! Navegue de nuevo a la raíz del directorio de su proyecto, y en la línea de comando ejecute:

1npx hardhat --network sepolia run scripts/deploy.js

Debería mostrarse algo parecido a esto:

1Contract deployed to address: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

Si vamos a Sepolia etherscan(opens in a new tab) y buscamos nuestra dirección de contrato deberíamos de poder ver que se ha implementado de forma exitosa. Si no puede verlo inmediatamente, por favor espere unos instantes, ya que puede llevar algún tiempo. El objeto de la transacción tendrá un aspecto parecido a esto:

Visualice la dirección de su transacción en Etherscan

La dirección de origen debe coincidir con la dirección de su cuenta de MetaMask y la dirección de destino dirá «Contract Creation» (Creación de contrato). Si hacemos clic en la transacción, veremos la dirección de nuestro contrato en la casilla To (para):

Ver la dirección de su contrato en Etherscan

¡Síííííí! ¡Acaba de implementar su contrato inteligente NFT en la cadena de Ethereum (red de pruebas)!

Para entender lo que está pasando internamente, vayamos a la pestaña de Explorer en nuestro panel Alchemy(opens in a new tab). Si dispone de varias aplicaciones de Alchemy, asegúrese de filtrar por aplicación y seleccione «MyNFT».

Ver las activaciones realizadas internamente con el panel del explorador de Alchemy

Aquí verá un puñado de activaciones JSON-RPC que Hardhat/Ethers ha realizado internamente cuando ejecutamos a la función .deploy(). Dos cosas importantes que se deben recalcar aquí son eth_sendRawTransaction, que es la solicitud para escribir realmente nuestro contrato inteligente en la cadena Sepolia, y eth_getTransactionByHash, que es una solicitud para leer información sobre nuestra transacción dado el hash (un patrón típico al enviar transacciones). Para ahondar más sobre el envío de transacciones, consulte este tutorial en Envío de transacciones mediante Web3.

Y así concluye la parte 1 de este tutorial. En la parte 2, interactuaremos con nuestro contrato inteligente acuñando un NFT, y en la parte 3 le enseñaremos a ver su NFT en su cartera de Ethereum.

Última edición: @UNOFFICIALbgd(opens in a new tab), 16 de agosto de 2024

¿Le ha resultado útil este tutorial?