NUEVO: Solana Privacy Rings ya está disponible en la red principal
El modelo de programación de Solana
Blog/Fundamentos

El modelo de programación de Solana: introducción al desarrollo en Solana

Developer Experience Engineer0xIchigo en X0xIchigo en LinkedIn0xIchigo en GitHub
24 min de lectura

¿De qué trata este artículo?

El enfoque de Solana para la computación descentralizada se basa en un principio simple: todo se almacena en su propia región de memoria, conocida como cuenta. Solana funciona como un almacén global de pares clave-valor, donde las claves públicas sirven como identificadores únicos de sus cuentas correspondientes. Las cuentas son la base de Solana porque almacenan el estado: contienen desde programas hasta saldos de tokens. Las transacciones se utilizan para actualizar cuentas y reflejar cambios de estado.

En este artículo, exploramos las complejidades de la arquitectura de Solana. Comenzamos con una descripción general de los clústeres y el concepto de estado. Luego analizamos la función de las cuentas y los programas como componentes fundamentales de Solana. Por último, examinamos cómo las transacciones permiten interacciones dinámicas entre cuentas y programas.

Al terminar este artículo, comprenderás a fondo el modelo de programación de Solana. Conocerás la arquitectura de los clústeres, la función crucial de las cuentas para almacenar datos y el proceso mediante el cual las transacciones actualizan los datos de las cuentas. Además, explorarás características propias de Solana, como su sistema de renta y las transacciones con versión.

¿Qué son los clústeres de Solana?

En el centro de la arquitectura de Solana están los clústeres: un conjunto de validadores que trabajan juntos para procesar transacciones y mantener un único libro mayor. Solana tiene varios clústeres independientes, cada uno con un propósito específico:

  • Localhost: un clúster de desarrollo local disponible en el puerto predeterminado 8899. La interfaz de línea de comandos de Solana (CLI) incluye un validador de prueba integrado que puede personalizarse según las necesidades de cada desarrollador, sin requerir airdrops ni estar sujeto a límites de solicitudes
  • Devnet: un entorno aislado y sin consecuencias para hacer pruebas y experimentar en Solana
  • Testnet: un entorno donde los principales colaboradores de Solana prueban nuevas actualizaciones y funciones antes de que lleguen a mainnet. También sirve como entorno de pruebas para desarrolladores que quieren ejecutar pruebas de rendimiento
  • Mainnet Beta: el clúster activo y sin permisos donde ocurren transacciones reales. Esta es la Solana «real», donde usuarios, desarrolladores, titulares de tokens y validadores interactúan a diario

Cada clúster funciona de manera independiente, sin conocimiento de los demás. Las transacciones enviadas al clúster equivocado se rechazan para garantizar la integridad de cada entorno operativo.

Imagina los clústeres como un montón monolítico de datos. En informática, un montón es una región de memoria donde los datos pueden almacenarse y modificarse dinámicamente. Sin embargo, es importante señalar que los clústeres no usan literalmente una estructura de datos de montón. Esta analogía es una herramienta conceptual que ayuda a entender que los clústeres constan de varias regiones de memoria que pueden asignarse y liberarse cuando sea necesario. Entender los clústeres como un montón dinámico es clave para comprender cómo se administran, consultan y protegen los datos dentro de la red.

También puedes pensar en este montón monolítico de datos como una especie de almacén digital. Aquí, los datos son como cajas en estantes, cada una con etiquetas únicas y reglas específicas para moverlas y cambiar su contenido. Esto garantiza un sistema seguro y ordenado donde solo se permiten movimientos o cambios autorizados.

Los contratos inteligentes, conocidos como programas en Solana, tienen asignada su propia parte del almacén, o montón, que pueden administrar. Aunque un programa puede leer cualquier parte del espacio de este almacén, necesita ciertos permisos para modificar el contenido de un espacio que no posee. La única acción permitida de forma universal es transferir lamports, la criptomoneda nativa de Solana, a cualquier espacio del almacén.

Todo el estado reside en este montón, incluidos los programas. Cada región tiene un programa que la posee y administra. Por ejemplo, los programas pertenecen al BPFLoader, un programa responsable de cargar, implementar y actualizar programas on-chain. Llamamos cuentas a estas regiones de memoria, las cajas de nuestro almacén digital.

¿Qué son las cuentas?

Todo en Solana es una cuenta. Piensa en las cuentas como contenedores que conservan datos de forma persistente, de manera similar a los archivos de una computadora. Son los componentes básicos del modelo de programación de Solana y se utilizan para almacenar el estado, como el saldo de la cuenta, la información de propiedad, si la cuenta contiene un programa y la información de renta.

Hay tres tipos de cuentas en Solana:

  • Cuentas que almacenan datos
  • Cuentas que almacenan programas ejecutables
  • Cuentas que almacenan programas nativos

Estos tipos de cuentas pueden distinguirse aún más según sus capacidades:

  • Cuentas ejecutables: cuentas capaces de ejecutar código
  • Cuentas no ejecutables: cuentas utilizadas para almacenar datos sin capacidad para ejecutar código (¡porque no contienen código!)

En la imagen anterior, vemos algunos ejemplos de cuentas ejecutables y no ejecutables. Entre las cuentas ejecutables, Bubblegum es un ejemplo de cuenta de programa. Es un programa de Metaplex utilizado para crear y administrar NFT comprimidos. El Programa de Votación es un ejemplo de cuenta de programa nativo. Se utiliza para crear y administrar cuentas que registran el estado de votación y las recompensas de los validadores. Explicaremos la diferencia entre las cuentas de programa y las cuentas de programa nativo en la sección ¿Qué son los programas?. Por ahora, lo importante es saber que existen distintos tipos de cuentas ejecutables en Solana.

Además, todas las cuentas no ejecutables pueden clasificarse como cuentas de datos. Algunos ejemplos son:

Estructura de las cuentas

Las cuentas se estructuran según la estructura AccountInfo:

Código
pub struct AccountInfo<'a> {
    pub key: &'a Pubkey,
    pub lamports: Rc>,
    pub data: Rc>,
    pub owner: &'a Pubkey,
    pub rent_epoch: Epoch,
    pub is_signer: bool,
    pub is_writable: bool,
    pub executable: bool,
}

Las cuentas se identifican mediante su dirección (key), que es una clave pública única de 32 bytes.

El campo lamports contiene la cantidad de lamports que posee esta cuenta. Un lamport equivale a una milmillonésima parte de un SOL, el token nativo de Solana.

data se refiere al arreglo de bytes de datos sin procesar almacenado por esta cuenta. Puede guardar desde metadatos de un activo digital hasta saldos de tokens, y los programas pueden modificarlo.

El campo owner contiene al propietario de esta cuenta, representado por la dirección de una cuenta de programa. La propiedad de las cuentas sigue algunas reglas:

  • Solo el propietario de una cuenta puede modificar sus datos y retirar lamports
  • Cualquiera puede depositar lamports en una cuenta
  • El propietario de una cuenta puede transferir la propiedad a un nuevo propietario, siempre que los datos de la cuenta se restablezcan a cero

El campo is_signer es un valor booleano que indica si el propietario de la cuenta en cuestión firmó una transacción. En otras palabras, informa a los programas involucrados en la transacción si la cuenta es firmante. Ser firmante significa que la cuenta posee la clave privada correspondiente a la clave pública y tiene autoridad para aprobar la transacción propuesta.

El campo is_writable es un valor booleano que indica si los datos de la cuenta pueden modificarse. Solana permite que las transacciones especifiquen cuentas como de solo lectura para facilitar el procesamiento en paralelo. Aunque el entorno de ejecución permite que distintos programas accedan simultáneamente a cuentas de solo lectura, gestiona los posibles conflictos de escritura en cuentas modificables mediante un orden de procesamiento de transacciones. Esto garantiza que solo las transacciones sin conflictos se procesen en paralelo.

El campo executable es un valor booleano que indica si una cuenta puede procesar instrucciones. Sí, esto significa que los programas se almacenan en cuentas. Profundizaremos en ello en la siguiente sección. Primero debemos explicar el concepto de renta.

El campo rent_epoch indica la siguiente época en la que esta cuenta deberá pagar renta. Una época es la cantidad de slots durante los que un cronograma de líderes es válido. A diferencia de los archivos tradicionales de un sistema operativo, las cuentas de Solana tienen una vida útil expresada en una cantidad de lamports. La idea de que la existencia continua de una cuenta dependa de su saldo de lamports nos lleva al concepto de renta.

Renta

La renta es un costo de almacenamiento necesario para mantener activas las cuentas en Solana y garantizar que permanezcan en la memoria de los validadores. Su cobro se calcula por épocas, una unidad de tiempo definida por los slots durante los cuales un cronograma de líderes es válido. Así funciona la renta:

  • Cobro de renta: la renta se cobra una vez por época. También puede cobrarse cuando una transacción hace referencia a una cuenta
  • Distribución de la renta: parte de la renta cobrada se quema, es decir, se retira permanentemente de circulación. El resto se distribuye entre las cuentas de voto después de cada slot
  • Pago de renta: si una cuenta no tiene suficientes lamports para pagar la renta, sus datos se eliminan y la cuenta se libera mediante un proceso conocido como recolección de basura
  • Exención de renta: las cuentas pueden quedar exentas de renta si mantienen un saldo mínimo equivalente a dos años de pagos. Todas las cuentas nuevas deben cumplir este umbral de exención, que depende del tamaño de la cuenta
  • Recuperación de la renta: los usuarios pueden cerrar una cuenta para recuperar los lamports restantes. Esto permite recuperar la renta almacenada en una cuenta

La renta puede estimarse mediante el endpoint RPC getMinimumBalanceForRentExemption para un tamaño de cuenta específico. El Helius API Playground simplifica el proceso al aceptar la longitud de los datos de una cuenta en usize. También puedes usar el subcomando de renta de Solana CLI para estimar la cantidad mínima de SOL necesaria para que una cuenta quede exenta de renta. Por ejemplo, al momento de escribir este artículo, ejecutar el comando solana rent 20000 devuelve Rent-exempt minimum: 0.14009088 SOL.

Direcciones en Solana

En realidad, hay dos «tipos» de direcciones en Solana. Para crear direcciones, Solana utiliza ed25519, un esquema de firma EdDSA que emplea SHA-512 (SHA-2) y la curva elíptica Curve22519. Esto produce claves públicas de 32 bytes que funcionan como formato principal de dirección. Pueden utilizarse directamente porque no se someten a hash.

Para que una dirección sea válida, debe ser un punto de la curva ed25519. Sin embargo, no todas las direcciones deben derivarse de esta curva. Las direcciones derivadas de programas (PDA) se generan fuera de la curva, por lo que no tienen una clave privada correspondiente y no pueden usarse para firmar. Las PDA se crean mediante el Programa del Sistema y se utilizan cuando los programas necesitan administrar cuentas. Este es solo un inciso para que conozcas los distintos tipos de direcciones en Solana. Abordaremos las PDA en un artículo futuro.

¿En qué se diferencian las cuentas de Solana de las cuentas de Ethereum?

Ethereum tiene dos tipos principales de cuentas: cuentas de propiedad externa (EOA) y cuentas de contrato. Las claves privadas controlan las EOA, mientras que el código del contrato rige las cuentas de contrato, que no pueden iniciar transacciones por sí mismas.

Tanto las EOA como las cuentas de contrato siguen la misma estructura:

  • Saldo: cada cuenta tiene un saldo medido en Ether
  • Nonce: para las EOA, es la cantidad de transacciones enviadas desde la cuenta. Para los contratos, es la cantidad de contratos creados por la cuenta
  • Raíz de almacenamiento: un hash de 256 bits del nodo raíz de un árbol de Merkle Patricia, que codifica el contenido almacenado en la cuenta
  • CodeHash: el hash del código de la Ethereum Virtual Machine (EVM) del contrato. Es inmutable, lo que significa que su código no cambia después de crearse, aunque su estado sí puede hacerlo. Es importante señalar que existen excepciones para actualizar contratos en Ethereum, como el uso de patrones proxy, pero esto queda fuera del alcance del artículo. Para las EOA, es el hash de una cadena vacía porque no contienen código

Solana adopta un modelo de cuentas más uniforme, donde cualquier cuenta puede llegar a ser un programa. La separación entre código y datos crea un entorno más eficiente y flexible. Los programas de Solana no tienen estado e interactúan con distintas cuentas de datos sin implementaciones redundantes. Esto resulta especialmente útil para aplicaciones de finanzas descentralizadas (DeFi), donde un usuario quiere interactuar con varios protocolos sin mover activos entre distintos programas. En cambio, el modelo de programación de Ethereum combina código y estado en una sola entidad. Esto hace que las interacciones sean más complejas y potencialmente más costosas debido al gas necesario para cambiar el estado.

Antes, las cuentas de Solana pagaban renta y debían mantener un saldo mínimo para permanecer activas. Esto garantiza que la red termine recuperando las cuentas sin uso o con fondos insuficientes, lo que reduce la sobrecarga de estado. Las actualizaciones recientes eliminaron las cuentas que pagan renta en mainnet: ahora todas deben estar exentas de renta. En comparación, Ethereum utiliza gas para administrar la asignación de recursos. Con este modelo, el almacenamiento de un contrato persiste indefinidamente a menos que se borre de forma explícita. El enfoque de Solana ofrece una estructura de costos más predecible para almacenar el estado, mientras que los costos de Ethereum pueden variar y volverse prohibitivos durante periodos de congestión de la red.

En la siguiente sección, examinaremos cómo Solana separa la lógica de sus programas del estado. En comparación con el modelo de programación de Ethereum, verás cómo este enfoque modular facilita operaciones on-chain más eficientes y ofrece a los desarrolladores una estructura de costos transparente y predecible.

¿Qué son los programas de Solana?

Los programas son cuentas ejecutables que pertenecen al BPF Loader. Los ejecuta el entorno de ejecución de Solana, diseñado para procesar transacciones y la lógica de los programas.

Una de las características distintivas del modelo de programación de Solana es la separación entre código y datos. Los programas no tienen estado, es decir, no almacenan ningún estado internamente. En su lugar, todos los datos que necesitan para operar se guardan en cuentas separadas, que las transacciones pasan por referencia a los programas. Este diseño permite que una implementación única y genérica de un programa interactúe con distintas cuentas.

Los programas de Solana pueden:

  • Poseer cuentas adicionales
  • Leer otras cuentas o abonarlas
  • Modificar datos o debitar las cuentas que poseen

Hay dos tipos de programas:

  • Programas on-chain: programas escritos por usuarios e implementados en Solana. Su autoridad de actualización, que normalmente es la cuenta que implementó el programa, puede actualizarlos
  • Programas nativos: programas integrados en el núcleo de Solana. Proporcionan la funcionalidad fundamental que los validadores necesitan para operar. Los programas nativos solo pueden actualizarse mediante actualizaciones de software en toda la red. Algunos ejemplos comunes son el Programa del Sistema, el programa BPF Loader y el Programa de Votación.

Tanto los usuarios como otros programas pueden invocar programas on-chain y nativos. La diferencia principal está en sus mecanismos de actualización: la autoridad de actualización puede actualizar los programas on-chain, mientras que los programas nativos solo pueden actualizarse como parte de las actualizaciones del clúster.

Solana Labs mantiene un grupo seleccionado de programas on-chain conocido como Solana Program Library. Esta biblioteca facilita distintas operaciones on-chain, incluidos los préstamos de tokens y la creación de pools de stake. Por ejemplo, el Associated Token Account Program establece un estándar y un mecanismo para vincular la billetera de un usuario con sus respectivas cuentas de tokens. Además, la SPL es dinámica. Programas como Token-2022 amplían y desarrollan las funciones proporcionadas por el Token Program.

El desarrollo de programas en Solana suele realizarse en Rust con ayuda de Anchor, un framework con convenciones definidas que simplifica la creación de programas al reducir el código repetitivo y agilizar la serialización y deserialización. Aunque Rust es la opción preferida, los desarrolladores no están limitados a este lenguaje: pueden usar C, C++ y cualquier lenguaje dirigido al backend BPF de LLVM, es decir, un componente de LLVM que permite compilar programas en bytecode BPF. Los avances recientes de Solang y Neon Labs permiten a los desarrolladores usar Solidity para desarrollar programas.

Los programas suelen desarrollarse y probarse en Localhost y Devnet antes de implementarse en Testnet o Mainnet Beta. Los desarrolladores pueden implementar su programa mediante Solana CLI con el comando solana program deploy <path to program>. Una vez compilado como un objeto compartido ELF que contiene el bytecode BPF, el programa se carga en el clúster de Solana designado. Los programas implementados residen en cuentas marcadas como executable, y la dirección de la cuenta funciona como program_id.

Al principio, los programas de Solana se implementaban con cuentas que duplicaban el tamaño del programa. La actualización 1.16 de Solana incorpora compatibilidad con cuentas redimensionables para brindar a los desarrolladores más flexibilidad y una mejor asignación de recursos. Ahora pueden implementar sus programas con una cuenta más pequeña y ampliar su tamaño posteriormente.

Como mencionamos antes, los programas se consideran sin estado porque todos los datos con los que interactúan se almacenan en cuentas separadas que se pasan por referencia. Todos los programas tienen un único punto de entrada donde se procesan las instrucciones. Este recibe un program_id, un arreglo de cuentas y los datos de la instrucción como un arreglo de bytes. El entorno de ejecución de Solana ejecuta los programas cuando una transacción los invoca.

¿Qué son las transacciones?

Las transacciones son la base de la actividad on-chain. Funcionan como el mecanismo mediante el cual se invocan programas y se aplican cambios de estado. Una transacción de Solana es un conjunto de instrucciones que indica a los validadores qué acciones deben ejecutar, en qué cuentas y si tienen los permisos necesarios.

Una transacción consta de tres partes principales:

  • Un arreglo de cuentas para leer o escribir
  • Una o más instrucciones
  • Una o más firmas

Las transacciones de Solana siguen la estructura Transaction. Esta proporciona la información necesaria para que la red procese y valide acciones. Se define de la siguiente manera:

Código
pub struct Transaction {
    pub signatures: Vec,
    pub message: Message,
}

El campo signatures contiene un conjunto de firmas que corresponden al Message serializado. Cada firma está asociada con una clave de cuenta de la lista account_keys del Message, comenzando por el pagador de comisiones. El pagador de comisiones es la cuenta responsable de cubrir las comisiones generadas al procesar una transacción. Normalmente es la cuenta que inicia la transacción. La cantidad de firmas requeridas equivale a num_required_signatures, que se define en el MessageHeader del mensaje.

El propio message es una estructura de tipo Message. Se define así:

Código
pub struct Message {
    pub header: MessageHeader,
    pub account_keys: Vec,
    pub recent_blockhash: Hash,
    pub instructions: Vec,
}

El header del mensaje contiene tres enteros sin signo de 8 bits: la cantidad de firmas requeridas (es decir, num_required_signatures), la cantidad de firmantes de solo lectura y la cantidad de no firmantes de solo lectura.

El campo account_keys enumera todas las direcciones de cuenta involucradas en la transacción. Primero aparecen las cuentas que solicitan acceso de lectura y escritura, seguidas de las cuentas de solo lectura.

recent_blockhash es un blockhash reciente que contiene un hash SHA-256 de 32 bytes. Es necesario para indicar cuándo un cliente observó el libro mayor por última vez y sirve para limitar la vida útil de las transacciones recientes. Los validadores rechazan las transacciones con un blockhash antiguo. Además, incluir un blockhash reciente ayuda a evitar transacciones duplicadas, ya que se rechaza cualquier transacción totalmente idéntica a una anterior. Si, por algún motivo, una transacción debe firmarse mucho antes de enviarse a la red, puede usarse un nonce de transacción duradero en lugar de un blockhash reciente para garantizar que sea única.

El campo instructions contiene una o más estructuras CompiledInstruction, y cada una determina una acción específica que deben ejecutar los validadores de la red.

Instrucciones

Una instrucción es una directiva para una única invocación de un programa de Solana. Es la unidad más pequeña de lógica de ejecución de un programa y la unidad operativa más básica de Solana. Los programas interpretan los datos enviados por una instrucción y operan sobre las cuentas especificadas. La estructura Instruction se define así:

Código
pub struct Instruction {
    pub program_id: Pubkey,
    pub accounts: Vec,
    pub data: Vec,
}

El campo program_id especifica la clave pública del programa que se ejecutará. Es la dirección del programa que procesará la instrucción. El propietario de la cuenta del programa, indicado por esta clave pública, especifica el cargador responsable de inicializar y ejecutar el programa. El cargador marca como ejecutables los programas on-chain en Solana Bytecode Format (SBF) después de implementarlos. El entorno de ejecución de Solana rechaza cualquier transacción que intente invocar cuentas que no estén marcadas como ejecutables.

El campo accounts enumera las cuentas que la instrucción puede leer o modificar. Estas cuentas deben proporcionarse como valores AccountMeta. Toda cuenta cuyos datos pueda modificar la instrucción debe marcarse como modificable; de lo contrario, la transacción fallará. Esto se debe a que los programas no pueden escribir en cuentas que no poseen o para las que no tienen los permisos necesarios. También se aplica a la modificación de los lamports de una cuenta: restar lamports de una cuenta que no pertenece al programa hará que la transacción falle, mientras que se permite agregar lamports a cualquier cuenta. El campo accounts también puede especificar cuentas que el programa no lee ni modifica. Esto se hace para influir en la programación de la ejecución del programa por parte del entorno de ejecución, pero esas cuentas se ignoran en cualquier otro caso.

data es un vector de uso general formado por enteros sin signo de 8 bits que funciona como la entrada enviada al programa. Este campo es crucial porque contiene las instrucciones codificadas que ejecutará el programa.

Solana no impone un formato para los datos de las instrucciones. Sin embargo, tiene compatibilidad integrada con la serialización mediante bincode e borsh (Binary Object Representation Serializer for Hashing). La serialización es el proceso de convertir estructuras de datos complejas en una serie plana de bytes que puede transmitirse o almacenarse. Al elegir cómo codificar los datos, debes considerar la sobrecarga de la decodificación, ya que todo ocurre on-chain. La serialización con Borsh suele preferirse sobre bincode porque tiene una especificación estable, una implementación en JavaScript y, por lo general, es más eficiente.

Los programas utilizan funciones auxiliares para agilizar la creación de instrucciones compatibles. Por ejemplo, el Programa del Sistema proporciona una función auxiliar para crear la instrucción SystemInstruction::Assign:

Código
pub fn assign(pubkey: &Pubkey, owner: &Pubkey) -> Instruction {
    let account_metas = vec![AccountMeta::new(*pubkey, true)];
    Instruction::new(
        system_program::id(),
        &SystemInstruction::Assign { owner: *owner },
        account_metas,
    )
}

Esta función crea una instrucción que, al procesarse, cambiará el propietario de la cuenta especificada por el nuevo propietario proporcionado.

Una sola transacción puede contener varias instrucciones, que se ejecutan secuencial y atómicamente en el orden indicado. Esto significa que todas tienen éxito o ninguna lo tiene. También implica que el orden de las instrucciones puede ser crítico. Los programas deben reforzarse para procesar de forma segura cualquier secuencia posible de instrucciones y evitar posibles vulnerabilidades.

Por ejemplo, durante la desinicialización, un programa puede intentar desinicializar una cuenta estableciendo su saldo de lamports en cero. Esto presupone que el entorno de ejecución de Solana eliminará la cuenta. La suposición es válida entre transacciones, pero no entre instrucciones o invocaciones entre programas (abordaremos las invocaciones entre programas en un artículo futuro). El programa debe poner explícitamente en cero los datos de la cuenta para protegerse contra este posible defecto del proceso de desinicialización. De lo contrario, un atacante podría emitir una instrucción posterior para aprovechar la supuesta eliminación, por ejemplo, reutilizando la cuenta antes de que finalice la transacción.

¿Qué son las transacciones con versión?

Las transacciones de Solana utilizan los estándares de unidad máxima de transmisión (MTU) de IPv6 para garantizar una transmisión de datos rápida y confiable en todo el clúster. La pila de red de Solana utiliza un tamaño de MTU conservador de 1280 bytes. Después de reservar espacio para los encabezados, quedan 1232 bytes disponibles para los datos del paquete. Por ello, las transacciones de Solana están limitadas a este tamaño.

Esta restricción de tamaño facilita varias mejoras de red, pero también limita la complejidad de las operaciones que pueden realizarse en una sola transacción. Como cada dirección de cuenta ocupa 32 bytes de almacenamiento, una transacción puede incluir hasta 35 cuentas si no contiene instrucciones. Esta limitación genera dificultades para los casos de uso que requieren más de 35 cuentas sin firma en una sola transacción.

Para resolverlo, se introdujo un nuevo formato de transacción compatible con varias versiones. Actualmente, el entorno de ejecución de Solana admite dos versiones de transacciones:

  • legacy: el formato de transacción original
  • 0 (Versión 0): el formato de transacción más reciente, que admite tablas de búsqueda de direcciones

La Versión 0 se lanzó para admitir tablas de búsqueda de direcciones (ALT). En esencia, almacenan direcciones de cuentas on-chain en una estructura de datos similar a una tabla. Estas tablas son cuentas separadas que almacenan direcciones y permiten hacer referencia a ellas en una transacción mediante un índice u8 de 1 byte. Esto reduce considerablemente el tamaño de una transacción, ya que cada cuenta incluida solo necesita 1 byte en lugar de 32. Las ALT son especialmente útiles para operaciones complejas que involucran muchas cuentas, como las habituales en aplicaciones DeFi.

Este diagrama se adaptó de la sección sobre transacciones con versión de Solana Cookbook

El término «transacciones con versión» se refiere a la forma en que Solana admite tanto el formato de transacciones heredado como el de Versión 0. Este enfoque garantiza la componibilidad a la vez que incorpora mejoras al entorno de ejecución.

Estructura de una transacción con versión

Un VersionedTransaction se define así:

Código
pub struct VersionedTransaction {
    pub signatures: Vec,
    pub message: VersionedMessage,
}

El campo signatures es una lista de firmas de los firmantes de la transacción. Sirven para autenticarla y mantener su integridad. El message es el contenido real de la transacción. Está encapsulado por el tipo VersionedMessage, un envoltorio enum ligero que gestiona tanto los mensajes heredados como los de Versión 0:

Código
pub enum VersionedMessage {
    Legacy(Message),
    V0(Message),
}

La versión del mensaje se determina mediante el primer bit del proceso de serialización. Si el primer bit está activado, los 7 bits restantes se usan para determinar qué versión de Message se serializa, comenzando por la Versión 0. Si el primer bit no está activado, todos los bytes se utilizan para codificar el formato heredado de Message. Esto se debe a que existen dos estructuras Message con nombres idénticos, pero se encuentran en módulos diferentes: legacy y v0.

Un Message representa el formato interno condensado de una transacción. Se utiliza para la transmisión por la red y para su manipulación por parte del entorno de ejecución. Incluye una lista lineal de todas las cuentas utilizadas por las instrucciones de la transacción, un MessageHeader que detalla la estructura del arreglo de cuentas, un blockhash reciente y una codificación compacta de las instrucciones del mensaje. Esta es la estructura v0 de Message:

Código
pub struct Message {
    pub header: MessageHeader,
    pub account_keys: Vec,
    pub recent_blockhash: Hash,
    pub instructions: Vec,
    pub address_table_lookups: Vec,
}

La diferencia entre un mensaje heredado y uno v0 es que este último incluye el campo address_table_lookups.

Integración del modelo de programación con el flujo de transacciones de Solana

El modelo de programación de Solana está profundamente integrado con sus sistemas de cuentas y transacciones. Así se relacionan los conceptos:

  • Cuentas como estado: las cuentas de Solana funcionan como contenedores de estado para los programas. El modelo de programación se centra en modificar los datos almacenados en estos contenedores en respuesta a instrucciones
  • Instrucciones: los programas definen la lógica para procesar las instrucciones contenidas en una transacción. Estas instrucciones son los componentes ejecutables que interactúan con los datos de las cuentas
  • Serialización y procesamiento: cuando una transacción se serializa, las instrucciones del programa determinan los cambios en el estado de las cuentas. El proceso de serialización respeta el diseño del programa, ya sea que utilice el formato de transacciones heredado o el de Versión 0
  • Atomicidad: el modelo de programación de Solana garantiza el procesamiento atómico de las instrucciones. Los programas deben diseñarse para gestionar transacciones simultáneas de forma segura y eficiente
  • Escalabilidad: el modelo de programación de Solana favorece la escalabilidad mediante funciones como las tablas de búsqueda de direcciones (ALT). Estas tablas reducen el tamaño de una transacción y aumentan la cantidad de cuentas a las que puede hacer referencia

El modelo de programación de Solana no consiste solo en escribir código, sino en entender cómo interactúa ese código dentro del ecosistema general. Las cuentas son esenciales para este modelo y constituyen el principal medio para almacenar y modificar datos en la red. Las transacciones permiten la actividad on-chain al indicar a los validadores qué datos deben crearse, actualizarse o eliminarse. Comprender a fondo estos aspectos es vital para que los desarrolladores creen aplicaciones optimizadas para el rendimiento y la sinergia dentro del ecosistema de Solana.

Conclusión

¡Felicidades! En este artículo, recorrimos las complejidades de la arquitectura del sistema de Solana y analizamos el concepto de los clústeres como montones monolíticos de datos. Descubrimos cómo este montón se organiza en regiones de memoria independientes conocidas como cuentas, que forman la base del modelo de programación de Solana. Las cuentas almacenan desde los tokens de los usuarios hasta los propios programas que definen el comportamiento de la red, y todo se modifica mediante transacciones.

Para los desarrolladores, comprender el enfoque de Solana para la computación descentralizada es fundamental. Entender los detalles de las cuentas, los programas y las transacciones es necesario para crear aplicaciones que aprovechen al máximo las capacidades de Solana. Se trata de entender un sistema donde el código está separado del estado. Esto da lugar a programas sin estado que interactúan con los datos mediante cuentas, con un nivel de componibilidad y capacidad de actualización sin precedentes.

Tanto para los inversionistas como para los usuarios ocasionales, entender cómo el diseño de Solana crea un ecosistema sólido, flexible y eficiente es crucial para apreciar la viabilidad de la plataforma y su capacidad para impulsar aplicaciones innovadoras que solo son posibles en Solana.

Si llegaste hasta aquí, anon, ¡gracias! ¿Quieres profundizar? Únete a nuestro Discord y comienza hoy mismo a programar en Solana.

Recursos adicionales / Lecturas recomendadas

Suscríbete a Helius

Mantente al día con las novedades del desarrollo en Solana y recibe actualizaciones cuando publiquemos

Imagen ampliada