Ir al contenido principal

Crear un token SPL de Solana con Metaplex

Actualizado el
26 de noviembre de 2025
Perfil de Aaron Milano
Aaron Milano
Todos
Solana
SVM
Programa de tokens SPL
Metaplex
TypeScript
JavaScript
IPFS
Solana-Web3.js
Vídeo

11 minutos de lectura

Resumen​

¿Quieres crear un token en Solana? El estándar de metadatos de tokens de Metaplex y Umi lo hacen más fácil y seguro que nunca. En esta guía, te explicaremos paso a paso cómo crear un token SPL fungible en Solana utilizando este moderno marco de trabajo, en solo 6 pasos.

¿Prefieres un tutorial en vídeo? Sigue los pasos de Sahil y aprende a crear un token fungible en Solana.
¡Suscríbete a nuestro canal de YouTube para ver más vídeos!

Tus funciones​

En esta guía, aprenderás a crear un token SPL de Solana utilizando el estándar de tokens de Metaplex y el cliente Umi. Crearás un monedero (y recibirás un airdrop de SOL), subirás los metadatos del token a IPFS y acuñarás tu token, todo ello siguiendo las mejores prácticas para un entorno de desarrollo de Solana.

Lo que necesitarás​

Paso 1: Configurar el entorno​

Antes de poder crear un token SPL, debes configurar tu entorno. Para empezar, crea un nuevo directorio de proyecto en tu terminal con el siguiente comando:

mkdir mint-fungible-spl
cd mint-fungible-spl

Crea dos archivos: wallet.ts y mint.ts. Utilizaremos wallet.ts para crear una nueva cartera de desarrollo y recibir un airdrop de Solana con fines de prueba. Utilizaremos mint.ts para acuñar un nuevo token SPL y subir los metadatos de nuestro token. 

echo > {monedero,caja de monedas}.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: 

tsc --init

Abre el archivo tsconfig.json y elimina el comentario (o añade) esto al archivo: 

«resolveJsonModule»: true

Esto nos permitirá importar archivos .json a nuestro repositorio, lo cual será importante más adelante cuando queramos generar un par de claves a partir de una clave privada.

Comprueba también que esModuleInterop esté establecido en «true» para que podamos utilizar importaciones. 

Instalar las dependencias de Solana Web3:​

hilo añadir @solana/web3.js@1 @metaplex-foundation/umi @metaplex-foundation/mpl-token-metadata @metaplex-foundation/umi-bundle-defaults bs58
#o
npm i @solana/web3.js@1 @metaplex-foundation/umi @metaplex-foundation/mpl-token-metadata @metaplex-foundation/umi-bundle-defaults bs58

Tu entorno debería tener un aspecto similar a este: 

Entorno Solana listo para usar

¡Muy bien! Ya estamos listos para empezar. 

Paso 2: Configurar un punto de conexión de la red de desarrollo de Solana en 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. Regístrate aquí para crear una cuenta.

Una vez que hayas creado tu cuenta, implementa un nodo de Solana Devnet. A continuación, copia el enlace del proveedor HTTP:

Nuevo punto de conexión de Solana

Paso 3: Crear un monedero y recibir SOL mediante airdrop​

Para acuñar un token SPL fungible, primero tendremos que crear una cartera de Devnet y recibir un airdrop de SOL en ella. Si ya tienes una cartera en papel, guárdala en el directorio de tu proyecto con el nombre guideSecret.json. Si necesitas SOL de Devnet, puedes solicitarlo mediante el formulario que aparece a continuación o a través del grifo de Solana de Quicknode:

🪂SolicitarSOL de Devnet

Nota: Enviar solicitudes de airdrop con demasiada frecuencia puede provocar un error 429 (demasiadas solicitudes).

Si no tienes una cartera en papel, generaremos una nueva mediante programación. Abre el archivo wallet.ts y pega el siguiente código. Lo explicaremos con detalle en la siguiente sección.

wallet.ts
import { Keypair, LAMPORTS_PER_SOL, Connection } from "@solana/web3.js";
import * as fs from 'fs';
import bs58 from 'bs58';

//STEP 1 - Connect to Solana Network
const endpoint = 'https://example.solana-devnet.quiknode.pro/000000/'; //Replace with your Quicknode RPC Endpoint
const solanaConnection = new Connection(endpoint);

//STEP 2 - Generate a New Solana Wallet
const keypair = Keypair.generate();
console.log(`Generated new KeyPair. Wallet PublicKey: `, keypair.publicKey.toString());

//STEP 3 - Convert Private key to Base58
const privateKey = bs58.encode(keypair.secretKey);
console.log(`Wallet PrivateKey:`, privateKey);

//STEP 4 - Write Wallet Secret Key to a .JSON
const secret_array = keypair.secretKey    
    .toString() //convert secret key to string
    .split(',') //delimit string by commas and convert to an array of strings
    .map(value=>Number(value)); //convert string values to numbers inside the array

const secret = JSON.stringify(secret_array); //Covert to JSON string

fs.writeFile('guideSecret.json', secret, 'utf8', function(err) {
    if (err) throw err;
    console.log('Wrote secret key to guideSecret.json.');
});

//STEP 5 - Airdrop 1 SOL to new wallet
(async()=>{
    const airdropSignature = solanaConnection.requestAirdrop(
        keypair.publicKey,
        LAMPORTS_PER_SOL,
    );
    try{
        const txId = await airdropSignature;     
        console.log(`Airdrop Transaction Id: ${txId}`);        
        console.log(`https://explorer.solana.com/tx/${txId}?cluster=devnet`)
    }
    catch(err){
        console.log(err);
    }    
})()

Este script realizará 5 tareas: 

  1. Conéctate a la red Solana (asegúrate de sustituir la URL de ejemplo de la línea 6 por la URL real de tu punto final de Quicknode, que guardaste en el paso anterior).
  2. Genera un nuevo par de claves para el monedero.
  3. Convierte la clave privada a Base58 y muéstrala en la consola.
  4. Escribe la clave secreta en un archivo .json que utilizaremos en el siguiente paso. Las líneas 16-22 son necesarias para dar formato a la clave como una matriz de números. Las líneas 24-27 utilizan fs para exportar la matriz a un archivo .json.
  5. Envía 1 SOL a la nueva cartera. 

Adelante, ejecuta este script para crear un nuevo monedero y recibir un airdrop de 1 SOL: 

ts-node wallet.ts

Deberías ver un nuevo archivo, «guideSecret.json», en la carpeta de tu proyecto y un registro de la terminal como este:

Se ha generado un nuevo par de claves. Clave pública del monedero:  G7ugoBpckgiL13KZMzWgQ751G27moDR9yVckQERrNnvj
Clave privada del monedero: 3A4b34ob9hqUaTjR52eBLjQCLova1jqAG1zT59ypXSJvjh1cQzEExpBBbQLWT7gfbcS4KuYddBDiAaYrFCPE55Tu
Se ha escrito la clave secreta en el archivo guideSecret.json.
ID de la transacción del airdrop: 58uYUd8PeimjWxf12dZRdqmURoMg1Q15SaaWwEET8U4VXU2pystyUsL9s2sq3cp2JTsUugPY7SUwW82S71SUo6Sj
https://explorer.solana.com/tx/58uYUd8PeimjWxf12dZRdqmURoMg1Q15SaaWwEET8U4VXU2pystyUsL9s2sq3cp2JTsUugPY7SUwW82S71SUo6Sj?cluster=devnet

Ahora, añadamos la clave privada al monedero que elijamos (en este caso,Phantom ):

No compartas las claves privadas

Imprimimos las claves privadas únicamente para poder añadir el nuevo monedero en Phantom. Nunca compartas tus claves privadas con nadie; guárdalas siempre de forma segura y en archivos de entorno (.env) cuando las utilices en el código, y asegúrate de añadir los archivos de entorno a .gitignore antes de publicarlos en GitHub.

Añadir un monedero en Phantom

Subamos el icono y los metadatos del token.

Paso 4: Sube el icono y los metadatos del token utilizando el estándar Metaplex Token Standard​

Necesitaremos un icono (imagen) del token y metadatos (archivo JSON) que sean de acceso público, para que los metadatos de nuestro token se puedan mostrar correctamente en los exploradores de bloques, las carteras y las plataformas de intercambio.

Para mantenernos fieles al espíritu de la descentralización, utilizaremos IPFS para subir el icono y los metadatos de nuestro token.

Aunque recomendamos utilizar la herramienta IPFS de Quicknode para fijar y servir datos, a continuación mostraremos ambos métodos:

  1. Uso del servicio IPFS gestionado de Quicknode
  2. Cómo ejecutar un nodo IPFS local

consejo

Para utilizar IPFS en Quicknode, se requiere un plan «Build» o superior. Consulta el desglose de las funciones por plan en nuestra página de tarifas.

Accede al panel de control de Quicknode y haz clic en la pestaña «IPFS» de la barra lateral izquierda.

A continuación, haz clic en la pestaña «Archivos» y, o bien haz clic en el botón «Nuevo» y selecciona «Subir un archivo», o simplemente arrastra el archivo que quieras anclar. Primero subiremos la imagen que aparece a continuación y, después, el archivo JSON de metadatos.

Icono de token

Una vez subida la imagen, haz clic en el menú de los tres puntos situado junto al archivo y, a continuación, haz clic en Copiar la URL de IPFS. Tendremos que añadir esto al archivo de metadatos.

Ahora definamos nuestros metadatos utilizando el Estándar de tokens fungibles de Metaplex, que requiere un nombre, un símbolo, una descripción y una imagen (todos ellos valores de cadena). El uso de este estándar al acuñar tu token permitirá que las principales plataformas, como Phantom Wallet o Solana Explorer, reconozcan fácilmente tu token y lo muestren a sus usuarios. Crea un nuevo archivo JSON de metadatos (token.json en este caso).

token.json
{
    "name": "Best Token Ever",
    "symbol": "BTE",
    "description": "This is the best token ever!",
    "image": "IPFS_URL_OF_IMAGE"
}

Actualiza IPFS_URL_OF_IMAGE con la URL IPFS de la imagen que hemos obtenido anteriormente, guarda el archivo y súbelo. Una vez fijado, verás el nombre del archivo, junto con otros datos como el CID del archivo, si está fijado y la fecha en que se fijó. Copia también la URL IPFS del archivo de metadatos. Necesitaremos esta URL más adelante, al acuñar nuestro token.

Captura de pantalla del panel de control con el icono del token y la subida de metadatos a IPFS

¡Ha sido muy fácil! Además, no tenemos que preocuparnos por poner en marcha y gestionar nuestro propio nodo IPFS. Puedes hacer clic en los tres puntos situados junto al archivo y seleccionar «Copiar URL de IPFS» para obtener la URL donde está alojado tu archivo. Además, puedes volver a descargar o ver los detalles de tus archivos desde este menú de los tres puntos. Tómate un momento para probarlo.

Ahora que ya tenemos nuestros archivos alojados en IPFS a través de Quicknode, ¡vamos a acuñar nuestro token!

Paso 5: Crear una herramienta para la emisión de tokens​

Para acuñar tu token SPL, primero tendrás que crear una herramienta de acuñación. A continuación te explicamos cómo hacerlo:

Importar dependencias​

Abre el archivo mint.ts e importa las siguientes dependencias en la línea 1: 

import { percentAmount, generateSigner, signerIdentity, createSignerFromKeypair } from '@metaplex-foundation/umi'
import { TokenStandard, createAndMint, mplTokenMetadata } from '@metaplex-foundation/mpl-token-metadata'
import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import secret from './guideSecret.json';

Hablaremos de ellos a medida que los vayamos encontrando en la guía, pero queremos destacar esa última importación, «secret», que consiste en importar el archivo .json que creamos en los primeros pasos.

Establecer la conexión con Solana​

Crea una conexión a la red Solana sustituyendo la URL de ejemplo por la URL de tu punto final de Quicknode en el código que aparece a continuación y pegándola justo debajo de las importaciones:

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

Inicializar el monedero Signer​

Estamos inicializando el monedero a partir de la clave secreta y configurándolo como firmante de las transacciones.

const userWallet = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(clave secreta));
const userWalletSigner = createSignerFromKeypair(umi, userWallet);

*Nota: si se establece numDecimals en 0, se obtiene un token que no se puede subdividir. Esto podría ser relevante, por ejemplo, para un token de acuñación destinado a una membresía o a una lista blanca.

Crear la variable «Metadata»​

Crea una variable de metadatos como la que se muestra a continuación e introduce los datos de tu token. Sustituye IPFS_URL_DE_METADATOS por la URL real de IPFS de tu archivo de metadatos (token.json).

const metadata = {
    name: "Best Token Ever",
    symbol: "BTE",
    uri: "IPFS_URL_OF_METADATA",
};

Creación de la PDA Mint​

Tendremos que crear una dirección derivada del programa de acuñación (PDA) para nuestro token. Descubre qué son las PDA en Solana y qué es la PDA de acuñación para tokens en Solana.

A continuación, vamos a crear una nueva PDA de acuñación y a indicar al cliente umi que utilice nuestra cartera, inicializada anteriormente a partir del secreto, como firmante, y que utilice los metadatos del token MPL para acuñar los metadatos del token.

const mint = generateSigner(umi);
umi.utilizar(identidad del firmante(userWalletSigner));
umi.uso(mplTokenMetadata())

Implementar Mint PDA y Mint Tokens​

En la función que aparece a continuación, enviamos una transacción para implementar el Mint PDA y acuñar un millón de nuestros tokens. Puedes modificar la cantidad de tokens y el mensaje de la consola según lo que más te convenga.

createAndMint(umi, {
    mint,
    authority: umi.identity,
    name: metadata.name,
    symbol: metadata.symbol,
    uri: metadata.uri,
    sellerFeeBasisPoints: percentAmount(0),
    decimals: 8,
    amount: 1000000_00000000,
    tokenOwner: userWallet.publicKey,
    tokenStandard: TokenStandard.Fungible,
}).sendAndConfirm(umi)
    .then(() => {
        console.log("Successfully minted 1 million tokens (", mint.publicKey, ")");
    })
    .catch((err) => {
        console.error("Error minting tokens:", err);
    });
¿Por qué sumamos decimales?

Se añaden decimales a los tokens para que sean divisibles hasta las partes más pequeñas, con el fin de simplificar las transacciones y mejorar la liquidez. Por ejemplo, en el ejemplo anterior, estamos diciendo que el decimal de nuestro token sería 8, lo que significa que nuestro token será divisible hasta el octavo decimal. Por lo tanto, al acuñar un millón de tokens, tenemos que añadir ocho ceros delante del número un millón (1000000_00000000).

Ponlo todo en su sitio​

Muy bien, el archivo «mint.ts» completo debería tener este aspecto:

mint.ts
import { percentAmount, generateSigner, signerIdentity, createSignerFromKeypair } from '@metaplex-foundation/umi'
import { TokenStandard, createAndMint, mplTokenMetadata } from '@metaplex-foundation/mpl-token-metadata'
import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
import secret from './guideSecret.json';

const umi = createUmi('https://example.solana-devnet.quiknode.pro/000000/'); //Replace with your Quicknode RPC Endpoint

const userWallet = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(secret));
const userWalletSigner = createSignerFromKeypair(umi, userWallet);

const metadata = {
    name: "Best Token Ever",
    symbol: "BTE",
    uri: "IPFS_URL_OF_METADATA",
};

const mint = generateSigner(umi);
umi.use(signerIdentity(userWalletSigner));
umi.use(mplTokenMetadata())

createAndMint(umi, {
    mint,
    authority: umi.identity,
    name: metadata.name,
    symbol: metadata.symbol,
    uri: metadata.uri,
    sellerFeeBasisPoints: percentAmount(0),
    decimals: 8,
    amount: 1000000_00000000,
    tokenOwner: userWallet.publicKey,
    tokenStandard: TokenStandard.Fungible,
}).sendAndConfirm(umi)
    .then(() => {
        console.log("Successfully minted 1 million tokens (", mint.publicKey, ")");
    })
    .catch((err) => {
        console.error("Error minting tokens:", err);
    });

Paso 6: Crea tu token de Solana​

En la Terminal, escribe: 

ts-node mint.ts

Una vez ejecutado correctamente, deberías ver un resultado similar a este:

Resultados finales en la pantalla de salida

Ya has creado con éxito tu token de Solana. Puedes verlo en el Solana Devnet Explorer, así como en tu monedero Phantom:


Cuenta de tokens en el explorador de la red de desarrollo de SolanaToken que se muestra en la cartera Phantom

Nota: Si ya has acuñado un token fungible anteriormente, es probable que hayas enviado tu token al Registro del Programa de Tokens de Solana. Ese registro ya no se utiliza y ya no es un paso necesario. Ya has subido los metadatos a la cadena, ¡así que ya estás listo!

¡Hora de la fiesta! 🎉​

¡Enhorabuena! Acabas de acuñar tu propio token en Solana utilizando el estándar de tokens fungibles de Metaplex y Umi. Diviértete con esto; ¡estamos deseando ver qué tokens vas a crear! Para obtener más información, echa un vistazo a algunos de nuestros otros tutoriales sobre Solana aquí. 

¡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.

Última actualización en
Comparte esta guía