Cómo migrar contratos inteligentes del Solidity de Ethereum al Rust de Soroban

En este tutorial, exploraremos las complejidades de dos importantes entornos de programación de contratos inteligentes: Solidity de Ethereum y el SDK de Rust 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 avanza a través de las tareas como un coche deportivo con estilo. Es super rápido, incluso superando a C++ en cuanto a velocidad y eficiencia para que tus operaciones de blockchain no solo sean rápidas sino que también ahorren en recursos informáticos.
• Seguridad de Tipo: Imagina el sistema de tipos de Rust como un inspector meticuloso, que está observando cada bit de tu código en el momento de la 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 conduce 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 "Solidity Compiler" debajo del icono de “File Explorer”.

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

Una vez compilado con éxito haz clic en el icono debajo de “Solidity Compiler” que es “Deploy & Run Transactions”.

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

Haz clic en “>” antes de tu contrato y verás un botón “hello” abajo, ya que nuestro contrato tiene una variable de función hello que devuelve una cadena compuesta por “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 con el verdadero McCoy!

```
#![no_std]
```

Esta directiva se utiliza 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 es adecuada para el despliegue en blockchains.

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

• La palabra **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 **soroban_sdk** módulo, 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 que 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 las 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/array 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!(🥁)