Como acuñar un NFT (parte 2/3 de la serie de tutoriales de NFT)

ERC-721alchemysoliditycontratos inteligentes

Principiante

Sumi Mudgil

22 de abril de 2021

9 minuto leído minute read

Beeple(opens in a new tab): 69 millones de $ 3Lau(opens in a new tab): 11 millones de $ Grimes(opens in a new tab): 6 millones de $

Todos ellos acuñaron sus NFT usando la potente API de Alchemy. En este tutorial, le enseñaremos a hacer lo mismo en < 10 minutos.

«Acuñar un NFT» es el acto de publicar una instancia única de su token ERC-721 en la cadena de bloques. Usando nuestro contrato inteligente de la parte 1 de esta serie de tutoriales sobre NFT, hagamos flexibles nuestras habilidades Web3 y acuñemos un NFT. Al finalizar este tutorial, será capaz de localizar tantos NFT como se le antojen (¡o su billetera alcance!).

¡Comencemos!

Paso 1: Instalar Web3

Si siguió el primer tutorial sobre cómo crear su contrato inteligente NFT, entonces ya está familiarizado con el uso de Ethers.js. Web3 es similar a Ethers, ya que es una biblioteca usada para crear solicitudes en la cadena de bloques de Ethereum de manera simple. En este tutorial usaremos Alchemy Web3(opens in a new tab), que es una biblioteca Web3 mejorada que ofrece reintentos automáticos y un soporte robusto para WebSocket.

En el directorio de inicio de su proyecto ejecute:

1npm install @alch/alchemy-web3

Paso 2: Crear un archvio `mint-nft.js`

Dentro de su directorio de scripts, cree el archivo mint-nft.js y añada las siguientes líneas de código:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
4const web3 = createAlchemyWeb3(API_URL)
 Copiar

Paso 3: Obtener la ABI de su contrato

Nuestro contrato ABI (las siglas en inglés de Aplicación de Interfaz Binaria) es la interfaz para interactuar con nuestro contrato inteligente. Puede profundizar aquí(opens in a new tab) acerca de los contratos ABI. Hardhat genera automáticamente una ABI para nosotros y la guarda en el archivo MyNFT.json. Para poder usarlo, necesitaremos analizar el contenido añadiendo las siguientes líneas de código a nuestro archivo mint-nft.js:

1const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
 Copiar

Si quiere ver la ABI puede hacerlo en su propia consola:

1console.log(JSON.stringify(contract.abi))
 Copiar

Para ejecutar mint-nft.js y ver su ABI impresa en la consola, vaya a la ventana del terminal y ejecute:

1node scripts/mint-nft.js
 Copiar

Paso 4: Configurar los metadatos para su NFT usando IPFS

Si recuerda la primera parte de nuestro tutorial, nuestra función mintNFT del contrato inteligente toma un parámetro de tokenURI que debe resolverse en un documento JSON que describe los metadatos de NFT —que es lo que realmente hace que el NFT cobre vida— permitiéndole tener propiedades configurables, como su nombre, descripción, imagen y otros atributos.

Interplanetary File System (IPFS) es un protocolo de red descentralizado y de red entre pares para guardar y compartir datos en un sistema de archivos distribuido.

Usaremos Pinata, una conveniente API y kit de herramientas de IPFS, para almacenar nuestros activos y metadatos del NFT y así garantizar que nuestro NFT esté verdaderamente descentralizado. Si no tiene una cuenta en Pinata, puede crearla gratuitamente aquí(opens in a new tab) y completar los pasos para verificar su correo electrónico.

Una vez que haya creado una cuenta:

Navegue hasta la página de «Files» (Archivos) y haga clic en botón azul «Upload» (Subir) en la parte superior izquierda de la página.
Suba una imagen a Pinata: este será el recurso de imagen para su NFT. Dele a su activo el nombre que desee.
Una vez subida, verá la info dentro de la tabla en la página «Files» (Archivos). También verá una columna CID. Puede copiar el CID haciendo clic en el botón copiar junto a él. Puede ver el activo subido en https://gateway.pinata.cloud/ipfs/<CID>. Por ejemplo, puede ver la imagen que usamos en IPFS aquí(opens in a new tab).

He aquí un resumen de los pasos descritos anteriormente para aquellos que tienen memoria visual:

Ahora, vamos a subir otro documento más a Pinata. Pero antes de hacer eso, necesitamos ¡crearlo!

En su directorio raíz, cree un nuevo archivo llamado nft-metadata.json y añada el siguiente código json:

1{
2  "attributes": [
3    {
4      "trait_type": "Breed",
5      "value": "Maltipoo"
6    },
7    {
8      "trait_type": "Eye color",
9      "value": "Mocha"
10    }
11  ],
12  "description": "The world's most adorable and sensitive pup.",
13  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14  "name": "Ramses"
15}
Mostrar todo
 Copiar

Cambie libremente los datos en el json. Puede quitar o añadir la sección de atributos. Más importante, asegúrese de que el campo de la imagen apunte a la localización de su imagen IPFS - de otra manera, su NFT incluirá una foto (¡muy linda!) de un perrito.

Una vez que haya terminado de editar el archivo JSON, guárdelo y súbalo a Pinata, siguiendo los mismos pasos que utilizamos para subir la imagen.

Paso 5: Crear una instancia de su contrato

Seguidamente, para interactuar con nuestro contrato, necesitamos crear una instancia de él en nuestro código. Para hacerlo, necesitaremos nuestra dirección de contrato, que podemos obtener de la implementación o Etherscan(opens in a new tab) buscando la dirección que usó para implementar el contrato.

En el ejemplo anterior, nuestra dirección de contrato es 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

A continuación, utilizaremos el método de contrato web3(opens in a new tab) para crear nuestro contrato usando la ABI y la dirección. En el archivo mint-nft.js, añada lo siguiente:

1const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
2
3const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
 Copiar

Paso 6: Actualizar el archivo `.env`

Ahora, para crear y enviar transacciones en la cadena de Ethereum, usaremos la dirección de su cuenta pública de Ethereum para obtener la cuenta nonce (que explicaremos a continuación).

Añada su clave pública a su archivo .env: si completó la parte 1 del tutorial, nuestro archivo .env ahora debería ser algo parecido a esto:

1API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
2PRIVATE_KEY = "your-private-account-address"
3PUBLIC_KEY = "your-public-account-address"
 Copiar

Paso 7: Crear su transacción

Primero, vamos a definir una función llamada mintNFT(tokenData) y crear nuestra transacción haciendo lo siguiente:

Tome su PRIVATE_KEY y su PUBLIC_KEY del archivo .env.
Después, necesitaremos averiguar la cuenta nonce. Las especificaciones nonce se usan para rastrear el número de transacciones enviadas desde su dirección - las cuales necesitaremos por cuestiones de seguridad y para prevenir ataques repetidos(opens in a new tab). Para obtener el número de transacciones enviadas desde su dirección, usamos getTransactionCount(opens in a new tab).
Finalmente estableceremos nuestra transacción con la siguiente información:

'from': PUBLIC_KEY: El origen de nuestra transacción es nuestra dirección pública
'to': contractAddress: El contrato con el que queremos interactuar y enviar la transacción
'nonce': nonce: la cuenta nonce con el número de transacciones enviadas desde nuestra dirección
'gas': estimatedGas: El gas estimado que necesitamos para completar la transacción
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI(): El cálculo que deseamos realizar en esta transacción, que en este caso es acuñar un NFT

Su archivo mint-nft.js debería ser algo parecido a esto:

1   require('dotenv').config();
2   const API_URL = process.env.API_URL;
3   const PUBLIC_KEY = process.env.PUBLIC_KEY;
4   const PRIVATE_KEY = process.env.PRIVATE_KEY;
5
6   const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
7   const web3 = createAlchemyWeb3(API_URL);
8
9   const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
10   const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
11   const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
12
13   async function mintNFT(tokenURI) {
14     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
15
16   //the transaction
17     const tx = {
18       'from': PUBLIC_KEY,
19       'to': contractAddress,
20       'nonce': nonce,
21       'gas': 500000,
22       'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
23     };
24   }
Mostrar todo
 Copiar

Paso 8: Firmar la transacción

Ahora que ya hemos creado nuestra transacción, necesitamos firmarla para poder enviarla. Aquí es donde usaremos nuestra clave privada.

web3.eth.sendSignedTransaction nos dará el hash de transacción, el cual usaremos para asegurarnos de que nuestra transacción ha sido minada y no descartada por la red. Notará que en la sección de firma de la transacción, hemos añadido algunas comprobaciones de errores, así sabremos si nuestra transacción se ha enviado correctamente.

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
15
16  //the transaction
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "The hash of your transaction is: ",
34              hash,
35              "\nCheck Alchemy's Mempool to view the status of your transaction!"
36            )
37          } else {
38            console.log(
39              "Something went wrong when submitting your transaction:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log(" Promise failed:", err)
48    })
49}
Mostrar todo
 Copiar

Paso 9: Activar el `mintNFT` y ejecutar el nodo `mint-nft.js`

¿Recuerda el metadata.json que ha subido a Pinata? Obtenga su hashcode de Pinata y escriba lo siguiente como parámetro de la función mintNFT https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

Así es cómo se puede obtener el código hash:

Cómo obtener el código hash de sus metadatos en Pinata

Asegúrese de que el código hash que copió enlaza con su metadata.json cargando https://gateway.pinata.cloud/ipfs/<metadata-hash-code> en una ventana separada. La página debería tener un aspecto similar a la siguiente captura de pantalla:

Su página debería mostrar los metadatos json

Conjuntamente, su código debería tener un aspecto similar a este:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
15
16  //the transaction
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "The hash of your transaction is: ",
34              hash,
35              "\nCheck Alchemy's Mempool to view the status of your transaction!"
36            )
37          } else {
38            console.log(
39              "Something went wrong when submitting your transaction:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log("Promise failed:", err)
48    })
49}
50
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
Mostrar todo
 Copiar

Ahora, ejecute node scripts/mint-nft.js para implementar su NFT. Después de un par de segundos, debería aparecer una respuesta como esta en su terminal:

1The hash of your transaction is: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
2
3Check Alchemy's Mempool to view the status of your transaction!

A continuación, visite su zona de espera de Alchemy(opens in a new tab) para ver el estado de su transacción (ya sea que esté pendiente, haya sido minada o desechada por la red). Si su transacción se cuelga, también es útil comprobar Sepolia Etherscan(opens in a new tab) y buscar el hash de su transacción.

Ver el hash de transacción de su NFT en Etherscan

¡Y eso es todo! Ahora ha implementado y acuñado un NFT en la cadena de bloques de Ethereum

Con el mint-nft.js puede acuñar todos los NFT que quiera (o que su cartera le permita). Solo asegúrese de pasar un nuevo tokenURI que describa los metadatos del NFT (de lo contrario, terminará haciendo un montón de idénticos con ID diferentes).

¡Seguramente le gustaría mostrar su NFT en su cartera, por tanto no se pierda la parte 3: Cómo ver su NFT en su cartera!

Última edición: @pettinarip(opens in a new tab), 23 de noviembre de 2023