Uma nova versão do Solidity, a linguagem de desenvolvimento de contratos inteligentes mais popular do Ethereum, foi lançada

Compilação: Plano de tradução; Fonte: soliditylang.org

A última versão do compilador Solidity v0.8.22 foi lançada. O compilador 0.8.22 inclui uma série de melhorias de linguagem e compilador, como definições de eventos no nível de arquivo, otimização incremental de loops não verificados, suporte para importação de JSON de montagem EVM e muito mais.

IMPORTANTE

Esta versão deprecia o suporte para EVMs abaixo de Constantinopla, que estão se tornando cada vez mais difíceis de manter. Essas versões arcaicas estão obsoletas há muito tempo na mainnet e testnet do Ethereum, e suspeitamos que elas não são mais relevantes para outras redes também. Caminhos de código complexos e soluções retardam o desenvolvimento e o teste de recursos para novas versões, por isso esperamos parar de oferecer suporte a eles em versões futuras do compilador. Se você confia no suporte para essas versões EVM, entre em contato conosco[6] 。

Destaques de novos recursos

incremento de loop não verificado

O uso de aritmética não verificada ao aumentar o contador de loop é para otimização de gás[7] prática comum. Vamos ilustrar com o seguinte exemplo de um loop e contador i:

for (uint i = 0; i < array.length; ++i) {
acc += matriz[i] ; i não é modificado pelo corpo do loop
}

Em muitos casos (veja as condições exatas abaixo), a operação de comparação garantirá que i nunca atinja o valor máximo de seu tipo, por isso é seguro assumir que o loop irá parar antes que o valor máximo seja atingido. Neste caso, uma verificação de segurança do contador seria redundante e um desperdício de gás. Isso incentiva o usuário a usar o longo padrão não verificado, que envolve o contador incrementalmente em um bloco aritmético não verificado dentro do loop, ignorando a verificação:

para (uint i = 0; i < array.length;) {
acc += matriz[i] ;
não verificado { i++; } // Eu é incrementado sem verificações de estouro -- menos gás usado
}

O Solidity 0.8.22 introduz uma otimização de verificação de estouro que gera automaticamente um incremento aritmético não verificado para o contador de loop. Essa nova otimização elimina a necessidade de usar um longo padrão delta não verificado em corpos de loop como o do exemplo anterior.

Em contraste, as novas otimizações permitem que os usuários retornem ao código bruto e mais legível sem sacrificar a eficiência do gás.

As condições precisas para a verificação de prevenção de derrames recentemente otimizada são as seguintes:

• As condições do ciclo estão na forma de i < ... onde i é uma variável local (doravante chamada de "contador de loop").
• Esta comparação deve ser realizada no mesmo tipo que o contador de loop, ou seja, o tipo à direita deve ser implicitamente convertido para o tipo do contador de loop para que o contador de loop não seja implicitamente estendido antes da comparação.
• O contador de loop deve ser uma variável local do tipo inteiro incorporado.
• A expressão de loop deve ser um incremento de prefixo ou sufixo para o contador de loop, i++ ou ++i.
• O contador de ciclos não pode ser modificado numa condição de ciclo ou num corpo de ciclo.

Para esclarecer a segunda condição, considere o seguinte trecho de código:

para (uint8 i = 0; em < UINT16(1000); ++I) {
corpo do laço
}

Nesse caso, i é convertido em uint16 antes da comparação, e a condição nunca é realmente falsa, portanto, a verificação de estouro incrementada não pode ser removida.

Além disso, observe que < é o único operador de comparação que aciona a otimização. O operador <= e outros operadores são deliberadamente excluídos. Além disso, o operador deve ser incorporado - definido pelo utilizador < não é elegível.

A otimização é simples e sempre benéfica, por isso será ativada mesmo se o resto do otimizador estiver desativado usando a configuração comum settings.optimizer.enabled. Você pode desativá-lo explicitamente definindo settings.optimizer.details.simpleCounterForLoopUncheckedIncrement como false na entrada JSON padrão. Ele não pode ser desativado usando a interface de linha de comando.

Ajuste o otimizador Yul para regenerar zero literais

A nova versão baseia-se no suporte a opcode PUSH0 introduzido na versão 0.8.20, adicionando o Rematerialiser[8] [9] A etapa de otimização é estendida para sempre regenerar o literal zero em vez de armazená-lo como uma referência variável, permitindo que PUSH0 seja usado em vez de DUP para reduzir os custos de gás. Para garantir que isso seja feito de forma eficaz, Rematerialiser e UnusedPruner são adicionados As etapas são adicionadas à sequência de limpeza padrão do otimizador Yul.

Adicionar suporte para importação de montagem EVM JSON (experimental)

Esta nova versão adiciona suporte experimental para a importação de montagens EVM, abrindo a possibilidade de ferramentas externas executarem superotimizações antes da geração de bytecode. O principal objetivo desse recurso é definir um formato de serialização para assemblies EVM de baixo nível para que os assemblies gerados pelo compilador possam ser exportados, modificados e reimportados, retomando assim o processo normal de compilação.

Importante: Este é um recurso experimental e não está disponível atualmente em produção. Estamos oferecendo esse recurso nesta versão para que você possa experimentá-lo e fornecer comentários.

Permite que os eventos sejam definidos no nível do arquivo

O Solidity 0.8.22 permite definir eventos no nível do arquivo. As definições de eventos podem agora ser colocadas fora do âmbito do contrato. Isso dá outra opção para a organização de código sem ter que encapsular artificialmente eventos em uma biblioteca.

Além disso, esta versão corrige um bug que causava um erro ao gerar um NatSpec ao emitir um evento definido em um contrato externo ou interface para o código. Na versão anterior (0.8.21), o compilador Solidity adicionou suporte para acesso restrito a eventos definidos em contratos e interfaces que não são herdados do contrato atual, mas o bug impediu o uso completo do recurso.

Com essa correção de bug e permitindo definições de eventos no nível de arquivo, a versão mais recente do Solidity permite que os usuários compilem os seguintes exemplos sem erros:

interface I {
evento ForeignEvent();
}
contrato C {
evento ForeignEvent();
}
evento E();
contrato D {
função f() public {
Emitir um evento estrangeiro desencadearia um erro interno em 0.8.21
emitir I.ForeignEvent();
emitir C.ForeignEvent();
Emissão de um evento em nível de arquivo. Novo recurso.
emitir E();
}
}

Registo de alterações completo

Recursos de idioma

• Permite que os eventos sejam definidos no nível do arquivo.

Recursos do compilador

• Gerador de código: Remova verificações de estouro redundantes para alguns loops quando a variável de contagem não estourar.
• Interface de linha de comando: Adicionada opção --no-import-callback para impedir que o compilador carregue arquivos de origem que não são explicitamente fornecidos na CLI ou entrada JSON padrão.
• Interface de linha de comando: Adicionada uma opção experimental --import-asm-json para importar assemblies EVM no formato usado por --asm-json. Interface de linha de comando: use a severidade e a coloração apropriadas para mensagens de erro geradas fora do pipeline compilado.
• EVM: Suporte preterido para as versões "homestead", "tangerineWhistle", "spuriousDragon" e "byzantium" EVM.
• Parser: Remova o modo de recuperação de erro experimental (--error-recovery/settings.parserErrorRecovery).
• SMTChecker: Suporta operadores definidos pelo usuário.
• Yul Optimizer: Se PUSH0 é suportado, prefere usar literais zero em vez de armazenar valores zero em variáveis.
• Yul Optimizer: Executa as etapas Rematerializer e UnusedPruner no final da sequência de limpeza padrão.

Correções de bugs

• Gerador de código: Corrigido um problema em que a saída via gerador de código via IR dependia de arquivos encontrados em retornos de chamada de importação. Em alguns casos, diferentes atribuições de ID AST podem alterar a ordem das funções no agendamento interno, resultando em bytecodes aparentemente diferentes, mas semanticamente equivalentes.
• NatSpec: Corrigido um erro interno ao solicitar documentação do usuário ou documentação de desenvolvimento para um contrato que emitia um evento definido em um contrato externo ou interface.
• SMTChecker: Corrigido um erro de codificação que fazia com que o loop se expandisse após a conclusão.
• SMTChecker: Corrigidas inconsistências em verificações de condição constantes quando um loop while ou for é desenrolado antes de uma verificação de condição.
• Yul Optimizer: Corrigido um problema em que nomes de variáveis Yul gerados pelo compilador durante o CSE afetavam as decisões de substituição, resultando em bytecode diferente (mas equivalente) em alguns casos.