¿Qué es Yul?

Publicado el 28 de julio de 20234 min de lectura

Yul es un lenguaje de programación intermedio programming language que se puede usar para escribir una forma de lenguaje ensamblador dentro de smart contracts. Aunque solemos ver Yul usado dentro de smart contracts, es posible escribir un smart contract completo en Yul.

Entender Yul puede llevar tus smart contracts a otro nivel y permitirte entender qué sucede por debajo en solidity, lo que a su vez puede ayudarte a reducir los costos de gas de los usuarios.

Podemos identificar Yul en un smart contract con la siguiente sintaxis.

En el resto de este artículo, veremos los conceptos básicos del uso de Yul mediante ejemplos, y te invitamos a seguirlo en Remix.

Asignación de variables, operaciones y evaluaciones en yul

El primer tema que debemos cubrir son las operaciones simples. Yul tiene +, -, , /, %, , <, >, y =.

Nota que >= y <= no están incluidos en la lista de operadores disponibles en Yul porque Yul no cuenta con estos operadores. Además, en lugar de que las evaluaciones sean iguales a true o false, son iguales a 1 o 0, respectivamente. Dicho esto, ¡empecemos a aprender un poco de Yul!

Instruction	Explanation
let	Esto es necesario antes de definir una variable. Dado que todos los valores son bytes, no hace falta asignar un tipo de valor.
:=	Equivalente en Solidity: x = y
add(x,y)	Equivalente en Solidity: x + y
sub(x,y)	Equivalente en Solidity: x - y
mul(x,y)	Equivalente en Solidity: x * y
div(x,y)	Equivalente en Solidity: x / y (o 0 si y es igual a 0)
mod(x,y)	Equivalente en Solidity: x % y (o 0 si y es igual a 0)
lt(x,y)	Equivalente en Solidity: x < y
gt(x,y)	Equivalente en Solidity: x > y
eq(x,y)	Equivalente en Solidity: x == y
iszero(x)	Equivalente en Solidity: x == 0

Veamos rápidamente un ejemplo antes de continuar.

For loops e if statements en yul

Para aprender tanto sobre for loops como sobre if statements, escribamos una función que cuente cuántos números son pares en una serie.

La sintaxis de los if statements es similar a la de Solidity, pero no es necesario poner la condición entre paréntesis.

Para el for loop, nota que usamos llaves al declarar i e incrementar i, pero no al evaluar la condición. Además, usamos un continue para saltar una iteración del loop. También podemos usar break statements en Yul.

Cómo funciona el storage en yul

Hay 2²⁵⁶ slots para un smart contract. Al declarar variables, empezamos con el slot 0 e incrementamos a partir de ahí. Cada slot tiene 256 bits de longitud (32 bytes); de ahí vienen los nombres uint256 y bytes32. Todas las variables se convierten a hexadecimal. Si se usa una variable, como un uint128, no se ocupa un slot completo para almacenarla. En su lugar, se rellena con 0's del lado izquierdo.

Para aprender más sobre cómo funciona el storage en Yul, lee nuestro otro artículo que cubre:

Arrays
Arrays dinámicos
Mappings
Mappings anidados

Cómo leer y escribir variables empaquetadas en yul

Empaquetar variables significa ordenarlas de manera que la suma de su almacenamiento sea menor a 32 bytes para que puedan caber juntas en un slot. Empaquetar variables puede ahorrar gas, y es una técnica esencial para los optimizadores de smart contracts.

Por ejemplo, 0x000000000000000000000000000002 y 0x000000000000000000000000000001 encajan perfectamente juntos en el mismo slot porque ambos ocupan 16 bytes (la mitad de un slot).

Para aprender más sobre cómo leer y escribir variables de storage empaquetadas en Yul, ¡lee nuestro análisis a fondo!

¿Cómo funciona la memoria en yul?

La memoria se comporta de forma distinta al storage, ya que no es persistente (es decir, una vez que la función termina de ejecutarse, todas las variables se borran). Algunos usos de la memoria en Yul son:

Devolver valores para llamadas externas
Establecer valores de función para llamadas externas
Obtener valores de llamadas externas
Revertir con un mensaje de error
Registrar mensajes (logging)

Para aprender más sobre cómo funciona la memoria en Yul, ¡lee nuestro otro artículo que profundiza en el tema!

¿Cómo funcionan las llamadas a contratos en yul?

Una vez que entiendas la sintaxis, el storage y cómo funciona la memoria en Yul, es momento de llamar contratos. Nuestro último artículo de la serie sobre Yul explica cómo se llaman los contratos en Yul, específicamente mediante:

call() - llama al contrato en la dirección a, devolviendo 0 en caso de error y 1 en caso de éxito
staticcall() - idéntico a call(g, a, 0, in, insize, out, outsize) pero no permite modificaciones de estado
delegatecall() - idéntico a callcode pero también conserva caller y callvalue‍

Puedes encontrar más información sobre las definiciones de llamadas a contratos en la documentación del lenguaje Yul.