Ir a la página de inicio
Home / Posts
Compartir en Twitter
Go to Homepage

CÓMO CREAR UN NFT DESDE CERO EN 2025

November 26, 2025

Introducción a la Creación de NFTs

Los tokens no fungibles (NFTs) han transformado la forma en que se percibe la propiedad digital, permitiendo a creadores monetizar activos únicos como arte, música o coleccionables en blockchain. Este tutorial te guiará paso a paso para crear un NFT desde cero, utilizando herramientas modernas y tecnologías accesibles en 2025. Cubriremos desde la configuración del entorno hasta el despliegue en una blockchain como Ethereum, con ejemplos prácticos y código. No se requieren conocimientos avanzados, pero se asume familiaridad básica con programación y conceptos de blockchain.

¿Qué es un NFT?

Un NFT es un token único almacenado en una blockchain, que certifica la propiedad y autenticidad de un activo digital. A diferencia de criptomonedas como Bitcoin, los NFTs son indivisibles y cada uno tiene metadatos únicos. Por ejemplo, un NFT puede representar una obra de arte digital con detalles como el creador, la fecha de creación y un enlace a su archivo multimedia.

Los NFTs se crean mediante contratos inteligentes, típicamente en Ethereum, usando el estándar ERC-721 o ERC-1155. Estos contratos definen funciones para acuñar (mint), transferir y gestionar tokens. En este tutorial, usaremos ERC-721 para crear un NFT simple.

Requisitos Previos

Antes de comenzar, asegúrate de tener lo siguiente:

  • Node.js (versión 18 o superior) y npm instalados.
  • Un editor de código como Visual Studio Code.
  • Una billetera de criptomonedas como MetaMask.
  • Conocimientos básicos de JavaScript y Solidity.
  • Acceso a una red de prueba como Sepolia para pruebas en Ethereum.

Instala las herramientas necesarias ejecutando:

npm install -g truffle
npm install -g ganache-cli

Truffle es un marco de desarrollo para Ethereum, y Ganache proporciona una blockchain local para pruebas.

Configuración del Entorno de Desarrollo

Crea un directorio para tu proyecto e inicializa un proyecto Truffle:

mkdir MiNFT
cd MiNFT
truffle init

Esto genera una estructura de directorios:

MiNFT/
├── contracts/
├── migrations/
├── test/
├── truffle-config.js

El directorio contracts/ almacenará los contratos inteligentes, migrations/ los scripts de despliegue, y test/ las pruebas unitarias.

Instala la biblioteca OpenZeppelin para usar plantillas de contratos ERC-721:

npm install @openzeppelin/contracts

Creación del Contrato Inteligente

En el directorio contracts/, crea un archivo llamado MiNFT.sol con el siguiente código:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MiNFT is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("MiNFT", "MNFT") {}

    function mintNFT(address recipient, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, tokenURI);
        return newItemId;
    }
}

Este contrato hereda de ERC721 de OpenZeppelin y usa un contador para asignar IDs únicos a los NFTs. La función mintNFT permite acuñar un NFT, asignándolo a una dirección y asociándolo con un URI de metadatos.

Configuración de Metadatos

Los metadatos de un NFT son un archivo JSON que describe sus atributos, como nombre, descripción e imagen. Un ejemplo de metadatos:

{
    "name": "Mi Primer NFT",
    "description": "Un NFT único creado en 2025",
    "image": "https://mi-servidor.com/imagen.png",
    "attributes": [
        {
            "trait_type": "Color",
            "value": "Azul"
        }
    ]
}

Almacena este archivo en un servidor accesible, como IPFS o un servidor centralizado, y obtén su URI (por ejemplo, https://mi-servidor.com/metadata.json). Este URI se pasará a la función mintNFT.

Para usar IPFS, instala el cliente ipfs-http-client:

npm install ipfs-http-client

Sube el archivo JSON a IPFS:

const { create } = require("ipfs-http-client");
const ipfs = create({ host: "ipfs.infura.io", port: 5001, protocol: "https" });

async function uploadToIPFS(file) {
    const added = await ipfs.add(file);
    return `https://ipfs.infura.io/ipfs/${added.path}`;
}

const metadata = JSON.stringify({
    name: "Mi Primer NFT",
    description: "Un NFT único creado en 2025",
    image: "https://mi-servidor.com/imagen.png",
});

uploadToIPFS(metadata).then((uri) => console.log(uri));

Configuración de la Migración

Crea un archivo en migrations/ llamado 2_deploy_contracts.js:

const MiNFT = artifacts.require("MiNFT");

module.exports = function (deployer) {
    deployer.deploy(MiNFT);
};

Este script despliega el contrato MiNFT en la blockchain.

Actualiza truffle-config.js para usar la red de prueba Sepolia:

const HDWalletProvider = require("@truffle/hdwallet-provider");
const mnemonic = "tu-frase-semilla-de-12-palabras";

module.exports = {
    networks: {
        sepolia: {
            provider: () =>
                new HDWalletProvider(
                    mnemonic,
                    "https://sepolia.infura.io/v3/tu-api-key"
                ),
            network_id: 11155111,
            gas: 5500000,
            confirmations: 2,
            timeoutBlocks: 200,
            skipDryRun: true,
        },
    },
    compilers: {
        solc: {
            version: "0.8.0",
        },
    },
};

Obtén una frase semilla de MetaMask y una clave API de Infura para conectar con Sepolia.

Despliegue en la Red de Prueba

Inicia Ganache para una blockchain local:

ganache-cli

Despliega el contrato localmente:

truffle migrate

Para desplegar en Sepolia, ejecuta:

truffle migrate --network sepolia

La salida mostrará la dirección del contrato desplegado:

Deploying 'MiNFT'
------------------
> transaction hash:    0x...
> contract address:    0x...

Guarda la dirección del contrato para interactuar con él.

Acuñación del NFT

Crea un script para acuñar un NFT. En el directorio scripts/, crea mint.js:

const MiNFT = artifacts.require("MiNFT");

module.exports = async function (callback) {
    const miNFT = await MiNFT.deployed();
    const tokenURI = "https://mi-servidor.com/metadata.json";
    const tx = await miNFT.mintNFT("tu-direccion-de-billetera", tokenURI);
    console.log("NFT acuñado con ID:", tx.logs[0].args.tokenId.toString());
    callback();
};

Ejecuta el script:

truffle exec scripts/mint.js --network sepolia

Esto acuñará un NFT y lo asignará a tu billetera. Verifica en MetaMask o un explorador de bloques como Etherscan.

Publicación en un Mercado NFT

Para vender tu NFT, súbelo a un mercado como OpenSea. Conecta tu billetera MetaMask al sitio, selecciona la red Sepolia (para pruebas) y crea un nuevo ítem. Ingresa la dirección del contrato y el ID del token acuñado. OpenSea detectará los metadatos automáticamente si el URI es válido.

Por ejemplo, en OpenSea:

  1. Ve a “Create” > “Item”.
  2. Ingresa la dirección del contrato (0x...).
  3. Ingresa el ID del token (por ejemplo, 1).
  4. Configura el precio y otros detalles.

Una vez publicado, tu NFT estará disponible para la venta.

Pruebas del Contrato

Escribe pruebas para asegurar que el contrato funcione correctamente. En test/, crea MiNFT.test.js:

const MiNFT = artifacts.require("MiNFT");

contract("MiNFT", (accounts) => {
    it("debería acuñar un NFT", async () => {
        const miNFT = await MiNFT.deployed();
        const tokenURI = "https://mi-servidor.com/metadata.json";
        await miNFT.mintNFT(accounts[0], tokenURI);
        const owner = await miNFT.ownerOf(1);
        assert.equal(owner, accounts[0], "El propietario no es correcto");
    });
});

Ejecuta las pruebas:

truffle test

La salida confirmará si el NFT se acuñó correctamente:

Contract: MiNFT
    ✓ debería acuñar un NFT (123ms)

Optimización de Costos

Desplegar contratos en Ethereum puede ser costoso debido a las tarifas de gas. Para optimizar:

  • Usa redes de prueba como Sepolia para experimentos.
  • Considera blockchains alternativas como Polygon o Binance Smart Chain, que tienen tarifas más bajas.
  • Minimiza las operaciones en el contrato, como evitar bucles innecesarios en Solidity.

Por ejemplo, en Polygon, configura truffle-config.js con un proveedor como:

polygon: {
  provider: () => new HDWalletProvider(mnemonic, "https://rpc-mumbai.maticvigil.com"),
  network_id: 80001,
  gas: 5500000
}

Seguridad en Contratos Inteligentes

La seguridad es crítica al desarrollar contratos inteligentes. Algunos consejos:

  • Usa bibliotecas probadas como OpenZeppelin.
  • Evita funciones que permitan accesos no autorizados, como mintNFT sin restricciones.
  • Realiza auditorías con herramientas como Mythril o Slither.

Por ejemplo, para limitar quién puede acuñar NFTs, modifica el contrato:

address private owner;

constructor() ERC721("MiNFT", "MNFT") {
    owner = msg.sender;
}

modifier onlyOwner() {
    require(msg.sender == owner, "Solo el propietario puede acuñar");
    _;
}

function mintNFT(address recipient, string memory tokenURI)
    public
    onlyOwner
    returns (uint256)
{
    // Código existente
}

Escalando tu Proyecto NFT

Una vez que tengas un NFT funcional, puedes escalar tu proyecto:

  • Crea una colección con múltiples NFTs.
  • Integra un frontend en React para que los usuarios acuñen NFTs directamente.
  • Añade funcionalidades como royalties para recibir un porcentaje de ventas secundarias.

Por ejemplo, para royalties, usa el estándar ERC-2981:

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";

contract MiNFT is ERC721, ERC721Royalty {
    constructor() ERC721("MiNFT", "MNFT") {
        _setDefaultRoyalty(msg.sender, 1000); // 10% de royalty
    }
}

Conclusiones

Crear un NFT en 2025 es un proceso accesible gracias a herramientas como Truffle, OpenZeppelin y redes de prueba como Sepolia. Este tutorial te ha guiado desde la configuración del entorno hasta la publicación en un mercado, con ejemplos de código en Solidity, JavaScript y JSON. Los NFTs ofrecen oportunidades únicas para creadores y desarrolladores, pero requieren atención a la seguridad y los costos de gas. Experimenta en redes de prueba, optimiza tus contratos y explora blockchains alternativas para maximizar el potencial de tus proyectos. Con práctica, puedes desarrollar colecciones complejas y aplicaciones descentralizadas innovadoras.