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 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 se desliza por las tareas como un auto deportivo con estilo. Es super 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.
• Dominando 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 en 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 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 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 a la estructura Contract, designándola como el tipo al que se asocian las funciones de contrato. Implica que esta estructura tendrá funciones de contrato implementadas para ella.
• **pub struct Contract;**define una estructura pública llamada Contract. En los contratos de Soroban, las funciones de contrato están asociadas con esta estructura.

```
#[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 la estructura **Contract**, indicando que este bloque contiene la implementación de funciones de contrato.
• **impl Contract { ... }**: Este es el bloque de implementación para la estructura Contract, donde se definen las funciones de 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 por hoy. ¡No te pongas gruñón conmigo! (🥁)