Ir al contenido principal

Cómo utilizar las transacciones versionadas en Solana

Actualizado el
26 de noviembre de 2025
Perfil de Aaron Milano
Aaron Milano
Todos
Solana
SVM
Transacciones
JavaScript
TypeScript
Solana-Web3.js

7 minutos de lectura

Resumen​

El 10 de octubre de 2022 (Época 358), Solana incorporó compatibilidad con nuevos tipos de versiones de transacciones a través de un concepto conocido como«transacciones versionadas». Tras este cambio, el entorno de ejecución de Solana admite ahora dos tipos de transacciones: «legacy» (transacciones antiguas) y «0» (transacciones que incluyen tablas de búsqueda de direcciones). Las transacciones versionadas te permitirán utilizar las tablas de búsqueda de direcciones desde hoy mismo y podrían incorporar funcionalidades adicionales en el futuro.

En esta guía, crearás y ejecutarás una transacción de versión 0 (V0).

Si necesitas ayuda para asegurarte de que tus aplicaciones del lado del cliente actuales sean compatibles con las transacciones versionadas, consulta nuestra Guía: Cómo actualizar tu cliente de Solana para gestionar transacciones versionadas.

Lo que necesitarás​

Configura tu proyecto​

Crea un nuevo directorio de proyecto en tu terminal con:

mkdir solana-versioned-tx
cd solana-versioned-tx

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

Instalar la dependencia de Solana Web3​

Para este ejercicio tendremos que añadir la biblioteca Solana Web3. En tu terminal, escribe:

hilo añadir @solana/web3.js@1
#o
npm instalar @solana/web3.js@1

Empecemos.

Configura tu aplicación​

Importar las dependencias necesarias​

Abre el archivo app.ts y pega las siguientes importaciones en la línea 1 para obtener algunos métodos y clases esenciales de la biblioteca Solana Web3:

import { Connection, Keypair, LAMPORTS_PER_SOL, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';

Crea un monedero y recibe SOL mediante airdrop​

Lo primero que tendremos que hacer es crear una cuenta con un monedero y recargarla. Utilizaremos la práctica herramienta que aparece a continuación para generar automáticamente un nuevo monedero y recibir un airdrop de 1 SOL en él. (También puedes hacerlo con el Keypair.generate() y requestAirdrop() funciones, si prefieres un enfoque más manual).

🔑Generarun nuevo monedero con Devnet SOL

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

Una vez que hayas generado correctamente tu par de claves, verás que aparecen dos nuevas constantes: secreto y CARTERA_DEL_FIRMANTE, un par de claves. El secreto es una matriz de 32 bytes que se utiliza para generar las claves pública y privada. La CARTERA_DEL_FIRMANTE es una instancia de Keypair que se utiliza para firmar transacciones (hemos repartido algunos SOL de la red de desarrollo para cubrir las comisiones de gas). Asegúrate de añadirla a tu código debajo de las demás constantes si aún no lo has hecho.

Debajo de tus importaciones, pega tu nuevo secreto y añade:

const secreto = [0,...,0]; // 👈 Sustituye por tu clave secreta
const SIGNER_WALLET = Keypair.fromSecretKey(nuevo Uint8Array(secreto));
const CARTERA_DE_DESTINO = Keypair.generar();

Hemos definido dos carteras: CARTERA_DEL_FIRMANTE enviará SOL a nuestro DESTINATION_WALLET. También hemos añadido una constante, DIRECCIÓN_DE_LA_TABLA_DE_CONSULTA, que actualizaremos más adelante para que haga referencia al ID de cuenta en la cadena de nuestra tabla de consulta.

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:

const QUICKNODE_RPC = 'https://example.solana-devnet.quiknode.pro/0123456/';
const SOLANA_CONNECTION = new Connection(QUICKNODE_RPC);

Tu entorno debería tener este aspecto:

¡Vale, manos a la obra!

Crear una transacción de versión 0​

Las transacciones de la versión 0 nos obligan a utilizar una nueva clase, `VersionedTransaction`, que requiere que le pasemos un `VersionedMessage` como parámetro. Un `VersionedMessage` admite tanto un `Message` como un `MessageV0`. Aunque son muy similares, ¡ `MessageV0` permite el uso de tablas de búsqueda de direcciones!

Empecemos creando una nueva instrucción de transacción (TransactionInstruction) que envíe 0,1 SOL desde nuestro SIGNER_WALLET a nuestro DESTINATION_WALLET. Dado que nuestro mensaje de transacción va a necesitar una matriz de instrucciones de transacción, incluye la instrucción en una matriz:

const instructions: TransactionInstruction[] = [
    SystemProgram.transfer({
        fromPubkey: SIGNER_WALLET.publicKey,
        toPubkey: DESTINATION_WALLET.publicKey,
        lamports: 0.01 * LAMPORTS_PER_SOL,
    }),
];

Ahora vamos a crear una nueva función, ` createAndSendV0Tx`, que aceptará nuestro array `TransactionInstruction `:

async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) {

}

Definamos un confirmarTransacción función que llamaremos en nuestro createAndSendV0Tx función. Añade el siguiente código a tu app.ts archivo:

async function confirmTransaction(
    connection: Connection,
    signature: TransactionSignature,
    desiredConfirmationStatus: TransactionConfirmationStatus = 'confirmed',
    timeout: number = 30000,
    pollInterval: number = 1000,
    searchTransactionHistory: boolean = false
): Promise<SignatureStatus> {
    const start = Date.now();

    while (Date.now() - start < timeout) {
        const { value: statuses } = await connection.getSignatureStatuses([signature], { searchTransactionHistory });

        if (!statuses || statuses.length === 0) {
            throw new Error('Failed to get signature status');
        }

        const status = statuses[0];

        if (status === null) {
            // If status is null, the transaction is not yet known
            await new Promise(resolve => setTimeout(resolve, pollInterval));
            continue;
        }

        if (status.err) {
            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
        }

        if (status.confirmationStatus && status.confirmationStatus === desiredConfirmationStatus) {
            return status;
        }

        if (status.confirmationStatus === 'finalized') {
            return status;
        }

        await new Promise(resolve => setTimeout(resolve, pollInterval));
    }

    throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
}

Esto simplemente consultará la red de Solana para comprobar el estado de la transacción hasta que se confirme o se agote el tiempo de espera. Hemos incluido algunos valores predeterminados para el tiempo de espera y el intervalo de consulta, pero puedes ajustarlos según sea necesario.

Vamos a crear nuestra función. Añade estos 5 pasos al cuerpo de tu función ` createAndSendV0Tx `.

Paso 1: Obtener el hash del último bloque de la red mediante la función getLatestBlockhash:

    // Paso 1: Obtener el último hash del bloque
    let hashDelÚltimoBloque = await SOLANA_CONNECTION.getLatestBlockhash('confirmed');
    console.log("   ✅ - Se ha obtenido el último hash de bloque. Última altura válida:", hashDelÚltimoBloque.últimaAlturaVálidaDelBloque);

Nota: Pasamos el parámetro «confirmed» para reducir la probabilidad de que el hash pertenezca a una bifurcación descartada.

Paso 2: Utilizando nuestro parámetro `txInstructions ` y el `latestBlockhash`, podemos crear un nuevo `MessageV0 ` construyendo un nuevo `Message` y ejecutando el método `.compileToV0Message() `:

    // Step 2 - Generate Transaction Message
    const messageV0 = new TransactionMessage({
        payerKey: SIGNER_WALLET.publicKey,
        recentBlockhash: latestBlockhash.blockhash,
        instructions: txInstructions
    }).compileToV0Message();
    console.log("   ✅ - Compiled Transaction Message");
    const transaction = new VersionedTransaction(messageV0);

A continuación, pasamos nuestro mensaje a una nueva instancia de VersionedTransaction. ¡Enhorabuena! ¡Has creado una transacción versionada!

Paso 3: Firmar la transacción con un conjunto de firmantes. En este caso, se trata únicamente de nuestro SIGNER_WALLET.

    // Paso 3: firma tu transacción con los `Signers` necesarios
    transacción.sign([CARTERA_DEL_FIRMANTE]);
    console.log("   ✅ - Transacción firmada");

NOTA: Al enviar una «VersionedTransaction» al clúster, debe firmarse ANTES de llamar al método «sendAndConfirmTransaction». Fuente: edge.docs.solana.com.

Paso 4: Envía la transacción al clúster mediante la función `sendTransaction`, que devolverá una firma o un identificador de transacción:

    // Step 4 - Send our v0 transaction to the cluster
    const txid = await SOLANA_CONNECTION.sendTransaction(transaction, { maxRetries: 5 });
    console.log("   ✅ - Transaction sent to network");

Nota: Pasamos el parámetro «maxRetries» para permitir que el RPC vuelva a intentar enviar la transacción al líder si es necesario.

Paso 5: Por último, espera a que el clúster confirme que la transacción se ha realizado correctamente:

    // Step 5 - Confirm Transaction 
    const confirmation = await confirmTransaction(SOLANA_CONNECTION, txid);
    if (confirmation.err) { throw new Error("   ❌ - Transaction not confirmed.") }
    console.log('🎉 Transaction Succesfully Confirmed!', '\n', `https://explorer.solana.com/tx/${txid}?cluster=devnet`);

Si se realiza correctamente, registramos la URL del explorador de la transacción realizada con éxito.

¡Genial! ¡Ya estamos listos para probarlo!

Ejecuta tu código​

Para ejecutar nuestra función, llama a `createAndSendV0Tx` al final del archivo, pasando las instrucciones como argumento:

createAndSendV0Tx(instrucciones);

Nuestro código final está disponible en GitHub, aquí.

A continuación, en tu terminal, ejecuta:

ts-node app.ts

¿Ves algo así?

¡Buen trabajo! Si quieres comparar tu código con el nuestro, lo hemos publicado en GitHub, aquí.

Próximos pasos​

Ahora que ya sabes cómo crear y ejecutar transacciones versionadas, es el momento de descubrir todo lo que pueden ofrecer las transacciones V0. Echa un vistazo a nuestra guía «Cómo utilizar las tablas de consulta en Solana» (próximamente) para obtener más información sobre la nueva función de tablas de consulta de Solana y cómo utilizarlas.

Si te quedas atascado, tienes alguna duda o simplemente te apetece charlar sobre el tema, ¡escríbenos en Discord o Twitter!

¡Nos encanta recibir comentarios!​

Si tienes algún comentario o pregunta sobre esta guía, háznoslo saber. Nos encantaría saber tu opinión.

Última actualización en
Comparte esta guía