17 minutos de lectura
Resumen
¿Quieres crear una colección de 10 000 NFT? Esta guía te acompañará en el proceso para dar vida a tu colección de 10 000 NFT en Arbitrum Nova. Aprenderás a crear metadatos, a implementar un contrato inteligente de NFT con Hardhat y a acuñar tokens únicos para exhibirlos en un mercado de NFT destacado como TofuNFT.
Lo que necesitarás
- Conocimientos básicos de Solidity y JavaScript
- Node.js instalado
- Monedero sin custodia (por ejemplo, Torus, MetaMask, Coinbase Wallet)
- ETH en la cadena Arbitrum Nova (puedes utilizar el puente de Arbitrum Nova)
- Un editor de código (por ejemplo, VSCode)
Tus funciones
- Crear un contrato NFT con Hardhat
- Crea imágenes y metadatos para tu colección de NFT
- Prueba tu contrato NFT e impleméntalo en Arbitrum Nova
- Crea un NFT y visualízalo en un mercado de NFT
Descripción general de Arbitrum Nova
Arbitrum Nova es una solución de escalabilidad de capa 2 para Ethereum cuyo objetivo es ofrecer transacciones ultrarrápidas y económicas para aplicaciones descentralizadas. Utiliza una combinación de la tecnología AnyTrust y los Comités de Disponibilidad de Datos (DAC) para alcanzar sus objetivos, y resulta considerablemente más económica que Arbitrum One.
AnyTrust es una variante de la tecnología Arbitrum Nitro que reduce los costes al partir de un grado mínimo de confianza. AnyTrust recurre a un Comité de Disponibilidad de Datos (DAC) externo para almacenar los datos y ponerlos a disposición cuando se solicite. Quicknode, como proveedor líder de servicios de blockchain, fue seleccionado como miembro del comité DAC de Arbitrum Nova (junto con Google Cloud, Reddit y Consensys). Como miembro del DAC, Quicknode gestiona servidores de disponibilidad de datos, lo que permite que los datos de los lotes de transacciones estén disponibles bajo demanda a través de una API REST. Para obtener más información sobre los DAC, consulta esta entrada del blog de Quicknode.
Arbitrum Nova ofrece una gran variedad de casos de uso, como los juegos Web3 y la infraestructura social, pero en esta guía nos centraremos específicamente en los NFT (tokens no fungibles). Estos activos digitales únicos han ganado cada vez más popularidad en los últimos años, y hay varias razones por las que alguien podría querer desarrollar NFT en Arbitrum Nova:
- Costes de transacción ultrabajos
- Transacciones rápidas con tiempos de bloqueo cortos
- Interoperabilidad entre otras cadenas EVM
Estas ventajas también resultan beneficiosas para proyectos con grandes volúmenes de transacciones, como el desarrollo de videojuegos, los proyectos sociales y las finanzas descentralizadas (DeFi).
Si quieres saber más sobre las ventajas de Arbitrum Nova en comparación con Arbitrum One y otras cadenas de bloques, echa un vistazo a esta guía de Quicknode
Configuración del entorno de desarrollo
Paso 1: Acceder a Arbitrum Nova con Quicknode
Necesitarás un punto final de API para comunicarte con la cadena Arbitrum Nova. Puedes utilizar nodos públicos o implementar y gestionar tu propia infraestructura; sin embargo, si quieres tiempos de respuesta ocho veces más rápidos, puedes dejarnos a nosotros el trabajo pesado. Regístrate aquí para crear una cuenta.
Una vez que hayas iniciado sesión, haz clic en «Crear punto final» y, a continuación, selecciona la cadena de la red principal de Arbitrum Nova.
Una vez creado tu punto final, ten a mano la URL del proveedor HTTP, ya que la necesitarás más adelante en esta guía para configurar tu archivo .env.
Paso 2: Crear un monedero y recargarlo con ETH
Para esta guía, utilizaremos Torus Wallet, un monedero sin custodia compatible con múltiples cadenas y redes, entre las que se incluyen Ethereum, Arbitrum One, Arbitrum Nova y otras cadenas relacionadas con la EVM. Ten en cuenta que, para realizar un despliegue en la red principal de Arbitrum Nova, necesitarás disponer de fondos reales (ETH) para cubrir las comisiones de transacción. Estas comisiones deberían ser mínimas y no superar los 0,25 $. Puedes adquirir ETH en exchanges descentralizados como Uniswap o en exchanges tradicionales como Coinbase. Puedes utilizar el Arbitrum Nova Bridge para transferir fondos a Arbitrum Nova.
Para empezar, entra en Torus y sigue las instrucciones para generar una clave privada.
Antes de continuar con los aspectos técnicos de esta guía, asegúrate de que dispones de fondos suficientes en tu dirección de la red principal de Arbitrum Nova para pagar el despliegue del contrato y las interacciones. Si necesitas transferir fondos, puedes utilizar el puente de Arbitrum Nova.
Paso 3: Crear un nuevo proyecto
Para utilizar Hardhat, primero tendrás que instalar Node.js en tu ordenador. Puedes descargarlo desde la página web oficial nodejs.org.
Abre un terminal y comprueba que Node.js esté instalado y que la versión sea 18 o superior:
node -v
Accede al directorio en el que quieras crear tu proyecto. Para esta guía, crearemos una carpeta llamada «10k-collection»:
mkdir 10k-collection
Accede a la carpeta que acabas de crear y, a continuación, utiliza el siguiente comando para inicializar un nuevo proyecto npm:
npm init -y
A continuación, instala Hardhat ejecutando el siguiente comando:
npm install --save-dev hardhat
--save-dev añade esto a la lista devDependencies del archivo package.json
Ahora, vamos a inicializar un proyecto de Hardhat ejecutando el siguiente comando:
npx hardhat create
Cuando se te pregunte qué tipo de proyecto deseas crear, elige la tercera opción (es decir, «Crear un archivo de configuración de hardhat vacío»).
Esto creará un nuevo directorio con la estructura predeterminada de un proyecto de Hardhat. A continuación, tendremos que crear las carpetas necesarias para nuestra colección «10k-collection».
mkdir contratos
mkdir test
mkdir scripts
Paso 5: Instalar las bibliotecas necesarias
En el directorio del proyecto, ejecuta los siguientes comandos para instalar las dependencias necesarias del proyecto:
npm install dotenv @openzeppelin/contracts @nomicfoundation/hardhat-toolbox
Paso 6: Configura tu archivo de configuración para la implementación
Para proteger tu clave privada y la URL de RPC (en caso de que publiques tu código en GitHub), crearemos un archivo .env para almacenar las credenciales. Este archivo no debe incluirse al subir el código a GitHub.
En el directorio principal de tus proyectos, ejecuta el siguiente comando en la terminal para crear el archivo .env:
echo > .env
Abre el archivo e introduce las siguientes variables. A continuación, sustituye los valores de los marcadores de posición por tus credenciales reales. ¡No olvides guardar el archivo!
RPC_URL=<YOUR_RPC_URL>
PRIVATE_KEY=<YOUR_PRIVATE_KEY>
A continuación, configuraremos el archivo hardhat.config.js. Abre el archivo e introduce el siguiente código.
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();
module.exports = {
solidity: "0.8.17",
networks: {
nova: {
url: process.env.RPC_URL,
accounts: [process.env.PRIVATE_KEY]
}
}
};
¡No olvides guardar el archivo! En la siguiente sección, crearemos imágenes y metadatos para nuestra colección de 10 000 NFT.
Creación de metadatos y subida a IPFS
En esta sección, crearemos los metadatos de la colección de 10 000 NFT.
En concreto, utilizaremos Figma y este repositorio de GitHub para generar recursos gráficos y metadatos (¡gracias a quien lo haya creado!). Ten en cuenta que puedes utilizar otras herramientas para los metadatos, y que este no es el único método.
Para crear 10 000 NFT con imágenes diferentes, necesitarás al menos siete capas con cuatro opciones distintas. Echa un vistazo a este archivo de Figma para ver un ejemplo. Ten en cuenta que este archivo de Figma solo contiene tres capas, y las cuatro restantes ya están creadas en el repositorio que estamos utilizando. Si lo prefieres, también puedes saltarte este paso y utilizar únicamente los recursos de ejemplo que se encuentran en el repositorio de GitHub.
Una vez que hayas exportado tus recursos de imagen a tu ordenador, clona el siguiente repositorio y ábrelo en el editor de código que prefieras.
git clone https://github.com/manuelpires/nft-collection-generator/
A continuación, instala las dependencias necesarias con el siguiente comando:
npm install
Si utilizas Mac OS X y el comando de instalación anterior ha dado un error, es posible que primero tengas que instalar las siguientes bibliotecas:
brew install pkg-config, cairo, pango, libpng, jpeg, giflib, librsvg, pixman
& a continuación, instala canvas:
npm i canvas
Ahora, crea dos carpetas: «metadata » e «images»:
mkdir metadata && mkdir images
A continuación, accede al directorio «traits» y crea carpetas para cada capa. En nuestro ejemplo, hemos creado una carpeta para flechas, otra para círculos y otra para estrellas.
NOTA: Omite este paso y pasa directamente a ejecutar el comando «node index.js» si solo vas a utilizar las imágenes de ejemplo que ya se encuentran en la carpeta «traits».
A continuación, abre el archivo config.js y añade cada capa al objeto ORDERED_TRAITS_LIST. Un ejemplo quedaría así:
{
type: "Square",
options: [
{
image: "./traits/square/bright-coral.png",
value: "Bright Coral",
weight: 1,
},
{
image: "./traits/square/liliac.png",
value: "Liliac",
weight: 1,
},
{
image: "./traits/square/pumpkin.png",
value: "Pumpkin",
weight: 1,
},
{
image: "./traits/square/spring.png",
value: "Spring",
weight: 1,
},
{
weight: 1,
},
],
},
Ten en cuenta que las capas se añaden por orden, así que presta atención al orden en que las utilices. La opción «weight» es relativa a los pesos de los demás elementos del mismo array de opciones, y debe ser un número entero de al menos 1. Si asignas un peso de 10 a una opción, esta tendrá diez veces más posibilidades de ser seleccionada que una opción del mismo array con un peso igual a 1.
Una vez que hayas configurado el archivo config.js con todos tus metadatos y referencias a imágenes, y se hayan instalado las dependencias necesarias, genera los metadatos y las imágenes ejecutando el siguiente comando:
nodo index.js
Una vez creadas las imágenes y los metadatos, dedica unos minutos a revisarlos para asegurarte de que se han generado según lo previsto. Cuando subamos las imágenes y los metadatos a IPFS, tendremos que sustituir la URL base por nuestro enlace de metadatos real, así que ten esta carpeta a mano.
Publicación de metadatos e imágenes en IPFS
Ahora que ya hemos creado nuestros metadatos e imágenes, tendremos que subirlos a IPFS, un protocolo, hipermedia y red peer-to-peer para compartir archivos, destinada a almacenar y compartir datos en un sistema de archivos distribuido. Utilizaremos IPFS en lugar de una solución de almacenamiento centralizada (como Amazon) debido a sus propiedades descentralizadas, con las que queremos que nuestra colección de NFT esté en consonancia. Sin embargo, ten en cuenta que, aunque el uso de IPFS es gratuito, en ocasiones puede resultar lento, y tendrás que mantener tu contenido «anclado» de forma activa (es decir, mantener tu nodo IPFS en funcionamiento) para que tus metadatos sigan siendo recuperables.
Como alternativa, también puedes utilizar servicios como Pinata (con versiones gratuitas y de pago) o NFT.Storage (gratuito, pero con almacenamiento limitado) para subir datos fácilmente a IPFS y mantener tu contenido fijado y más rápido de recuperar; sin embargo, tienen límites de almacenamiento y pueden ser de pago.
En cualquier caso, debes subir tus metadatos a una carpeta de modo que todos los archivos de ese directorio tengan la misma ruta raíz.
Por ejemplo:
https://ipfs.io/ipfs/bafybeidhtkrvmboa4pel3i3asl57rgmrtai4zelpoeccfulw7qxqbhwyw4/metadata/
La URL anterior apunta a una carpeta en IPFS que contiene los archivos con los metadatos de los NFT. También puedes añadir un número al final de la ruta (por ejemplo, /metadata/1) para ver los metadatos de cada NFT individual. Es importante que estos datos estén estandarizados para que a las aplicaciones les resulte más fácil mostrar tus NFT e interactuar con ellos.
En primer lugar, instalaremos IPFS utilizando el siguiente enlace. Se puede acceder a IPFS de varias formas; sin embargo, lo instalaremos mediante el binario de Kubo.
A continuación, abre una nueva ventana de terminal (CMD + T en Mac) y comprueba si IPFS está instalado:
ipfs --versión
A continuación, pondremos en marcha el nodo IPFS que utilizaremos para conectarnos a la red IPFS y mantenerlo activo de forma permanente.
ipfs init
Deberías ver algo como esto:
Inicializando el nodo IPFS en /Users/user/.ipfs
> Generando un par de claves RSA de 2048 bits... Hecho
> Identidad del nodo: Qmcpo2iLBikrdf1d6QU6vXuNb6P7hwrbNPW9kLAH8eG67z
> Para empezar, escribe:
>
> ipfs cat /ipfs/QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG/readme
Para poner en funcionamiento nuestro nodo IPFS, ejecuta el siguiente comando:
demonio IPFS
Anota los puertos TCP en los que el demonio está a la escucha
A continuación, abre otra ventana de terminal. Si estás conectado a la red, deberías poder ver las direcciones IPFS de tus pares al ejecutar el siguiente comando:
Nodos de Swarm de IPFS
Puedes comprobar si tu IPFS puede solicitar datos a la red ejecutando el siguiente comando:
ipfs cat /ipfs/QmSgvgwxZGaBLqkGyWemEDqikCqU52XxsYLKtdy3vGZ8uq > ~/Escritorio/spaceship-launch.jpg
Si has podido descargar la imagen, ¡genial! Ahora ya podemos subir nuestras imágenes y metadatos a IPFS.
En el directorio raíz de tu proyecto, ejecuta el siguiente comando de IPFS para fijar la carpeta «images»:
ipfs add -r images/
La última línea de la salida mostrará el CID del directorio raíz, que es el directorio de nivel superior de la carpeta que has subido. Puedes acceder a la carpeta en esta dirección IPFS añadiendo el CID al final de la URL de la pasarela IPFS«https://ipfs.io/ipfs/».
Ahora que ya hemos subido nuestras imágenes, copia el hash CID de tu carpeta raíz «images/» y vuelve al repositorio de nft-collection-generator. Utiliza el siguiente comando de terminal para sustituir de una sola vez todas las URL provisionales por la URL real de tu imagen:
find metadata -type f -exec perl -pi -e 's#https://base-uri-to-my-nft-images.com/#https://ipfs.io/ipfs/{CID}/#g' {} +
Recuerda sustituir el {CID} ¡Sustituye en el comando anterior el hash CID de IPFS de tu carpeta «images/»!
Al final, el contenido de tus archivos de metadatos debería tener este aspecto:
{
"tokenId": 0,
"name": "KT0",
"description": "KT Collection",
"image": "https://ipfs.io/ipfs/Qma5p2daHfdui4keZjMrJpgmL7JRjoZ6J5GcyLPUcmTTuT/0.png",
"attributes": [
{
"trait_type": "Background",
"value": "Robin"
},
{
"trait_type": "Square",
"value": "Spring"
},
{
"trait_type": "Triangle",
"value": "Green"
},
{
"trait_type": "Circle",
"value": "Blue"
},
{
"trait_type": "Arrows",
"value": "Up"
}
]
}
A continuación, tendremos que agrupar nuestros metadatos (archivos JSON) en un archivo .CAR (Content-Addressed Archive). Para ello, puedes utilizar el comando «ipfs car ».
Ejecuta el siguiente comando para crear un archivo CAR que contenga los archivos JSON:
npx ipfs-car --pack metadata/
Es posible que se te pida que instales la biblioteca externa
Ahora que nuestro JSON está empaquetado en un archivo .CAR, lo fijaremos en IPFS mediante el siguiente comando:
ipfs dag import metadata.car
Deberías ver una respuesta similar a:
Raíz fijada bafybeihzssbfdo6cmprolorfimhda4yapkzkyukffsteta6exwcr4nipzi éxito
Puedes comprobar que tus metadatos están accesibles accediendo al CID al que hace referencia tu archivo subido. Recuerda añadir la ruta /metadata/ al final de la URL:
https://ipfs.io/ipfs/{CID}/metadata/
You can also access the IPFS URL through your local IPFS node (daemon). Depending on the state of the network, curl may take a while due to public gateways being overloaded or having a hard time reaching you. To view the objects on your local gateway, try "http://127.0.0.1:8080/ipfs/{CID}". For the public gateway, use https://ipfs.io/ipfs/{CID}.
Ten en cuenta que debes utilizar el verificador de puertas de enlace de IPFS para ver cuáles son las puertas de enlace más rápidas en este momento.
¡En la siguiente sección, desarrollarás tu contrato NFT!
Crear el contrato NFT
Crea un nuevo archivo llamado NFT.sol en el directorio «contracts».
Abre el archivo e introduce el siguiente código:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
// Contract for creating 10k tokens, inherits from ERC721 and Ownable
contract KTokens is ERC721, Ownable {
// Max supply
uint256 public constant MAX_SUPPLY = 10000;
// Current supply
uint256 public totalSupply = 0;
// Use Counters library for token ID counter
using Counters for Counters.Counter;
// Private variable to keep track of token ID
Counters.Counter private _tokenIdCounter;
// Constructor to initialize the contract with the name "10K Tokens" and symbol "10KT"
constructor() ERC721("10K Tokens", "10KT") {}
// Internal function to return the base URI for the contract
function _baseURI() internal pure override returns (string memory) {
return "https://ipfs.io/ipfs/{CID}/metadata/";
}
// Function to mint a new token, only callable by the contract owner
function safeMint(address to) public onlyOwner {
//Require that the current supply is less than max supply
require(totalSupply <= MAX_SUPPLY, "Maximum supply reached");
//Increment total supply variable
totalSupply++;
// Get the current token ID
uint256 tokenId = _tokenIdCounter.current();
// Increment the token ID counter
_tokenIdCounter.increment();
// Mint the token to the specified address
_safeMint(to, tokenId);
}
}
Tómate unos minutos para revisar los comentarios del código y comprender mejor la lógica.
Aunque no aparece aquí, la función `tokenURI` se hereda del contrato ` ERC721.sol ` que importamos de OpenZeppelin. Esta función de solo lectura toma un `tokenId` y devuelve la URL que debería apuntar a los metadatos de ese token concreto.
You'll need to edit the placeholder (https://ipfs.io/ipfs/{CID}) in the _baseURI() function with the CID you obtained when uploading your metadata directory. This CID or URL, if you are not using IPFS, should point to the directory your metadata lives in. Remember to save the file before moving to the next step!
A continuación, tendrás que compilar el contrato NFT. Esto implica compilar el código Solidity en bytecode, que luego se implementa en la cadena de bloques.
Para compilar el contrato, ejecuta el siguiente comando de Hardhat:
npx hardhat compile
Deberías ver un mensaje similar a este:
Se han compilado correctamente 13 archivos Solidity
En la siguiente sección, crearemos pruebas para el contrato NFT con el fin de asegurarnos de que todo vaya bien al implementarlo en la red principal de Arbitrum Nova.
Probar el contrato NFT
En esta sección, crearemos pruebas para comprobar el comportamiento de nuestro contrato NFT. Probar nuestro NFT es importante porque permite a los desarrolladores asegurarse de que sus contratos inteligentes funcionan según lo previsto y no contienen errores antes de su implementación en la cadena de bloques. Esto es fundamental, ya que, una vez implementado un contrato, no se puede modificar ni eliminar, por lo que cualquier error o problema será permanente. Además, las pruebas pueden ayudar a prevenir posibles vulnerabilidades de seguridad en el contrato, que podrían ser aprovechadas por actores malintencionados.
En el directorio «tests», crea un archivo llamado NFT.js e introduce el siguiente código:
const { expect } = require("chai");
describe("KTokens", () => {
let kTokens;
let owner;
beforeEach(async function () {
// Retrieve the default account from ethers
[owner] = await ethers.getSigners();
// A helper to get the contracts instance and deploy it locally
const KTokens = await ethers.getContractFactory("KTokens");
kTokens = await KTokens.deploy();
});
it("should have the correct name and symbol", async () => {
expect(await kTokens.name()).to.equal("10K Tokens");
expect(await kTokens.symbol()).to.equal("10KT");
});
it("should be able to mint new tokens", async () => {
// Mint a new token
await kTokens.safeMint(owner.address);
expect(await kTokens.ownerOf(0)).to.equal(owner.address);
});
});
Tómate unos minutos para revisar los comentarios del código y comprender mejor la lógica.
Para ejecutar el archivo de prueba, ejecuta el siguiente comando:
npx hardhat test
Deberías ver el siguiente resultado:
KTokens
✔ deben tener el nombre y el símbolo correctos
✔ deben poder acuñar nuevos tokens
2 aprobados (1s)
¡En la siguiente sección, vamos a publicar la colección de 10 000 NFT en Arbitrum Nova!
Implementar el contrato NFT
En tu carpeta de scripts, crea un archivo llamado deploy.js:
echo > scripts/deploy.js
A continuación, abre el archivo e introduce el siguiente código:
const hre = require("hardhat");
async function deploy() {
// Deploy the contract
const NFT = await hre.ethers.getContractFactory("KTokens");
const nft = await NFT.deploy();
// Print the deployed contracts address
console.log("NFT contract deployed at:", nft.address);
}
deploy()
.then(() => console.log("Deployment complete"))
.catch((error) => console.error("Error deploying contract:", error));
Este archivo contendrá la lógica necesaria para desplegar nuestro contrato en la red principal de Arbitrum Nova.
Para implementar el contrato, ejecuta el siguiente comando de Hardhat en tu terminal:
npx hardhat run --network nova scripts/deploy.js
El
novaEl objeto es el que hemos creado en hardhat.config.js
Deberías ver un resultado que contenga la dirección de tu contrato desplegado.
Contrato NFT desplegado en: 0xf18802cb61EF336E30c5B93a7c9C961b1e80BeDE
Despliegue completado
Crea el NFT y visualízalo en un mercado de NFT
Ahora que nuestro contrato NFT ya está implementado, vamos a acuñar un NFT y a verlo en un mercado de NFT. A efectos de esta guía, solo acuñaremos un NFT, pero puedes seguir el mismo proceso para acuñar varios NFT.
Crea un archivo «mint.js » en tu carpeta «scripts »:
echo > scripts/mint.js
A continuación, abre el archivo e introduce el siguiente código:
const hre = require("hardhat");
async function main() {
let owner;
// Retrieve the default account from ethers
[owner] = await ethers.getSigners();
// Get contract factory for the NFT contract
const NFT = await ethers.getContractFactory("KTokens");
// Attach to deployed contract at the specified address
const nft = await NFT.attach(
"DEPLOYED_CONTRACT_ADDRESS" // Your deployed contract address
);
// Call the safeMint function to update the value
let safeMintTx = await nft.safeMint(owner.address)
console.log("safeMint function call. Waiting for confirmation...")
// Wait 3 blocks for the transaction to be confirmed
await safeMintTx.wait(confirm=3);
// Get the latest total Supply
let tokenSupply = (await nft.totalSupply()).toString()
//Decrease by one since tokenID starts at zero
let tokenIdInt = parseInt(tokenSupply) - 1
//Get owner of minted tokenID
let tokenOwner = await nft.ownerOf(tokenIdInt);
console.log(`Token ID ${tokenId} - tokenOwner ${tokenOwner}`)
}
// Start the script and handle any errors
main()
.then(() => console.log("Script complete"))
.catch((error) => console.error("Error running script:", error));
Una vez acuñado, puedes ir a un mercado de NFT como tofuNFT.com —un mercado de NFT multicadena compatible con Arbitrum Nova— e introducir la dirección de tu monedero para ver el NFT.
Si te interesa saber cómo acuñar 10 000 tokens de una sola vez, echa un vistazo a esta guía sobre «Cómo acuñar NFT utilizando la implementación ERC721A».
Ecosistema de Arbitrum
Ahora que ya has desplegado tu primer contrato inteligente en Arbitrum Nova, puedes explorar algunos de los recursos que ofrece la cadena de Arbitrum Nova:
- Arbitrum Nova Bridge
- Explorador de bloques de Arbitrum Nova
- Documentación de Arbitrum Nova
- Portal de Arbitrum
Recursos adicionales
Si quieres seguir aprendiendo sobre Arbitrum Nova y los contratos inteligentes, echa un vistazo a estos recursos:
- Documentación para desarrolladores de Quicknode Arbitrum Nova
- Guías para el desarrollo de contratos inteligentes
- Quicknode y Arbitrum Nova
Conclusión
¡Enhorabuena! ¡Ya tienes los conocimientos necesarios para lanzar una colección de 10 000 NFT!
¿Para qué utilizas Arbitrum Nova? ¡Nos encantaría ver lo que estás creando! Comparte tu aplicación con nosotros en Discord o Twitter. Si tienes algún comentario o pregunta sobre esta guía, ¡nos encantaría que nos lo hicieras saber!