11 minutos de lectura

Resumen

Acuñar 10 000 NFT con una «Candy Machine» es divertido, pero hay muchos casos en los que puede que necesitemos acuñar un solo NFT (por ejemplo, una obra de arte «1 de 1», música, etc.). Metaplex, la organización que creó el estándar de metadatos de Solana, ha desarrollado recientemente unos prácticos SDK de JavaScript que facilitan la creación de un NFT desde tu terminal.

Tus funciones

En esta guía, acuñarás un NFT con metadatos en la red de desarrollo de Solana desde tu terminal utilizando las bibliotecas Metaplex Umi JS. Repasaremos tres pasos clave para la acuñación de NFT:

1. Subir una imagen
2. Subir metadatos
3. NFT de Mint

Lo que necesitarás

• Node.js (versión 16.15 o superior) instalado
• Experiencia con TypeScript y ts-node instalado

Información general sobre los NFT de Solana

Antes de crear nuestra aplicación, hablemos de los NFT y de la arquitectura de NFT de Solana. ¿Qué demonios es un NFT? Un token no fungible es, en esencia, un conjunto de datos almacenado en la cadena que es único y diferente de cualquier otro. En resumen, solo hay uno. En Solana, lo conseguimos utilizando el Programa de Tokens SPL y creando un token con un suministro de 1. Además, los NFT no se pueden subdividir, lo que significa que no se puede tener un tercio de un NFT (nota: existen algunos protocolos avanzados de NFT relacionados con la fraccionalización, pero normalmente un NFT no se puede dividir en unidades más pequeñas). En Solana, también lo conseguimos utilizando el Programa de tokens SPL al establecer los decimales en 0 (lo que significa que no se puede fraccionar).

Aunque crear un token SPL con un suministro de 1 y 0 decimales es, técnicamente, un NFT definido por su ID de acuñación único, el programa de tokens SPL presenta limitaciones en cuanto a algunos de los tipos y la cantidad de datos que se pueden almacenar. Aquí entra en juego Metaplex. El programa de metadatos de Metaplex establece un estándar para los metadatos tanto dentro como fuera de la cadena. A través de una dirección derivada del programa (Program Derived Address) asociada a la cuenta de acuñación, Metaplex permite a los usuarios asignar metadatos más detallados a una acuñación (por ejemplo, nombre, descripción, mutabilidad, comisiones del vendedor, etc.). Un campo destacado en los metadatos de Metaplex es el denominado «URI». Se trata de una dirección que apunta a metadatos específicos fuera de la cadena. Debido a las comisiones de alquiler y a las limitaciones de velocidad, Metaplex prevé que ciertos datos se almacenen fuera de la cadena (por ejemplo, imagen/URI de la imagen, rasgos o características del NFT). La siguiente figura de Metaplex ilustra las relaciones entre estos campos:

Fuente: *https://docs.metaplex.com/programs/token-metadata/overview
*

En esta guía, primero subiremos nuestra imagen a Arweave y obtendremos su URI; a continuación, crearemos los metadatos fuera de cadena y los subiremos a Arweave; y, por último, acuñaremos nuestro token y definiremos los metadatos en cadena que apunten a nuestros metadatos fuera de cadena.

Configura tu proyecto

Crea un nuevo directorio de proyecto en tu terminal con:

mkdir mint-nft
cd mint-nft

Crea un archivo para tu aplicación, app.ts:

echo > app.ts

Inicializa tu proyecto con el indicador «yes» para utilizar los valores predeterminados en tu nuevo paquete:

hilo init --sí
#o
npm init --yes

Crea un archivo tsconfig.json con la importación de .json habilitada:

tsc -init --resolveJsonModule true

Por último, crea una carpeta para tus archivos subidos:

mkdir uploads

Guarda una imagen (.png o .jpg) en esta carpeta con el nombre «image.png». Vamos a utilizar esta belleza pixelada:

Instalar la dependencia de Solana Web3

Para este ejercicio, tendremos que añadir las bibliotecas Solana Web3 y SPL Token. Además, utilizaremos el SDK de JS de Metaplex y las bibliotecas de metadatos de tokens MPL. Escribe en tu terminal:

hilo añadir @metaplex-foundation/umi @metaplex-foundation/umi-bundle-defaults @metaplex-foundation/mpl-token-metadata @metaplex-foundation/umi-storage-mock
#o
npm instalar @metaplex-foundation/umi @metaplex-foundation/umi-bundle-defaults @metaplex-foundation/mpl-token-metadata @metaplex-foundation/umi-storage-mock

Crea un monedero y recibe SOL mediante airdrop

Tendrás que crear una cartera de Solana File System (con el par de claves guardado en un archivo wallet.json ) y recibir un airdrop de SOL en ella. Desde tu terminal, escribe:

solana-keygen new --silencioso --no-bip39-passphrase --archivo de salida wallet.json

Esto creará un nuevo monedero y lo guardará en un archivo llamado wallet.json. A continuación, podrás recibir SOL mediante airdrop en este monedero utilizando el grifo de Quicknode o el grifo de Solana. Para obtener la dirección de tu monedero, escribe:

dirección de Solana -k wallet.json

Cuando hayas terminado, deberías poder ver el saldo de tu monedero en:

saldo de Solana -ud -k wallet.json

Si el saldo sigue siendo 0, vuelve a probar el grifo. Necesitarás unos 0,1 SOL de Devnet antes de continuar con los siguientes pasos.

Configura tu aplicación

Importar las dependencias necesarias

Abre el archivo app.ts y pega las siguientes importaciones en la línea 1:

import { createNft, mplTokenMetadata } from '@metaplex-foundation/mpl-token-metadata'
import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
import { createGenericFile, createSignerFromKeypair, generateSigner, keypairIdentity, percentAmount, sol } from '@metaplex-foundation/umi';
import { mockStorage } from '@metaplex-foundation/umi-storage-mock';
import * as fs from 'fs';
import secret from './wallet.json';

Además de la cartera que hemos creado en el paso anterior, también vamos a importar algunos métodos y clases esenciales de las bibliotecas de Metaplex Umi. Asimismo, dado que vamos a subir archivos desde nuestro sistema, necesitamos importar fs, la biblioteca del sistema de archivos.

Configura tu punto de acceso de Quicknode

Para desarrollar en Solana, necesitarás un punto final de API para conectarte a la red. Puedes utilizar nodos públicos o implementar y gestionar tu propia infraestructura; sin embargo, si quieres tiempos de respuesta 8 veces más rápidos, puedes dejarnos a nosotros el trabajo pesado.

Descubre por qué más del 50 % de los proyectos de Solana eligen Quicknode y regístrate aquí para crear una cuenta. Vamos a utilizar un nodo de Solana Devnet.

Copia el enlace del proveedor HTTP:

En el archivo app.ts, debajo de las declaraciones de importación, declara tu RPC y establece la conexión con Solana iniciando una nueva instancia de Umi:

const QUICKNODE_RPC = 'https://example.solana-devnet.quiknode.pro/0123456/'; //Sustituye por tu punto final RPC de Quicknode
const umi = createUmi(QUICKNODE_RPC); 

Declarar variables

Tendrás que hacer un par de cosas antes de poder ejecutar tu script:

• Define tu firmante de contenido compatible con Umi
• Configura tu instancia de Umi
• Define los metadatos de tu NFT

Añade las siguientes declaraciones debajo de la declaración de Umi para definir tu creador y configurar tu instancia de Umi:

const creatorWallet = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(clave secreta));
const creador = createSignerFromKeypair(umi, carteraDelCreador);
umi.use(identidad del par de claves(creator));
umi.uso(mplTokenMetadata());
umi.uso(mockStorage());

Definir las características de los NFT

Crearemos un nftDetail objeto que contiene algunos metadatos que queremos incluir en nuestro NFT. Crea una nueva constante, nftDetail, e incluyen los siguientes atributos:

const nftDetail = {
    name: "Quicknode Pixel",
    symbol: "QP",
    uri: "IPFS_URL_OF_METADATA",
    royalties: 5.5,
    description: 'Pixel infrastructure for everyone!',
    imgType: 'image/png',
    attributes: [
        { trait_type: 'Speed', value: 'Quick' },
    ]
};

No dudes en utilizar tus propios valores aquí.

Sube tu imagen

Antes de nada, tendremos que subir la imagen que vamos a utilizar para nuestro NFT a una plataforma de almacenamiento descentralizada. Esto se debe a que debemos incluir el URI de la imagen del NFT en los metadatos del mismo. Si ya dispones de una imagen alojada con un URI, no dudes en definir ese valor en tu principal función y omite este paso.

Para subir nuestra imagen, utilizaremos el programa de subida de Umi. El programa de subida de Umi es una forma sencilla de subir archivos a Arweave, IPFS u otras plataformas de almacenamiento descentralizadas. Utilizaremos fs para crear un búfer de imagen y, a continuación, subirla mediante el programa de subida de Umi. Añade la siguiente función a tu app.ts archivo:

async function uploadImage(): Promise<string> {
    try {
        const imgDirectory = './uploads';
        const imgName = 'image.png'
        const filePath = `${imgDirectory}/${imgName}`;
        const fileBuffer = fs.readFileSync(filePath);
        const image = createGenericFile(
            fileBuffer,
            imgName,
            {
                uniqueName: nftDetail.name,
                contentType: nftDetail.imgType
            }
        );
        const [imgUri] = await umi.uploader.upload([image]);
        console.log('Uploaded image:', imgUri);
        return imgUri;
    } catch (e) {
        throw e;
    }

}

Interfaz de Umi Uploader

Si has prestado mucha atención a la instalación de las dependencias y a las importaciones que hemos visto antes, quizá te hayas dado cuenta de que estamos utilizando un paquete llamado @metaplex-foundation/umi-storage-mock. Como su nombre indica, se trata de un sistema de almacenamiento simulado que nos permite probar nuestro código sin tener que subir realmente archivos a una plataforma de almacenamiento descentralizada. Esto resulta útil para realizar pruebas y depurar el código (¡y su uso no cuesta nada!). Una de las grandes ventajas de Umi es que incluye genéricos primitivos para el almacenamiento (y otras operaciones comunes) que pueden sustituirse fácilmente por sistemas de almacenamiento reales como Arweave o IPFS. Esto se hace a través del Interfaz de subida de archivos. Esto significa que puedes sustituir el almacenamiento simulado por otro complemento con una simple importación y un cambio en la configuración. Aquí tienes una lista de la alternativa actual Interfaz de subida de archivos opciones. Lo único que tienes que hacer es importar el paquete correspondiente y cambiar el umi.use(mockStorage()) línea a umi.use(newStoragePlugin()).

¡Qué guay!

Subir metadatos

Los metadatos son, en cierto modo, lo que hace que tu NFT sea especial. Incluyen la imagen, cualquier rasgo distintivo, la asignación a una colección, etc. Utilizaremos un método de carga similar al que usamos con nuestra imagen en el paso anterior, pero existe un método especial para gestionar archivos .json. Añade la siguiente función a tu archivo app.ts:

async function uploadMetadata(imageUri: string): Promise<string> {
    try {
        const metadata = {
            name: nftDetail.name,
            description: nftDetail.description,
            image: imageUri,
            attributes: nftDetail.attributes,
            properties: {
                files: [
                    {
                        type: nftDetail.imgType,
                        uri: imageUri,
                    },
                ]
            }
        };
        const metadataUri = await umi.uploader.uploadJson(metadata);
        console.log('Uploaded metadata:', metadataUri);
        return metadataUri;
    } catch (e) {
        throw e;
    }
}

Aquí estamos creando un objeto JSON con los metadatos que queremos incluir en nuestro NFT. A continuación, subimos este objeto JSON mediante el programa de subida de Umi, uploadJson método. El objeto de metadatos incluye el nombre, la descripción, el URI de la imagen, los atributos y las propiedades de nuestro NFT. Puedes modificarlo ligeramente, pero asegúrate de que cumpla con el Estándar de metadatos Metaplex para NFT.

NFT de Mint

Al igual que nuestras funciones anteriores, la API de Metaplex simplifica este proceso y nos permite acuñar nuestro NFT con un único método: ` createNft`. A diferencia de los metadatos del paso anterior, en este último paso debemos proporcionar algunos metadatos que se almacenarán directamente en la cadena de Solana.

Después de la función `uploadMetadata() ` y antes de `main()`, crea una nueva función asíncrona, `mintNft()`:

async function mintNft(metadataUri: string) {
    try {
        const mint = generateSigner(umi);
        await createNft(umi, {
            mint,
            name: nftDetail.name,
            symbol: nftDetail.symbol,
            uri: metadataUri,
            sellerFeeBasisPoints: percentAmount(nftDetail.royalties),
            creators: [{ address: creator.publicKey, verified: true, share: 100 }],
        }).sendAndConfirm(umi)
        console.log(`Created NFT: ${mint.publicKey.toString()}`)
    } catch (e) {
        throw e;
    }
}

Esta función creará un token en la cadena de bloques que se vinculará a nuestros metadatos mediante el programa Metaplex Metadata.

Crear y llamar a la función principal

Crea una función asíncrona, «main», que utilizaremos para ejecutar todos los pasos de nuestro código:

async function main() {
    const imageUri = await uploadImage();
    const metadataUri = await uploadMetadata(imageUri);
    await mintNft(metadataUri);
}

main();

Como puedes ver, tendremos que definir tres funciones: uploadImage, uploadMetadata y mintNft. Llamaremos a estas funciones desde nuestra función principal. Empecemos por uploadImage.

¡Ahora solo tienes que ejecutar tu código!

Ejecuta tu código💨

¡Ya está todo listo! Cuando estés preparado, escribe lo siguiente en el terminal:

Aplicación ts-node

¡SÍ! ¿Ves algo así?

Aplicación ts-node      
Imagen subida: https://mockstorage.example.com/Quicknode Pixel
Metadatos subidos: https://mockstorage.example.com/Km5iewgZoHUE1dIQJZx7                          
NFT creado: 2dgA2xB4MebkQTMZeucoN1crDrPcLPaBryWChaUBcU6x

Buen trabajo.

Próximos pasos y resumen

¡Ahora ya tienes un script muy práctico y reutilizable para acuñar NFT directamente desde tu terminal! Muy útil, ¿verdad? ¿Quieres seguir aprendiendo? Aquí tienes un par de ideas para seguir avanzando a partir de lo que acabas de aprender:

1. Utiliza una transferencia de tokens SPL para enviar este NFT a otra cartera. (Guía: Transferencias de tokens SPL en Solana: una guía completa)
2. Utiliza Solana dApp Scaffold para crear un widget de acuñación de NFT. (Guía: Cómo conectar a los usuarios a tu dApp con el adaptador de monedero de Solana y Scaffold) Nota: Tendrás que utilizar una identidad del adaptador de monedero en lugar de keypairIdentitypara crear tu instancia de Metaplex en un front-end con el adaptador de cartera de Solana.

Si lo pruebas o tienes alguna pregunta que hacernos, ¡dínoslo! ¡Síguenos en Discord y Twitter!

¡Nos encanta recibir comentarios!

Si tienes algún comentario o sugerencia sobre nuevos temas, no dudes en hacérnoslo saber. Nos encantaría saber tu opinión.