NUEVO: Solana Privacy Rings ya está disponible en la red principal
Cómo migrar de Ethereum a Solana: guía para desarrolladores
Blog/Investigación

Cómo migrar de Ethereum a Solana: guía para desarrolladores

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

¿De qué trata este artículo?

Ethereum es una de las innovaciones más importantes de los últimos tiempos. Por primera vez en la historia, tenemos una plataforma global y descentralizada diseñada para la coordinación social, con el potencial de revolucionar muchas industrias. A pesar de su importancia, el entorno de ejecución de Ethereum, Ethereum Virtual Machine (EVM), no está diseñado en su estado actual para aplicaciones destinadas al consumidor. Es una red de un solo hilo, basada en gas y con comisiones volátiles. En cambio, Solana surge como una red de alto rendimiento y baja latencia. Ofrece una infraestructura paralelizada con comisiones bajas y predecibles. Aborda directamente las limitaciones de la EVM y mejora su diseño original, lo que la convierte en una opción atractiva para los desarrolladores que buscan crear aplicaciones escalables y eficientes.

Este artículo es una guía completa de migración para desarrolladores de EVM interesados en crear aplicaciones en Solana. Explica las diferencias fundamentales entre ambas, incluidos los mecanismos de consenso de Ethereum y Solana, cómo procesan las transacciones y los lenguajes utilizados para desarrollar contratos inteligentes. Luego, aborda el modelo de cuentas de Solana, que propone un enfoque más uniforme y multifacético. El artículo también explora Solang y Neon EVM, dos herramientas compatibles con Solidity que mejoran la experiencia de desarrollo en Solana.

Diferencias fundamentales

Esta sección explora las diferencias clave entre Ethereum y Solana, dos blockchains que buscan crear una máquina de estados descentralizada para la coordinación global. Sin embargo, ambas difieren considerablemente en sus mecanismos de consenso, métodos de procesamiento de transacciones y lenguajes para desarrollar contratos inteligentes. Comprender mejor estas diferencias fundamentales revela la clara ventaja de Solana sobre Ethereum como máquina de estados global de alto rendimiento.

Mecanismos de consenso

Los mecanismos de consenso sustentan todas las redes blockchain. Determinan cómo se verifican las transacciones y cómo se agregan los bloques a la blockchain de forma segura, eficiente y descentralizada. Tanto Ethereum como Solana son redes de prueba de participación (PoS). Aunque comparten una base común en PoS, sus enfoques para alcanzar el consenso difieren debido a sus reglas de confirmación.

Ethereum utiliza Gasper, una combinación de Casper the Friendly Finality Gadget (Casper-FFG) y el algoritmo de selección de bifurcaciones LMD-GHOST. Esta combinación constituye el mecanismo de consenso que protege Ethereum.

Casper es un sistema de finalidad basado en PoS que eleva el estado de confirmación de un bloque a «finalizado». Un bloque se considera finalizado en Ethereum cuando dos tercios de la participación total votan a favor de incluirlo y se construye otro bloque sobre él. Como la finalidad requiere que dos tercios de la participación total coincidan en que un bloque es canónico, un atacante no puede crear una cadena finalizada alternativa sin poseer o manipular dos tercios de la participación total y destruir al menos un tercio mediante penalización. Casper permite que los nuevos participantes se sincronicen con confianza con la cadena canónica. 

LMD-GHOST es el acrónimo de «Latest Message-Driven Greedy Heaviest Observed Sub-Tree». Es un algoritmo que decide qué bifurcación de Ethereum seguir. Para ello, elige la bifurcación que ha recibido más apoyo (es decir, más «peso») de los validadores de la red (de ahí «greedy heaviest sub-tree»). Después, garantiza que solo se tenga en cuenta el mensaje más reciente de cada validador. Cada vez que se propone un bloque nuevo en Ethereum, los validadores utilizan esta regla para decidir si debe formar parte de la cadena canónica.

En comparación, Solana utiliza hashes de prueba de historia (PoH) para alcanzar el consenso. A pesar de su nombre confuso, PoH no es un algoritmo de consenso. Es una forma de demostrar el paso del tiempo en una red adversarial. Más concretamente, es una función criptográfica de sellado de tiempo que permite a los nodos acordar un orden de eventos sin comunicarse entre sí. El líder (es decir, el validador que agrega entradas al libro mayor) aplica marcas de tiempo a los bloques para demostrar que ha transcurrido cierto tiempo desde el último bloque. 

Agregar estas marcas de tiempo establece un registro histórico, ya que demuestra que los datos existían en un momento específico. El registro histórico se crea mediante una función hash secuencial resistente a preimágenes, en la que cada hash depende del anterior. Las funciones de demora verificable (VDF) son fundamentales para generar estos hashes. Garantizan que cada hash se base en el anterior e incorpore el tiempo transcurrido desde entonces. La integración de las VDF añade una dimensión temporal al proceso de hashing, lo que permite crear en Solana una secuencia verificable de eventos con marcas de tiempo.

Después de establecer cómo el mecanismo de prueba de historia de Solana crea una secuencia confiable de eventos mediante marcas de tiempo criptográficas, es esencial comprender cómo se integra con el mecanismo de consenso de Solana, Tower BFT. Tower Byzantine Fault Tolerance (BFT) es la variante de Solana del modelo tradicional de consenso de tolerancia a fallos bizantinos, optimizada para PoH. Tower BFT utiliza como marco de referencia el registro histórico creado por PoH. Este marco permite que los validadores voten sobre el estado del libro mayor de forma eficiente y precisa. Tower BFT funciona mediante votos de los validadores que quedan bloqueados durante mucho tiempo y cuyo compromiso aumenta a medida que se agregan más votos. Gracias a PoH, los validadores pueden tomar decisiones más rápidas e informadas sobre el estado del libro mayor sin tener que comunicarse entre sí. La combinación de PoH y Tower BFT acelera el consenso y mejora la seguridad y confiabilidad de la red. El resultado es un entorno blockchain escalable y de alto rendimiento donde las transacciones se confirman rápidamente.

Procesamiento de transacciones y entornos de ejecución

La eficiencia y escalabilidad de una blockchain dependen principalmente de su capacidad para procesar transacciones y de su entorno de ejecución. Estos factores determinan la velocidad de ejecución de las transacciones y la eficiencia de costos de las operaciones en la red. El enfoque de una blockchain respecto al procesamiento de transacciones y los matices de sus entornos de ejecución influyen considerablemente en la experiencia del desarrollador.

El entorno de ejecución de Ethereum funciona como una máquina de pila determinista y de un solo hilo conocida como Ethereum Virtual Machine (EVM). Se comporta como una función matemática. Es decir, la EVM produce un resultado determinista cuando recibe una entrada. Resulta útil definir Ethereum mediante una función de transición de estado: f(S, T) = S’. Dado un estado anterior (S) y un nuevo conjunto de transacciones válidas (T), la EVM produce un nuevo estado de salida válido (S’). La EVM siempre alcanzará el mismo estado final con el mismo conjunto de transacciones. Esto es fundamental para mantener la coherencia entre los nodos de la red.

La EVM procesa las transacciones de forma secuencial. El procesamiento secuencial garantiza que cada transacción se ejecute en un entorno que refleje con precisión el estado de la red hasta ese momento. La ejecución secuencial permite calcular con precisión los cambios de estado y los costos de gas. Esta previsibilidad ofrece a desarrolladores y usuarios una comprensión clara de los resultados y costos de las transacciones.

Ethereum simplifica el entorno de ejecución de contratos inteligentes al adoptar un modelo de ejecución de un solo hilo. Esto ofrece a los desarrolladores la ventaja de cambios de estado predecibles, ya que cada transacción se procesa de forma secuencial. Estos cambios predecibles hacen que el entorno de desarrollo de Ethereum sea posiblemente más accesible para los nuevos desarrolladores, pues pueden concentrarse más en la lógica de sus contratos inteligentes que en las complejidades de la ejecución. Sin embargo, esta simplicidad dificulta la escalabilidad. El procesamiento secuencial limita el rendimiento de la red. Esto puede provocar congestión, tiempos de espera más largos y comisiones de gas más altas durante los periodos de alta demanda. Como cada transacción consume gas, los desarrolladores se ven obligados a optimizar la eficiencia del gas. Esta optimización mejora la experiencia general del usuario y ayuda a combatir los periodos de congestión, en los que un código ineficiente puede hacer que las aplicaciones resulten inutilizables para el usuario promedio.

Los desarrolladores de Solana no tienen que preocuparse por optimizar el uso del gas como los de Ethereum. Solana está diseñada como una máquina de estados de alto rendimiento y baja latencia conocida como Solana Virtual Machine (SVM). Un componente esencial de la SVM es Sealevel. Es un motor de ejecución que procesa transacciones en paralelo. En Solana, cada transacción indica al entorno de ejecución qué partes del estado leerá o escribirá cuando se ejecute. El entorno procesa en paralelo las transacciones que no entran en conflicto y las que leen el mismo estado. Sealevel optimiza la ejecución de contratos inteligentes al distribuir la carga de las transacciones entre varios hilos del hardware de un validador. Así, mientras el validador procesa una transacción en un núcleo, puede procesar otra simultáneamente en otro.

El paralelismo inherente de Solana reduce considerablemente los costos de transacción. Las transacciones de Solana tienen dos comisiones: una comisión base y una comisión de prioridad. La comisión base se fija en 5000 lamports por firma; la mayoría de las transacciones solo tiene una firma. La comisión de prioridad es opcional y permite priorizar una transacción frente a otras. El planificador prioriza de forma no determinista las transacciones con una comisión de prioridad más alta. Las comisiones de transacción suelen estar por debajo de $0.001 USD, mientras que la comisión promedio de las transacciones sin voto se encuentra en el rango de 0.000005 a 0.00007 SOL. El límite superior es más alto de lo habitual debido a un aumento reciente en el uso de comisiones de prioridad. Con el precio actual de SOL de ~$98.96, esta comisión equivale aproximadamente a entre $0.000494 y $0.006968 USD. 

Estas comisiones también son predecibles. Solana utiliza mercados de comisiones localizados para gestionar la demanda. El espacio de bloques está estructurado para evitar que un foco de actividad individual (por ejemplo, la acuñación de un NFT muy popular) domine el espacio y aumente las comisiones en toda la red. Solo aumentan las comisiones de las transacciones que intentan acceder a un foco específico de alta demanda. Los mercados de comisiones localizados permiten usar comisiones de prioridad sin provocar guerras de gas generalizadas. Esta localización difiere de las redes basadas en gas como Ethereum, donde las transacciones se procesan secuencialmente y la congestión global genera comisiones volátiles.

Ethereum es un entorno de ejecución de un solo hilo que procesa un único contrato a la vez. Actualmente no aprovecha el hardware moderno con varios núcleos, por lo que desaprovecha el hardware de los validadores. El objetivo de mantener requisitos de hardware bajos para los nodos agrava las limitaciones de Ethereum para procesar transacciones. En comparación, la capacidad de procesamiento paralelo de Solana le permite procesar más transacciones al utilizar todos los núcleos disponibles de un validador. Junto con los mercados de comisiones localizados, esto convierte a Solana en una máquina de estados global con un rendimiento muy superior. 

Lenguajes de contratos inteligentes

El principal lenguaje para desarrollar contratos inteligentes en Ethereum es Solidity. Es un lenguaje de tipado estático y llaves diseñado para crear contratos inteligentes que se ejecutan en la EVM. Está muy influenciado por JavaScript, C++ y Python, por lo que resulta fácil de aprender para quienes conocen estos lenguajes.

Yul es un lenguaje intermedio de bajo nivel optimizado para blockchains compatibles con EVM. Yul ofrece a los desarrolladores mayor control sobre la ejecución del bytecode y resulta muy eficiente para ajustar con precisión el consumo de gas y gestionar otras operaciones de bajo nivel. Los desarrolladores pueden crear contratos más eficientes programando directamente en Yul o utilizándolo como destino de compilación.

Vyper es un popular lenguaje de estilo Python que prioriza la simplicidad y la seguridad. Tiene deliberadamente menos funciones que Solidity, pues busca reducir la complejidad y las posibles vulnerabilidades de seguridad. La filosofía de diseño de Vyper prioriza ante todo la legibilidad y la facilidad de auditoría. Este enfoque ha inspirado el desarrollo de lenguajes similares, como Fe, y de lenguajes compilados a Vyper, como Dasy.

Rust es la lengua franca del desarrollo de contratos inteligentes —conocidos coloquialmente como programas— en Solana. Es un lenguaje rápido y eficiente en el uso de memoria, con un rendimiento comparable al de C++. Estas características lo hacen adecuado para desarrollar aplicaciones en una red de alto rendimiento y baja latencia. El completo sistema de tipos y el modelo de propiedad de Rust garantizan la seguridad de memoria y de hilos, lo que obliga a los desarrolladores a crear aplicaciones confiables y seguras. 

Aunque Rust tiene una curva de aprendizaje pronunciada para quienes no conocen la programación de sistemas, la ventaja es que permite crear código sólido y eficiente. La mayor parte del desarrollo en Rust se realiza con Anchor. Anchor es un framework con convenciones definidas que simplifica el desarrollo de programas al reducir el código repetitivo, realizar varias comprobaciones de seguridad estándar y agilizar el proceso de (des)serialización. Esto hace que los conocimientos avanzados de Rust sean menos importantes para comenzar. Como referencia, la documentación de Anchor recomienda conocer los primeros nueve capítulos del libro de Rust (es decir, los fundamentos de Rust). Solana Playground ofrece varios tutoriales de Anchor para ayudarte a comenzar.

Aunque Rust es la opción preferida, los desarrolladores no están limitados a este lenguaje. Se puede utilizar C, C++ y cualquier lenguaje que tenga como destino el backend BPF de LLVM (es decir, cualquier lenguaje que pueda compilarse en bytecode BPF). Para quienes conocen lenguajes de estilo Python como Vyper, Seahorse Lang permite escribir programas en Python. Así, los desarrolladores obtienen la facilidad de uso de Python y conservan las mismas garantías de seguridad que si programaran en Rust. Hay varios tutoriales útiles de Seahorse, como Seahorse University y Seahorse Cookbook, para que puedas comenzar a programar en Solana hoy mismo.

Los desarrolladores que migran de Ethereum a Rust no están obligados a usar únicamente Rust. Aunque se recomienda aprender y utilizar frameworks como Anchor y Seahorse por su popularidad y garantías de seguridad, esto no siempre es viable. Gracias a los avances recientes de Solang y Neon Labs con su compilador y entorno de desarrollo compatible con EVM, los desarrolladores pueden usar Solidity para crear programas. Solidity tiene un lugar en Solana. Para comenzar a desarrollar programas con Solidity, debemos profundizar en los matices del modelo de programación de Solana. Comprender el modelo de cuentas de Solana es fundamental para los desarrolladores que realizan esta transición, pues constituye la base del desarrollo de programas y de la interacción con la red.

Comprender el modelo de cuentas

Ethereum clasifica las cuentas en dos categorías principales: cuentas de propiedad externa (EOA) y cuentas de contrato. Las EOA son el tipo de cuenta estándar de los usuarios. Están controladas por claves privadas y pueden mantener saldos de Ether, enviar transacciones e interactuar con cuentas de contrato. Por otro lado, las cuentas de contrato se distinguen porque sus operaciones se rigen por el código del contrato inteligente que contienen. No pueden iniciar transacciones de forma autónoma y solo actúan en respuesta a transacciones recibidas de EOA u otras cuentas de contrato.

Solana adopta un modelo de cuentas más uniforme y las trata como contenedores multifacéticos que almacenan datos de forma persistente. Este modelo permite que cualquier cuenta sea un programa y difumina la frontera tradicional entre una cuenta y un contrato inteligente. A diferencia de Ethereum, donde el código y el estado se combinan en una sola cuenta, los programas de Solana no tienen estado. Esto significa que no almacenan ningún estado internamente. En cambio, todos los datos que necesitan para operar se guardan en una cuenta separada y se pasan por referencia mediante una transacción. Pasar las cuentas por referencia permite desplegar un único programa genérico capaz de interactuar con distintas cuentas. El modelo de cuentas de Solana separa el código y los datos, lo que fomenta un entorno de desarrollo más eficiente y modular. Esto resulta ventajoso para los usuarios que quieren interactuar con varios protocolos sin mover activos entre diferentes programas. Todo en Solana es una cuenta. 

Las cuentas de Solana pueden clasificarse, en términos generales, como ejecutables y no ejecutables. En pocas palabras, las cuentas ejecutables pueden ejecutar código. Las cuentas no ejecutables se utilizan para almacenar datos y no pueden ejecutar código. Esto se debe a que no almacenan código.

Las cuentas ejecutables son cuentas que contienen programas. Los programas pueden ser propietarios de cuentas adicionales, leer otras cuentas o acreditarlas, modificar datos o debitar las cuentas que poseen. Las cuentas ejecutables pueden dividirse a su vez en programas on-chain o nativos. Los programas on-chain son código escrito por usuarios y desplegado en la red. Su autoridad de actualización, que suele ser la cuenta que los desplegó, puede actualizarlos. Los programas nativos son un subconjunto especial de cuentas ejecutables, análogo a los contratos precompilados de Ethereum, pero con una funcionalidad más amplia. Estos programas están integrados en el núcleo de Solana y proporcionan la funcionalidad necesaria para que operen los validadores. Un ejemplo de programa nativo es el System Program. Este programa se encarga de crear cuentas, asignar datos de cuenta, asignar cuentas a programas, transferir lamports desde cuentas de su propiedad y pagar comisiones de transacción. Puedes consultar una lista completa de programas nativos aquí.

Sin importar si son ejecutables o no ejecutables, todas las cuentas tienen los mismos campos: 

  • Un campo de lamports para registrar el saldo nativo de una cuenta en SOL
  • Un campo de datos, que hace referencia al arreglo de bytes de datos sin procesar almacenado por la cuenta
  • Un campo de propietario que indica el programa que puede modificar esta cuenta
  • Un campo de firmante, utilizado en las transacciones para indicar si la cuenta puede aprobarlas
  • Un campo de escritura para especificar si los datos de una cuenta pueden modificarse. Esto facilita el procesamiento paralelo al marcar las cuentas incluidas en las transacciones como de solo lectura o de escritura
  • Un campo ejecutable para indicar si una cuenta almacena un programa
  • Un campo de época de renta para indicar la próxima época en la que la cuenta debe pagar renta

La renta es el costo de almacenamiento para mantener activas las cuentas en Solana y garantizar que permanezcan en la memoria de los validadores. Esto exige que las cuentas mantengan un saldo mínimo para seguir activas. La renta reduce el crecimiento excesivo del estado al garantizar que la red recupere finalmente las cuentas sin uso o con fondos insuficientes. Las actualizaciones recientes han eliminado las cuentas que pagan renta en mainnet. En cambio, todas las cuentas deben estar exentas de renta al crearse. Una cuenta está exenta de renta si mantiene un saldo mínimo equivalente a dos años de pagos de renta. Puedes utilizar herramientas como Helius API Playground y el subcomando de renta de Solana CLI para calcular la cantidad de SOL necesaria para que una cuenta quede exenta de renta. Esto difiere del sistema de asignación de recursos de Ethereum, donde el almacenamiento persiste salvo que se elimine explícitamente. El enfoque de Solana ofrece una estructura de costos más predecible para almacenar el estado y, al mismo tiempo, reduce su crecimiento excesivo.

Direcciones y direcciones derivadas de programas (PDA)

Todas las cuentas se identifican mediante su dirección, una clave pública única de 32 bytes. Esto difiere del modelo de datos de Ethereum, donde las direcciones tienen 20 bytes. Solana utiliza ed25519 (es decir, un esquema de firma EdDSA que utiliza SHA-512 y la curva elíptica Curve22519) para generar direcciones. Una cuenta debe ser un punto de la curva ed25519 para tener un par de claves válido. 

Las direcciones derivadas de programas (PDA) son cuentas generadas fuera de la curva mediante un bump (es decir, un valor que desplaza el resultado fuera de la curva). Las PDA requieren tres componentes principales: la dirección de su programa principal, un conjunto de semillas y un bump. Las semillas son un arreglo de cadenas que pueden tener valores arbitrarios. Sin embargo, la mayoría de los desarrolladores crea semillas específicas relacionadas con variables de estado del programa principal para crear estructuras de datos similares a mapas hash. Así, una PDA se crea aplicando la función hash SHA-512 al ID del programa, las semillas y el bump.

El objetivo de que las PDA estén fuera de la curva es permitir que solo el programa del que se deriva una PDA pueda firmar en su nombre. Esto agiliza el flujo de transacciones al generar firmas mediante programación, de modo que las dApps sin confianza puedan funcionar sin problemas ni intervención.

Interactuar con una cuenta

Una transacción de Ethereum es una acción que cambia el estado y que inicia una EOA. Los contratos inteligentes no pueden iniciar transacciones de forma independiente; solo pueden reaccionar a ellas. El código del contrato determina estas reacciones, y el costo de ejecutar la transacción se mide en gas. Los usuarios deben proporcionar suficiente Ether para cubrir esta comisión de gas.

Las transacciones de Ethereum suelen realizar una sola operación, como llamar a una función específica de un contrato inteligente. Aunque una única transacción puede generar varios cambios de estado dentro de un contrato, todos quedan limitados al alcance de esa llamada al contrato.

En Solana, una transacción consta de un arreglo de cuentas que se leerán o escribirán, una o más firmas y una o más instrucciones. Una instrucción es una directiva para invocar un único programa. Es la unidad más pequeña de lógica de ejecución y la unidad operativa más fundamental. Las instrucciones especifican el programa que se ejecutará, todas las cuentas involucradas y los datos operativos. Los programas interpretan los datos de una instrucción y operan sobre las cuentas especificadas. Esta estructura permite que una sola transacción ejecute de forma atómica una serie de acciones en varios programas. Esto significa que todas las instrucciones se completan correctamente o fallan juntas. El flujo de transacciones de Solana difiere del modelo de Ethereum, donde una transacción suele estar vinculada a un único contrato inteligente o a una acción de una EOA.

Las invocaciones entre programas (CPI) permiten que un programa invoque a otro durante la misma transacción. La cantidad de bytes de datos de cuenta que se cobra por unidad de cómputo durante una CPI es de 250. Esto equivale aproximadamente a 50 MB con 200,000 unidades. Las CPI permiten utilizar firmas generadas mediante programación al realizar llamadas entre programas. Esto es similar a cuando un contrato inteligente de Ethereum llama a otro contrato de forma eficiente y atómica. Sin embargo, el programa invocador se detiene hasta que el programa invocado termina de procesar la instrucción. La reentrada se limita a la autorrecursión directa, con una profundidad fija máxima de 4. Esto evita situaciones en las que un programa invoca a otro desde un estado intermedio sin saber que posteriormente podrían volver a llamarlo.

Las transacciones de Solana tienen un límite de tamaño para garantizar la eficiencia, similar al límite de gas de Ethereum. Sin embargo, el enfoque está en el tamaño de los datos. Las transacciones de Solana cumplen los estándares de unidad máxima de transmisión (MTU) de IPv6 para garantizar una transmisión confiable de los datos. Después de reservar el espacio necesario para el encabezado, quedan 1232 bytes disponibles para los datos del paquete. Solana introdujo las transacciones con versiones para admitir varios formatos de transacción y superar las restricciones de tamaño. Además del formato heredado (es decir, el formato de transacción original), se lanzó la versión 0 para admitir tablas de consulta de direcciones (ALT). Las ALT almacenan direcciones on-chain en una estructura de datos similar a una tabla, donde cada dirección se indexa mediante un índice u8 de 1 byte. Esto reduce considerablemente el tamaño de las transacciones, ya que cada cuenta solo necesita 1 byte en lugar de 32 bytes.

Solang

Solang es un compilador de Solidity para Solana y Polkadot. Busca lograr compatibilidad de archivos fuente con la versión 0.8 del compilador de Solidity de la EVM, aunque con algunas variaciones para ajustarse a las arquitecturas de Solana y Polkadot. Un aspecto importante de Solang es que utiliza LLVM, una potente infraestructura de compilación. La flexibilidad de LLVM permite que Solang admita otros lenguajes de programación en el futuro y facilite las implementaciones y compilaciones. Esta característica coincide con el objetivo de Solang de facilitar la transición de los desarrolladores a Solana o Polkadot y ampliar el alcance del desarrollo con Solidity. Solang está en desarrollo continuo, con énfasis en mejorar la compatibilidad, la eficiencia y la facilidad de uso. Es fundamental que los desarrolladores de Ethereum que quieran llevar sus habilidades a otras cadenas comprendan Solang y sus particularidades.

Instalación

Hay varias formas de instalar Solang. En Mac, puedes descargar Solang con Brew mediante un tap privado:

Código
brew install hyperledger/solang/solang

Otra forma de instalar Solang es usar contenedores de Solang. Esta opción es perfecta si prefieres usar Docker, ya que las imágenes nuevas quedan disponibles automáticamente en estos contenedores. Hay una etiqueta v.0.3.3 y una etiqueta latest:

Código
docker pull ghcr.io/hyperledger/solang:latest

Una de las formas más sencillas de instalar y usar Solang es mediante Ancor. Para comenzar, asegúrate de tener Rust y Node.js instalados en tu sistema. Si usas Windows, también tendrás que configurar el Subsistema de Windows para Linux. Ahora debemos instalar el conjunto de herramientas de Solana. En Mac y Linux, puedes hacerlo con el siguiente comando:

Código
 sh -c "$(curl -sSfL https://release.solana.com/v1.17.13/install)"

Si prefieres otra versión del software, reemplaza “v1.17.13” por la etiqueta de la versión correspondiente. También puedes usar uno de estos nombres de canales simbólicos: stable, beta o edge. Según tu sistema, quizá debas actualizar la variable de entorno PATH. Si aparece este mensaje, copia y pega el comando recomendado que se muestra debajo para actualizar PATH. Puedes confirmar la versión deseada de solana ejecutando solana --version.

En Windows, abre una instancia del Símbolo del sistema como administrador. Copia y pega el siguiente comando para descargar el instalador de Solana en un directorio temporal:

Código
cmd /c "curl https://release.solana.com/v1.17.13/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"

Luego, copia y pega el siguiente comando para instalar la versión más reciente de Solana: C:\solana-install-tmp\solana-install-init.exe v1.17.13. Cuando finalice la instalación, presiona Enter.

Cierra la ventana del Símbolo del sistema y abre una nueva instancia como usuario normal. Confirma que esté instalada la versión deseada de solana ejecutando solana –-version.

A continuación, instala Anchor.

Se recomienda instalar Anchor mediante el administrador de versiones de Anchor (avm). Puedes hacerlo a través de cargo con el comando:

Código
cargo install -git https://github.com/coral-xyz/anchor avm --locked --force.

Luego, instala y usa la versión más reciente:

Código
avm install latest
avm use latest

# Verify the installation
avm –version

La versión 0.28 de Anchor permite que los desarrolladores compilen directamente con Solang. Puedes crear un proyecto nuevo de Solang con el comando anchor init project_name —solidity. Esto crea un nuevo programa de Solang y un archivo de prueba que muestra cómo interactuar con el programa mediante el cliente.

Si usas Visual Studio Code, considera instalar la extensión de Solang para facilitar el resaltado de sintaxis. Desactiva cualquier otra extensión activa de Solidity para garantizar que la extensión de Solang funcione correctamente.

Creación de un proyecto nuevo

Crea un proyecto nuevo con el comando anchor-init project_name –solidity. Esto crea un directorio nuevo con el nombre de tu proyecto. La marca de Solidity indica a Anchor que queremos usar Solang. El directorio ./solidity del proyecto incluirá un programa inicial. El contrato tendrá este aspecto:

Código
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC")
contract test {
    bool private value = true;

    @payer(payer)
    constructor() {
        print("Hello, World!");
    }

    /// A message that can be called on instantiated contracts.
    /// This one flips the value of the stored `bool` from `true`
    /// to `false` and vice versa.
    function flip() public {
            value = !value;
    }

    /// Simply returns the current value of our `bool`.
    function get() public view returns (bool) {
            return value;
    }
}

Este programa tiene un constructor para crear el programa, inicializar la variable de estado value en true y registrar “Hello, World!” en los registros del programa. La función flip actualiza la variable de estado cuando se llama. La función get devuelve el valor actual de la variable de estado. Parece un contrato inteligente normal de Solidity, con algunas particularidades. La diferencia más importante es el uso de anotaciones.

Anotaciones

Las anotaciones se usan para gestionar cuentas. Observa la anotación @program_id(“...”). Se usa para especificar la dirección on-chain del programa si se conoce de antemano. Si quieres llamar a un contrato mediante una llamada externa, el programa debe tener la notación @program_id o llamarse mediante el argumento {program_id: … }:

Código
@program_id(“...”);

contract Foo {
	function hello() public pure {
		print(“Hello”);
	}
}

contract Foo2 {
	function bye() public pure {
		print(“Bye”);
	}
}

contract Bar {
	function new_foo() external {
		Foo.new();
	}
}

contract Bar2 {
	function new_foo(address new_foo_id) external {
		Foo2.new{program_id: new_foo_id}();
	}
}

Cuando creamos un proyecto nuevo, el contrato de ejemplo proporcionado tenía la anotación @payer sobre el constructor. Esta anotación define la cuenta que pagará la inicialización de la cuenta de datos del programa. La sintaxis @payer(payer) declara una cuenta llamada payer, que será necesaria para cada llamada al constructor.

Cuando se instancia un contrato, este requiere una cuenta de programa para almacenar el código ejecutable y una cuenta de datos para guardar las variables de estado. La cuenta de datos puede crearse mediante código del lado del cliente y luego pasarse a la transacción que invoca el constructor. También puede crearla el constructor. Como mínimo, debe proporcionarse la anotación @payer. Si la cuenta de datos será una PDA, deben proporcionarse una seed y un bump. La anotación @seed especifica una seed para derivar la PDA y puede ser un literal de cadena o una cadena hexadecimal con el formato hex”1234”. Si aparece antes de un argumento, la anotación de seed debe hacer referencia a un argumento de tipo bytes, address o a un arreglo de bytes de longitud fija. La anotación @bump especifica el valor utilizado para generar una dirección fuera de la curva. Debe ser un solo byte de tipo bytes1. La anotación opcional @space puede usarse para especificar el tamaño de la cuenta de datos. Es una expresión uint64 que puede ser una constante o usar uno de los argumentos del constructor. Según la documentación de Solang, como mínimo, @space debe ser el tamaño indicado al ejecutar el comando solang -v:

Código
$ solang compile --target solana -v examples/solana/flipper.sol
...
info: contract flipper uses at least 17 bytes account data
…

Si un programa no tiene constructor, estas anotaciones pueden combinarse con un constructor vacío. La documentación de Solang ofrece el siguiente ejemplo:

Código
@program_id("Foo5mMfYo5RhRcWa4NZ2bwFn4Kdhe8rNK5jchxsKrivA")
contract Foo {

    @space(500 + 12)
    @seed("Foo")
    @payer(payer)
    constructor(@seed bytes seed_val, @bump bytes1 bump_val) {
        // ...
    }
}

Las anotaciones de funciones se usan para declarar las cuentas necesarias para las funciones externas:

  • @account(foo) declara la cuenta foo como una cuenta de solo lectura
  • @mutableAccount(bar) declara la cuenta bar como una cuenta mutable
  • @signer(fizz) declara la cuenta fizz como un firmante de solo lectura
  • @mutableSigner(buzz) declara la cuenta buzz como un firmante mutable

Las cuentas declaradas con la anotación @payer en el constructor están disponibles dentro de este. Las cuentas declaradas mediante anotaciones de funciones están disponibles en el vector tx.accounts. Por ejemplo, usarías tx.accounts.ichigo para acceder a la cuenta declarada @account(ichigo). Esto devolverá la estructura integrada AccountInfo. Esta estructura sigue la misma organización que describimos en la sección “Comprender el modelo de cuentas”. Los nombres son un poco diferentes:

  • key: la dirección o clave pública de la cuenta. Es de tipo address
  • lamports: el saldo de lamports de la cuenta. Es de tipo uint64
  • data: los datos de la cuenta. Es de tipo bytes
  • owner: el propietario de la cuenta. Es de tipo address
  • rent_epoch: la siguiente época en la que vence el alquiler de la cuenta. Es de tipo uint64
  • is_signer: especifica si la cuenta firmó la transacción. Es de tipo bool
  • is_writable: especifica si se puede escribir en la cuenta durante esta transacción. Es de tipo bool
  • executable: especifica si la cuenta es un programa. Es de tipo bool

Limitaciones

Las principales incompatibilidades entre Solang y el desarrollo tradicional en Ethereum son:

  • msg.sender no está disponible en Solana. Con el modelo de cuentas, un contrato de Rust puede acceder a varias cuentas de datos, pero ¿cuál de ellas consideraríamos el invocador? En muchos casos no podemos identificar una única cuenta como invocador. Además, el entorno de ejecución no tiene un mecanismo para obtener las cuentas invocadoras
  • No existe una función ecrecover(), pero sí una función signatureVerify() para verificar firmas ed25519.
  • Las sentencias try-catch no funcionan. El entorno de ejecución detendrá la ejecución y revertirá toda la transacción si falla alguna llamada externa o creación de contrato.
  • Las definiciones de errores y las reversiones con mensajes de error todavía no funcionan
  • La transferencia de valor nativo mediante una llamada a una función no funciona.
  • Muchas funciones integradas de Yul no están disponibles. Solang admite la mayoría de las funciones integradas, pero las operaciones de memoria y cadena no están implementadas.
  • Actualmente no se admite el formato ERC-20. Los tokens SPL se definen según el Token Program. Token Program es la forma nativa de Solana de crear, acuñar, transferir y quemar tokens. Debes copiar el archivo spl_token.sol en tu árbol de código fuente e importarlo donde sea necesario para usar la biblioteca SplToken

Además, los registros de la SVM tienen un ancho de 64 bits, por lo que los enteros de 64 bits (es decir, uint64 y int64) son preferibles a los enteros de 256 bits. Una operación con tipos de más de 64 bits, como uint256 o int256, se divide en varias operaciones. Esto las hace más lentas y consume más unidades de cómputo.

En cuanto a las direcciones, un literal de dirección debe especificarse con la sintaxis address"36VtvSbE6jVGGQytYWSaDPG7uZphaxEjpJHUUpuUbq4D". La sintaxis hexadecimal de Ethereum (por ejemplo, 0xE0f5206BBD039e7b0592d8918820024e2a7437b9) no es compatible. Todos los saldos y valores de Solana tienen un ancho de 64 bits. Esto significa que las funciones integradas para direcciones (es decir, .balance(), .transfer() e .send()) usan enteros de 64 bits.

Aunque Solang ofrece una vía interesante para que los desarrolladores de EVM se adentren en el ecosistema de Solana, tiene varias limitaciones que requieren una consideración cuidadosa. El cambio al modelo basado en cuentas de Solana no es meramente sintáctico: representa un cambio fundamental en la lógica de los contratos inteligentes. Algunas funciones, patrones de programación y características específicas de la EVM no están disponibles con Solang. Los desarrolladores no pueden portar un contrato inteligente de Ethereum a Solang y esperar que funcione sin ajustes importantes. La ausencia de características, como definiciones de errores adecuadas y reversiones con mensajes de error, puede ser bastante perjudicial. Sin embargo, es importante reconocer que Solang es una herramienta en evolución constante y que cada actualización busca mejorar la experiencia de desarrollo con Solidity en Solana. Solang ofrece varias ventajas claras para mejorar esta experiencia.

Ventajas

A pesar de estas limitaciones, existen varias funciones integradas y decisiones de diseño que mejoran la experiencia de desarrollo. Por ejemplo, los contratos desarrollados en Solang pueden interactuar con programas de Anchor. Esto puede hacerse al generar una interfaz de Solidity a partir de la IDL de un programa de Anchor. IDL significa “lenguaje de descripción de interfaces”. En esencia, es un archivo JSON que contiene todas las especificaciones de un programa. Incluye todo lo que necesitas saber para interactuar con un programa de Anchor. Anchor genera automáticamente una IDL cuando desarrollas un programa con su framework. Esto es muy similar a las ABI de Ethereum. Para generar una interfaz de Solidity a partir de una IDL, usa el siguiente comando: solang idl [-output directory] [IDL file]. Ahora puedes importar el archivo con la sintaxis import “...”;.

Solang proporciona la biblioteca de Solana, una serie de bibliotecas que permiten a los contratos de Solidity interactuar con instrucciones específicas de Solana. Solang proporciona la biblioteca SPL Token para acuñar, quemar y transferir tokens. Puede considerarse un equivalente de ERC-20 y ERC-721. Solang también proporciona la biblioteca de instrucciones del sistema para que los desarrolladores puedan interactuar con System Program de Solana.

Solang también incluye algunas funciones integradas que pueden importarse con solana. Esto incluye las estructuras AccountMeta e AccountInfo. La estructura AccountMeta se usa para especificar qué cuentas deben pasarse al destinatario en una llamada externa (es decir, una CPI). La estructura AccountMeta tiene la siguiente organización:

  • pubkey: la dirección o clave pública de la cuenta. Es de tipo address
  • is_writable: especifica si el destinatario puede escribir en esta cuenta. Es de tipo bool
  • is_signer: especifica si el destinatario puede asumir que esta cuenta firmó la transacción. Es de tipo bool

Si el argumento accounts se omite en una llamada externa, el compilador de Solang genera automáticamente un arreglo AccountMeta. Esto solo funciona si la función se declara como externa. De lo contrario, el arreglo AccountMeta debe crearse manualmente según el orden de cuentas especificado en la IDL. Si una llamada determinada no necesita cuentas, pasa un vector vacío: {accounts: []}. La documentación de Solang ofrece un ejemplo claro de cómo crear el arreglo AccountMetas:

Código
function build_this() external {
	// When calling a constructor from an external function, the data account for the contract
	// 'BeingBuilt' should be passed as the 'BeingBuilt_dataAccount' in the client code.
	BeingBuilt.new("my_seed");
}

function build_that(address data_account, address payer_account) public {
	AccountMeta[3] metas = [
		AccountMeta({
			pubkey: data_account,
      is_signer: true,
      is_writable: true
		}),
    AccountMeta({
    	pubkey: payer_account,
      is_signer: true,
      is_writable: true
    }),
    AccountMeta({
      pubkey: address"11111111111111111111111111111111",
      is_writable: false,
      is_signer: false
    })
  ];
  BeingBuilt.new{accounts: metas}("my_seed");

	// No accounts are needed in this call, so we pass an empty vector.
	BeingBuilt.say_this{accounts: []}("It's summertime!");
}

Solang también tiene funciones integradas para:

Solang conecta Solana y Ethereum mediante un compilador con un amplio conjunto de herramientas que facilita la transición para los desarrolladores de EVM. A pesar de sus limitaciones, Solang ofrece varias características que mejoran la experiencia de desarrollo, como la capacidad de interactuar con programas de Anchor, acceder a bibliotecas específicas de Solana y usar funciones integradas. La integración de conceptos conocidos, como las IDL y los estándares de tokens, facilita aún más la curva de aprendizaje. No tener que preocuparse por el gas ni optimizarlo es una incorporación bienvenida. Solang representa un paso importante hacia la interoperabilidad entre Solana y Ethereum. Para los desarrolladores de EVM que buscan adentrarse en el mundo de alto rendimiento de Solana, Solang se presenta como una posible herramienta.

Neon EVM

Solang no es la única opción para los desarrolladores de Solidity que quieren crear en Solana. Neon EVM se describe como la primera EVM paralelizable del mundo. Es un entorno de Ethereum totalmente compatible en Solana. Es una solución sinérgica para quienes buscan escalar dApps de Ethereum en Solana de una forma sencilla para los desarrolladores. Los desarrolladores pueden implementar sus dApps sin reconfigurar sus contratos inteligentes, escritos en los lenguajes y con las herramientas que prefieren.

Arquitectura

Neon EVM consta de tres componentes principales: el programa Neon EVM, Neon Proxy y Neon DAO.

Neon EVM es un programa de Solana que acepta transacciones similares a las de Ethereum y las procesa en Solana según las reglas de la EVM. Estas transacciones similares a las de Ethereum dirigidas a Neon EVM se denominan transacciones de Neon. Son un subconjunto de métodos JSON RPC de acuerdo con la API JSON-RPC de Ethereum.

Neon Proxy permite que los desarrolladores de Ethereum porten sus dApps a Neon con cambios mínimos. Empaqueta transacciones de la EVM dentro de transacciones de Solana y funciona como una solución en contenedores para los operadores de Neon. Estos operadores ejecutan servidores de Neon Proxy, aceptan pagos en NEON y realizan pagos dentro del ecosistema de Solana en SOL. NEON es tanto un token de utilidad como de gobernanza: los operadores de Neon lo cobran para pagar las tarifas de gas necesarias para ejecutar transacciones, y los propietarios pueden participar en Neon DAO.

Neon DAO es un modelo de gobernanza dirigido por la comunidad y diseñado para dar a los titulares de tokens NEON poder en los procesos de toma de decisiones de Neon EVM. Está formado por usuarios, operadores, colaboradores y desarrolladores principales y de aplicaciones, quienes deliberan de forma colectiva sobre las reglas de gobernanza y la evolución del protocolo. La DAO opera mediante varias asambleas descentralizadas enfocadas en el ecosistema, el desarrollo y la seguridad. Cada asamblea facilita la toma colaborativa de decisiones y la evaluación de propuestas de su ámbito correspondiente. La asamblea enfocada en el ecosistema supervisa su crecimiento sostenible y administra fondos para subvenciones e iniciativas. La asamblea enfocada en el desarrollo gestiona las actualizaciones técnicas del programa Neon y las intervenciones de emergencia. La asamblea enfocada en la seguridad protege la tesorería de Neon y el programa Neon frente a posibles amenazas.

Compatibilidad con EVM

Neon EVM facilita las interacciones con la EVM en Solana mediante las siguientes acciones:

  • Implementa la mayoría de los métodos de la API JSON-RPC de Ethereum
  • Usa un proxy especial para gestionar las llamadas de Ethereum
  • Se adapta a las diferencias y limitaciones de la arquitectura de Solana

Interactuar con Neon EVM es similar a hacerlo con cualquier otra EVM. Los desarrolladores pueden usar métodos conocidos de la API RPC dirigidos a Neon Proxy, lo que facilita una experiencia de desarrollo fluida. Entre sus características principales se incluyen:

  • Compatibilidad con contratos inteligentes de Solidity y Vyper, además de herramientas estándar de desarrollo de Ethereum como Metamask, Foundry y Remix
  • Compatibilidad literal con la mayoría de los opcodes de Ethereum
  • Aceptación de solicitudes de transacciones de Ethereum de tipo 0 o heredadas. Actualmente no se admiten transacciones EIP-1559

Por supuesto, Neon EVM necesita ciertas adaptaciones para funcionar correctamente en Solana. Entre las diferencias destacadas se incluyen:

  • Neon EVM admite todos los contratos precompilados definidos en evm.code. Sin embargo, no se ejecutarán los contratos de Solidity que contengan las siguientes llamadas: bigModExp, bn256Add, bn256ScalarMult e bn256Pairing. Neon EVM necesita implementar llamadas al sistema de Solana para admitir estos contratos en el futuro
  • Aunque la mayoría de los opcodes se admiten literalmente, los opcodes COINBASE, PREVRANDAO (FKA DIFFICULTY), GASLIMIT, BASEFEE e GAS no se admiten de esta forma. Se conocen como opcodes variantes y están adaptados para usarse en Neon EVM.
  • El consumo de gas y los cálculos de tarifas difieren de Ethereum. Por lo general, generan costos más bajos debido al papel de Solana como capa de liquidación
  • Los métodos transfer() e send() de Solidity no son seguros frente a la reentrada en Neon EVM debido a los distintos cálculos de gas
  • El modelo de cuentas de Solana afecta el almacenamiento de los contratos inteligentes, con distintas funciones de almacenamiento y permisos de acceso para las cuentas ejecutables y no ejecutables
  • Neon EVM usa transacciones con versiones, lo que limita a 64 el número máximo de cuentas utilizadas en una sola transacción
  • Neon EVM usa el filtro de paquetes de Berkeley (BPF) de Solana con un límite de memoria heap de 256 KB. Esto restringe el tamaño de las llamadas a contratos y exige estrategias de optimización para gestionar eficazmente el uso de memoria
  • Las funciones basadas en el tiempo, como block.number e block.timestamp, se comportan de manera diferente. Se recomienda encarecidamente a los desarrolladores que no las usen al desarrollar en Neon EVM

Aunque Neon EVM proporciona un entorno conocido y compatible, los desarrolladores de EVM deben conocer las diferencias clave y adaptarse a ellas para migrar y crear correctamente en Solana.

Conexión a un RPC de Neon

Los desarrolladores pueden conectarse fácilmente a un RPC de Neon mediante Chainlist. Aquí pueden conectarse a la Mainnet o la Devnet de Neon EVM. Haz clic en Conectar billetera en la ventana modal de Mainnet o Devnet y, cuando aparezca tu billetera, haz clic en Aprobar.

Debes elegir el operador óptimo antes de enviar transacciones a Neon EVM. Expande los detalles de la tarjeta para ver los endpoints RPC disponibles para cada red:

Si eliges un operador distinto del predeterminado durante la conexión de la billetera, tendrás que conectarte manualmente. La documentación de Neon EVM ofrece guías completas para conectarse a un Proxy mediante Foundry, Hardhat, Remix y Truffle. En la sección de implementación explicaremos cómo conectarse con Foundry.

Una vez conectados, los desarrolladores pueden usar el faucet de Neon para obtener NEON u otros tokens de prueba ERC-20. También pueden usar el endpoint request_neon para solicitar tokens mediante programación:

Código
curl -i -X POST \
	-d '{"wallet": "Your wallet", "amount": 1}' \
	'http://localhost:3333/request_neon'

Este comando envía una solicitud POST para recibir tokens en la dirección de billetera especificada.

Ciclo de vida de las transacciones y tarifas de gas

Hay tres pasos principales para ejecutar una transacción desde una dApp de Ethereum en Solana mediante Neon EVM:

  • Un usuario inicia una transacción firmada similar a las de Ethereum y la dirige a un endpoint RPC de Neon
  • La transacción se pasa a Neon Proxy mediante la API de Ethereum. El Proxy estima el gas necesario para ejecutar la transacción, inicia una difusión al envolver la transacción similar a las de Ethereum dentro de una transacción de Solana y envía la transacción envuelta a Neon EVM. Esto genera un recibo de Solana y el correspondiente recibo de la transacción en Neon EVM. El contrato inteligente de Neon desenvuelve la transacción, verifica la firma del usuario y carga el estado de la EVM desde el almacenamiento de Solana. La transacción se ejecuta dentro del BPF de Solana
  • Solana y Neon EVM actualizan sus estados para completar la solicitud de transacción

Este es el ciclo de vida completo de una transacción en Neon EVM, desde el inicio hasta la ejecución. Los desarrolladores pueden visitar NeonScan para ver las transacciones y los bloques más recientes, y consultar cuentas, tokens, bloques o hashes de transacciones.

Los desarrolladores también pueden enviar transacciones sin gas. Esta función se implementó para ayudar a usuarios sin suficientes tokens NEON para cubrir las tarifas de sus transacciones iniciales. Los desarrolladores pueden obtener un paquete inicial de transacciones sin gas al comunicarse con info@neonevm.org. El operador de Proxy elegido por el desarrollador seguirá gestionando estas transacciones, pero Neon cubrirá el costo. Por lo general, se ofrecen al menos tres transacciones sin gas por cada cuenta nueva de Neon.

El proceso para las transacciones sin gas es el siguiente:

  • Un usuario final inicia una transacción mediante una dApp
  • La dApp solicita el precio actual del gas al operador de Proxy elegido. Si la cuenta cumple los requisitos, el operador de Proxy marca la cuenta de Neon para un número determinado de transacciones sin gas
  • Para esas transacciones, la dApp mostrará un costo de gas de cero
  • El usuario final firma la transacción sin tarifa de gas
  • El operador de Proxy ejecuta la transacción, y Neon Foundation paga la tarifa de gas en SOL

La documentación de Neon EVM proporciona el siguiente extracto para mostrar cómo solicitar una transacción sin gas:

Código
try {
	// Get gasless transaction if user account is eligible
  const rawGasPrice = await axios.post(rpcApiUrl, {
  	method: 'neon_gasPrice',
    params: [{ from: address }],
    jsonrpc: "2.0",
    id: new Date().getTime()
   })

   tx.gasPrice = rawGasPrice.data?.result;
	} catch (e) {
  	//Else, get standard GAS price
   	setError('Can\'t retrieve gas price for transaction')

    const rawGasPrice = await web3.eth.getGasPrice();

    tx.gasPrice = web3.utils.toHex(rawGasPrice);
} finally {
    setTx(tx)
}

NeonPass

NeonPass es una herramienta para transferir tokens entre Solana y Neon EVM. Permite transferir activos sin inconvenientes entre las cuentas de tokens asociadas de Solana y las cuentas de tokens ERC-20 de Neon EVM. NeonPass usa el contrato de interfaz y el almacenamiento especializado de cuentas de Neon EVM. Los tokens de Solana Program Library (SPL) se empaquetan en una interfaz ERC-20 dentro del contrato factory de Neon EVM. Esto permite almacenar los SPL en cuentas de tokens ERC-20 compatibles con dApps de Solidity. NeonPass permite transferir tokens de forma bidireccional entre cuentas de Solana y Neon EVM. A diferencia de los puentes tradicionales, que bloquean y acuñan activos nuevos, NeonPass mueve los tokens directamente entre los dos tipos de cuentas. Esto permite una transición fluida de los tokens de Solana y Neon EVM.

Implementación

Los desarrolladores pueden implementar en Neon EVM mediante Hardhat, Foundry, Truffle y Remix. Como la forma más sencilla de usar Solang es mediante Anchor, todas las pruebas se realizan en TypeScript. Sin embargo, por fin podemos probar e implementar dApps de Solidity en Solana mediante Foundry, para todos los maximalistas de Solidity.

Primero, asegúrate de tener una billetera compatible con EVM conectada a la Devnet de Neon EVM. Luego, clona el proyecto de ejemplo de Foundry de Neon y navega hasta él:

Código
git clone https://github.com/neonlabsorg/neon-tutorials
cd neon-tutorials/foundry

Luego, instala Foundryup, el instalador de la cadena de herramientas de Foundry, y ejecuta foundryup para instalar los binarios precompilados más recientes (nightly), es decir, force, cast, anvil y chisel:

Código
curl -L https://foundry.paradigm.xyz | bash
foundryup

Instala las bibliotecas necesarias:

Código
forge install foundry-rs/forge-std --no-commit
forge install openzeppelin/openzeppelin-contracts --no-commit

Ahora, obtén la clave privada de tu cuenta de billetera. En Metamask, por ejemplo, puedes ver tu clave privada al hacer clic en el menú de tres líneas y navegar hasta Account Details > Show Private Key. Se te pedirá que ingreses tu contraseña. Haz clic en Confirmar para acceder a la clave privada de tu cuenta. Recuerda no compartir esta clave con nadie y toma las medidas necesarias para protegerla.

Luego, crea un archivo .env con las siguientes variables:

Código
RPC_URL_DEVNET=https://devnet.neonevm.org
CHAIN_ID_DEVNET=245022926
RPC_URL_MAINNET=https://neon-proxy-mainnet.solana.p2p.org
CHAIN_ID_MAINNET=245022934
PRIVATE_KEY=
VERIFIER_URL_BLOCKSCOUT=https://neon-devnet.blockscout.com/api

Reemplaza <YOUR_PRIVATE_KEY> por tu clave privada y ejecuta source .env.

Para compilar los contratos del proyecto, navega al directorio src y ejecuta forge build. La consola debería indicar que la ejecución del compilador se completó correctamente. También puedes probar los contratos con el comando forge test. Para implementar el contrato del proyecto, ejecuta el siguiente comando:

Código
forge create --rpc-url $RPC_URL_DEVNET --private-key $PRIVATE_KEY src/TestERC20/TestERC20.sol:TestERC20 --constructor-args "Test ERC20 Token" "TERC20" --legacy

Deberías ver una salida similar a la siguiente:

Código
[⠰] Compiling...
No files changed, compilation skipped
Deployer: 0x4455E84Eaa56a01676365D4f86348B311969a4f4
Deployed to: 0x5537599aa2F97Dd60a66342522a465A7f2e40Ff9
Transaction hash: 0x6de9dab8a526cbac33008056d185b93dff725605efb791bf116b6bece4f0c486

Para verificar tu contrato, ejecuta el siguiente comando:

Código
forge verify-contract --chain-id $CHAIN_ID_DEVNET  src/TestERC20/TestERC20.sol:TestERC20 --verifier-url $VERIFIER_URL_BLOCKSCOUT --verifier blockscout

Reemplaza <contract_address> por la dirección de tu contrato inteligente. Deberías recibir una respuesta OK con una URL que apunte a la dirección del contrato en BlockScout, el explorador de Devnet de Neon. También puedes configurar tu archivo .env para usar NeonScan en lugar de BlockScout, que también admite devnet.

Ventajas y limitaciones

Los desarrolladores que quieran una experiencia de desarrollo similar a la de Ethereum deberían elegir Neon EVM. Es un entorno compatible con EVM que envía transacciones similares a las de Ethereum y usa herramientas conocidas. Características como NeonPass, la compatibilidad con la mayoría de los opcodes de EVM y las transacciones sin gas facilitan mucho la transición a Solana. Sin embargo, Neon EVM no es perfecto. Presenta ciertas limitaciones, como cambios en la lógica de los contratos inteligentes para adaptarse a la infraestructura de Solana, el funcionamiento dentro de las restricciones del filtro de paquetes de Berkeley (BFP) y de los modelos de cuentas de Solana, y ciertas restricciones en opcodes y contratos precompilados. Comprender y abordar estos matices es fundamental para implementar correctamente en Solana desde un entorno compatible con EVM.

Migraciones anteriores

Un protocolo grande de Ethereum debe completar varias tareas complejas para desplegarse en una cadena no EVM. En concreto, debe contratar ingenieros que no trabajen con Solidity para reconstruir su código base desde cero, encontrar socios de auditoría confiables, volver a auditar el nuevo código base y adaptar los contratos de gobernanza para hacer cumplir las decisiones de la DAO. Estas tareas pueden costar millones de dólares y requerir meses de trabajo dedicado. No es viable para la mayoría. Sin embargo, ya ha ocurrido antes.

Helium es una red LoRaWAN cuyo objetivo es crear una infraestructura inalámbrica descentralizada para admitir dispositivos del Internet de las cosas (IoT). Para ello, utiliza hotspots: dispositivos pequeños y de bajo consumo similares a torres de telefonía celular en miniatura que se conectan con otros hotspots a grandes distancias. Helium operaba originalmente en su propia blockchain de capa 1 (L1), pero su equipo de desarrollo propuso migrar a Solana mediante HIP 70. La migración permitiría que Helium consiguiera una mayor disponibilidad, más composabilidad y una experiencia de usuario más rápida, sin dejar de ofrecer un alto nivel de seguridad y un bajo costo de uso. La comunidad votó de forma abrumadora a favor de la propuesta y Helium migró a Solana en abril de 2023. Scott Sigel, director de operaciones de Helium, describió la migración como un evento aburrido - nada salió mal con la red ni con la infraestructura de Helium. Fue el sueño de cualquier ingeniero. El equipo también documentó todo el proceso de migración en una serie de guías en su documentación. La migración de Helium fue un gran éxito y aportó enormes beneficios a la comunidad.

Esta migración no es un caso aislado. The Render Network, la primera plataforma descentralizada de renderizado con GPU del mundo, actualizó con éxito su infraestructura central de Ethereum a Solana en noviembre de 2023. La comunidad votó a favor de RNP-002 para migrar a Solana. Jules Urbach, fundador de Render, describió la migración como un momento decisivo. Declaró: “Las increíbles velocidades de transacción de Solana, sus bajos costos y su compromiso con una arquitectura a escala web la convierten en la opción perfecta para Render Network mientras seguimos desarrollando una infraestructura de metaverso escalable y descentralizada”.

La migración de Render no tuvo un efecto demasiado negativo en sus usuarios. Los usuarios pueden transferir fondos de Ethereum a Solana mediante Upgrade Assistant de Render. Los usuarios conectan su billetera de Ethereum, indican la cantidad de RNDR que desean migrar y esperan a que sus tokens lleguen a la billetera de Solana especificada. 

Maker es un proyecto emblemático de Ethereum. Su objetivo es liberar el potencial de las finanzas descentralizadas mediante Maker Platform, una plataforma inclusiva diseñada para mejorar el empoderamiento económico y la igualdad de acceso al mercado financiero mundial. La plataforma consta de MakerDAO, que administra el proyecto Maker, y Maker protocol para DAI, “la primera moneda imparcial del mundo y la principal stablecoin descentralizada”.Rune Christensen, fundador de Maker, publicó en Twitter sobre el uso de un fork del código base de Solana para desarrollar una appchain de Maker: 

Las migraciones son complejas por naturaleza. A pesar de los costos económicos, reputacionales y de tiempo que supone migrar toda la infraestructura de un proyecto de Ethereum a Solana, los proyectos eligen Solana. Con herramientas como Solang y Neon EVM, las migraciones no tienen por qué ser complejas. Como ocurrió con la migración de Helium, pueden ser aburridas y tener poco o ningún impacto adverso en los fondos de los usuarios, tal como sucedió con Render Network. Solana es la blockchain con el mejor rendimiento del mercado y está diseñada para operar a escala web. Este es el lugar para desarrollar, y cada vez más proyectos se dan cuenta de ello.

Conclusión

Solidity es la lingua franca del desarrollo de contratos inteligentes. EVM ha sido el entorno dominante para contratos inteligentes desde su creación. Sin embargo, tiene sus debilidades. Las aplicaciones a escala web y orientadas al consumidor necesitan una red de alto rendimiento y baja latencia para operar. El entorno de Ethereum, basado en gas volátil y de un solo hilo, no puede admitir un proyecto de red de infraestructura física descentralizada (DePIN) con un alto volumen de procesamiento como Helium. 

Ante estos desafíos, Solana surge como una alternativa potente. La mejor forma de aprovechar los verdaderos beneficios de Solana es desarrollar directamente en Solana. Gracias a los avances recientes, herramientas como Solang y Neon EVM permiten que los desarrolladores de EVM interesados migren con herramientas y lenguajes conocidos. Este artículo ofrece una guía completa sobre la arquitectura de Solana, cómo se compara con Ethereum y cómo un desarrollador de EVM podría comenzar a desarrollar en Solana. Solana es la blockchain con el mejor rendimiento del mercado. Está ganando impulso, reconocimiento y aplicaciones orientadas al consumidor de gran prestigio. ¿Por qué esperar a que Ethereum escale cuando puedes disfrutar hoy de los beneficios de una blockchain rápida y escalable?

Si llegaste hasta aquí, ¡gracias, anon! Ingresa tu dirección de correo electrónico abajo para no perderte ninguna novedad sobre Solana. ¿Quieres profundizar más? Únete a nuestro Discord para comenzar hoy a construir el futuro sobre la blockchain con el mejor rendimiento.

Más recursos

Suscríbete a Helius

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

Imagen ampliada