For the complete documentation index, see llms.txt. This page is also available as Markdown.

Orçamento de computação

Custos de unidades de computação da Solana (CU) para operações da Rome EVM — orçamentos atômicos vs. iterativos e como projetar contratos Solidity eficientes em CU.

Toda transação Solana tem um orçamento de computação medido em Compute Units (CU). Entender os custos de CU ajuda você a projetar contratos Rome eficientes.

Visão geral do orçamento

Modo
Máx. de CU
Observações

Atômico (VmAt)

~1.400.000 CU

Uma única transação Solana

Iterativo (VmIt)

Até ~1.400.000 CU por perna; no máximo 160 iterações por sessão

Cada perna é sua própria transação Solana; opcodes/passo adaptativos — empacotados no orçamento de CU de cada tx

Cada transação Solana tem um orçamento padrão de 200.000 CU, que pode ser estendido para ~1,4 milhão de CU por meio de instruções de compute budget (adicionadas automaticamente pelo SDK Rome).

A execução iterativa não é ilimitada. Uma sessão termina após 160 iterações, e o compositor iterativo do SDK Rome em Rust planeja no máximo 128 pernas. Um plano que a própria carteira assina passa por rome_submitSignedV1Plan, que aceita no máximo 64 transações por chamada. A maioria das chamadas precisa de bem menos. CPIs da trilha legada são recusadas dentro de uma sessão iterativa, então uma chamada que as faz precisa caber no orçamento atômico. Veja Chamadas retransmitidas e chamadas longas e Restrições.

Estimativas de custo de CU

Operações da EVM

Operação
CU aproximado
Observações

Verificação de assinatura da transação (via de chave EVM)

~25.000 CU

O secp256k1_recover syscall, com o mesmo custo que o ecrecover pré-compilado abaixo

Transferência simples

~50.000–100.000 CU

Apenas atualizações de saldo

Transferência ERC-20

~100.000–150.000 CU

Inclui chamada ao pré-compilado SPL

Implantação de contrato (pequena)

~200.000–400.000 CU

Depende do tamanho do bytecode

Gravação em storage (SSTORE)

~5.000–20.000 CU

Acesso frio vs. quente

Operações de pré-compilados

Precompile
CU aproximado
Observações

ecrecover

~25.700 CU

SHA-256

~257 CU por palavra de 32 bytes medida

Além de um pequeno custo fixo. O programa precifica SHA-256, RIPEMD-160 e o pré-compilado de identidade com uma única tarifa compartilhada por palavra de cerca de 2.200 CU, calibrada para o RIPEMD-160, o mais caro dos três, de modo que uma chamada SHA-256 é cobrada por mais do que usa

BN254 ecAdd

Próximo de 0 CU

Mais barato do que copiar 32 bytes

BN254 ecMul

~4.200 CU

BN254 ecPairing

~22.000 CU mais ~12.800 CU por par

Uma verificação de quatro pares consome cerca de 73.000 CU, bem dentro de uma única transação atômica

Esses valores vêm da própria calibração do programa, que usou unidades de computação lidas de volta de um nó Solana em uma implantação na testnet. Eles não foram medidos novamente para esta página; meça sua própria chamada com computeUnitsConsumed.

Técnicas de otimização

1. Use Yul para caminhos críticos

O otimizador do Solidity gera código razoável, mas Yul (assembly inline) pode reduzir significativamente o CU para operações críticas:

2. Armazene em cache as derivações de PDA

A derivação de PDA via find_program_address é cara. Armazene os PDAs derivados no storage do contrato em vez de calculá-los em cada chamada:

3. Fixe IDs de programa conhecidos

Não carregue IDs de programa do storage — use constantes:

4. Minimize a quantidade de contas

Cada conta em uma transação Solana adiciona overhead de CU. Reduza o número de contas:

  • Agrupando operações que compartilham contas

  • Usando menos contas intermediárias

  • Evitando verificações redundantes de criação de ATA

5. Use as configurações do otimizador

Compile com npx hardhat compile --build-profile production.

Medindo o consumo de CU

eth_estimateGas não mede unidades de computação, porque uma unidade de gas no Rome equivale a um lamport de custo. Ele define o tamanho do seu limite de gas. Leia o compute da transação Solana por trás de um hash da EVM: obtenha suas assinaturas com rome_solanaTxForEvmTx, busque cada uma com o getTransaction e maxSupportedTransactionVersion: 1, e leia computeUnitsConsumed, ou abra a chamada no explorer. Uma chamada iterativa tem uma transação por perna. Para dimensionar o limite de gas antes de enviar:

Ou via ethers.js:

O que vem a seguir

Atualizado

Isto foi útil?