Cómo migrar contratos inteligentes de Solidity de Ethereum a Rust de Soroban

En este tutorial, exploraremos las complejidades de dos importantes entornos de programación de contratos inteligentes: Solidity de Ethereum y Rust SDK de Soroban y por qué deberías considerar migrar tus contratos inteligentes a Rust.

En el ámbito de blockchain y contratos inteligentes, Rust es una opción destacada para los desarrolladores, y aquí está el porqué:

• Velocidad y eficiencia: Rust se desplaza por las tareas como un coche deportivo con estilo. Es súper rápido, incluso superando a C++ en términos de velocidad y eficiencia para que tus operaciones en blockchain no solo sean rápidas sino que también ahorren en recursos computacionales.
• Seguridad de Tipo: Imagina el sistema de tipos de Rust como un inspector meticuloso, que está observando cada bit de tu código en tiempo de compilación. Esto significa menos errores y un entorno más seguro para tus contratos inteligentes.
• Seguridad de Memoria Sin Sobrecarga: Rust presume de una seguridad de memoria de primera, actuando como un escudo invisible contra vulnerabilidades críticas en el mundo de blockchain. Y lo hace de manera eficiente sin necesitar un recolector de basura, manteniendo tus proyectos ágiles y fortificados.
• Conquistando la Concurrencia con Facilidad: En blockchain, manejar transacciones simultáneas es como hacer malabares con bolas de fuego. Rust sobresale en gestionar múltiples operaciones sin problemas, previniendo las complicaciones comunes vistas en otros lenguajes. Esto lleva a un procesamiento de transacciones más rápido y seguro, mejorando el rendimiento general de tus contratos inteligentes.

Rust combina velocidad, seguridad y eficiencia de ejecución haciéndolo un lenguaje ideal para el desarrollo de blockchain donde tales cualidades son demandadas. Entonces, ¿cómo se compara Rust con Solidity?

Abre el remix-ide en tu navegador navegando a: remix.ethereum.org/

Haz clic en el icono de “crear nuevo archivo” en la pestaña "Explorador de Archivos".

Escribe el nombre del archivo “HelloWorld.sol” e introduce el siguiente código en el ide:

```

// SPDX-License-Identifier: MIT

// compiler version must be greater than or equal to 0.8.20 and less than 0.9.0

pragma solidity >=0.7.0 <0.9.0;




contract HelloWorld {

function hello(string memory to) public pure returns(string memory){

string memory greeting = string(abi.encodePacked("hello ", to));

return greeting;

}

}

```

Una vez que el código está en Remix, haz clic en el icono de "Compilador de Solidity" debajo del icono de “Explorador de Archivos”.

Luego, haz clic en “Compilar HelloWorld.sol” o simplemente presiona `cmd+s`

Una vez compilado exitosamente haz clic en el icono debajo de “Compilador de Solidity” que es “Desplegar y Ejecutar Transacciones”.

Sin cambiar ninguno de los valores mostrados arriba simplemente haz clic en el botón “Desplegar” para desplegar tu contrato inteligente. Una vez desplegado encontrarás tu contrato inteligente justo debajo en el encabezado “Contratos Desplegados”.

Haz clic en “>” antes de tu contrato verás un botón “hello” abajo ya que nuestro contrato tiene una variable de función hello que devuelve una cadena compuesta de “hello” + el valor que pasaste para el argumento `to`.

Define un valor para to y luego haz clic en el botón “hello” para devolver el saludo.

¡Bien hecho! Ahora vamos al meollo del asunto.

```
#![no_std]
```

Esta directiva se usa al principio del código Rust para especificar que la biblioteca estándar (std) no debe incluirse en la construcción. En los contratos de Soroban, la biblioteca estándar se excluye porque es grande y no adecuada para el despliegue en blockchains.

```
use soroban_sdk::{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec};
```

• La **palabra clave use** se utiliza para importar dependencias externas o módulos al código Rust actual.
• **soroban_sdk**: Este es el crate/módulo que proporciona las funcionalidades y tipos necesarios para los contratos de Soroban.
• **{contract, contractimpl, symbol_short, vec, Env, Symbol, Vec}**: Estos son los elementos específicos que se importan del **módulo soroban_sdk** incluyendo atributos, macros **(contract, contractimpl, symbol_short!)**, y tipos de datos **(Env, Symbol, Vec)**.

```
#[contract]
pub struct Contract;
```

• **#[contract]** es un atributo aplicado al struct Contract, designándolo como el tipo al cual se asocian las funciones del contrato. Implica que este struct tendrá funciones de contrato implementadas para él.
• **pub struct Contract;** define un struct público llamado Contract. En los contratos de Soroban, las funciones del contrato se asocian con este struct.

```
#[contractimpl]
impl Contract {
    pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> {
        vec![&env, symbol_short!("Hello"), to]
    }
}
```

• **#[contractimpl]** es un atributo que se aplica al bloque **impl** para el struct **Contract**, indicando que este bloque contiene la implementación de funciones del contrato.
• **impl Contract { ... }**: Este es el bloque de implementación para el struct Contract, donde se definen las funciones del contrato.
• **pub fn hello(env: Env, to: Symbol) -> Vec<Symbol> { ... }**: Esta línea define una función pública llamada **hello**. Toma dos argumentos, **env** de tipo **Env** y "to" de tipo **Symbol**(en este caso, una cadena de hasta 8 caracteres). También especifica el tipo de retorno como **Vec<Symbol>**
• **{ vec![&env, symbol_short!("Hello"), to] }**: Este bloque de código es donde se construye y devuelve un vector/arreglo de longitud 2 que contiene "Hello" y luego el valor pasado como "to".

Eso es todo el descanso que tenemos por hoy. ¡No te pongas gruñón conmigo! (🥁)