O que é Yul?

Publicado em 28 de julho de 20234 min de leitura

Yul é uma linguagem de programação intermediária programming language que pode ser usada para escrever uma forma de linguagem assembly dentro de smart contracts. Embora costumemos ver Yul usado dentro de smart contracts, é possível escrever um smart contract inteiramente em Yul.

Entender Yul pode elevar o nível dos seus smart contracts e permitir que você entenda o que está acontecendo por baixo dos panos em solidity, o que, por sua vez, pode ajudar a reduzir os custos de gas para o usuário.

Podemos identificar Yul em um smart contract com a seguinte sintaxe.

No restante deste artigo, discutiremos os fundamentos do uso de Yul por meio de exemplos, e recomendamos que você acompanhe no Remix.

Atribuições de variáveis, operações e avaliações em yul

O primeiro tópico que precisamos cobrir são operações simples. Yul tem +, -, , /, %, , <, > e =.

Observe que >= e <= não estão incluídos na lista de operadores disponíveis em Yul porque Yul não possui esses operadores. Além disso, em vez de avaliações resultarem em true ou false, elas resultam em 1 ou 0, respectivamente. Dito isso, vamos começar a aprender um pouco de Yul!

Instruction	Explanation
let	Isso é necessário antes de definir uma variável. Como todos os valores são bytes, não há necessidade de atribuir um tipo de valor.
:=	Equivalente em Solidity: x = y
add(x,y)	Equivalente em Solidity: x + y
sub(x,y)	Equivalente em Solidity: x - y
mul(x,y)	Equivalente em Solidity: x * y
div(x,y)	Equivalente em Solidity: x / y (ou 0 se y for igual a 0)
mod(x,y)	Equivalente em Solidity: x % y (ou 0 se y for igual a 0)
lt(x,y)	Equivalente em Solidity: x < y
gt(x,y)	Equivalente em Solidity: x > y
eq(x,y)	Equivalente em Solidity: x == y
iszero(x)	Equivalente em Solidity: x == 0

Vamos dar uma olhada rápida em um exemplo antes de continuar.

For loops e if statements em yul

Para aprender sobre for loops e if statements, vamos escrever uma função que conta quantos números são pares em uma série.

A sintaxe dos if statements é semelhante à do Solidity, mas não é necessário colocar a condição entre parênteses.

Para o for loop, observe que usamos chaves ao declarar i e ao incrementar i, mas não ao avaliar a condição. Além disso, usamos um continue para pular uma iteração do loop. Também podemos usar break statements em Yul.

Como funciona o storage em yul

Existem 2²⁵⁶ slots para um smart contract. Ao declarar variáveis, começamos pelo slot 0 e incrementamos a partir daí. Cada slot tem 256 bits de comprimento (32 bytes); é daí que vêm os nomes uint256 e bytes32. Todas as variáveis são convertidas para hexadecimal. Se uma variável, como um uint128, for usada, não ocupamos um slot inteiro para armazená-la. Em vez disso, ela é preenchida com 0's do lado esquerdo.

Para saber mais sobre como funciona o storage em Yul, leia nosso outro artigo, que aborda:

Arrays
Arrays dinâmicos
Mappings
Mappings aninhados

Como ler e escrever variáveis empacotadas em yul

Empacotar variáveis significa ordená-las de forma que a soma de seu armazenamento fique abaixo de 32 bytes, para que caibam juntas em um slot! Empacotar variáveis pode economizar gas e é uma técnica essencial para otimizadores de smart contracts.

Por exemplo, 0x000000000000000000000000000002 e 0x000000000000000000000000000001 cabem perfeitamente juntos no mesmo slot porque ambos ocupam 16 bytes (metade de um slot).

Para saber mais sobre como ler e escrever variáveis de storage empacotadas em Yul, leia nosso artigo aprofundado!

Como funciona a memory em yul?

A memory se comporta de forma diferente do storage, pois não é persistente (ou seja, assim que a função termina de ser executada, todas as variáveis são apagadas). Alguns usos da memory em Yul são:

Retornar valores para chamadas externas
Definir valores de função para chamadas externas
Obter valores de chamadas externas
Reverter com uma mensagem de erro
Registrar mensagens (logging)

Para saber mais sobre como funciona a memory em Yul, leia nosso outro artigo, que se aprofunda no assunto!

Como funcionam as chamadas de contrato em yul?

Depois de entender a sintaxe, o storage e o funcionamento da memory em Yul, é hora de chamar contratos. Nosso último artigo da série sobre Yul explica como as chamadas de contrato funcionam em Yul, especificamente por meio de:

call() - chama o contrato no endereço a, retornando 0 em caso de erro e 1 em caso de sucesso
staticcall() - idêntico a call(g, a, 0, in, insize, out, outsize), mas não permite modificações de estado
delegatecall() - idêntico a callcode, mas também mantém caller e callvalue‍

Mais informações sobre as definições de chamadas de contrato podem ser encontradas na documentação da linguagem Yul.