Limitações

O desenvolvimento de programas na blockchain Solana tem algumas limitações inerentes associadas a eles. Abaixo está uma lista de limitações comuns que você pode encontrar.

Bibliotecas Rust

Como os programas onchain baseados em Rust devem ser determinísticos enquanto executam em um ambiente de thread único com recursos limitados, eles têm algumas limitações em várias bibliotecas.

Os programas Rust on-chain suportam a maior parte do libstd, libcore e liballoc do Rust, assim como muitos crates de terceiros.

Existem algumas limitações, já que esses programas são executados em um ambiente de thread único com recursos limitados, além de serem determinísticos:

Sem acesso a
- rand
- std::fs
- std::net
- std::future
- std::process
- std::sync
- std::task
- std::thread
- std::time
Acesso limitado a:
- std::hash
- std::os
Bincode é extremamente caro computacionalmente tanto em ciclos quanto em profundidade de chamada e deve ser evitado
A formatação de strings também deve ser evitada, pois é computacionalmente cara.
Sem suporte para println!, print!, use a macro msg! em vez disso.
O runtime impõe um limite no número de instruções que um programa pode executar durante o processamento de uma instrução. Veja orçamento computacional para mais informações.

Orçamento computacional

Para evitar o abuso dos recursos computacionais da blockchain, cada transação recebe um orçamento computacional. Exceder esse orçamento computacional resultará na falha da transação.

Veja a documentação sobre restrições computacionais para detalhes mais específicos.

Profundidade da pilha de chamadas - erro `CallDepthExceeded`

Os programas Solana são limitados a executar rapidamente e, para facilitar isso, a pilha de chamadas do programa é limitada a uma profundidade máxima de 64 frames.

Quando um programa excede o limite permitido de profundidade da pilha de chamadas, ele receberá o erro CallDepthExceeded.

Profundidade de chamada CPI - erro `CallDepth`

As invocações entre programas permitem que programas invoquem outros programas diretamente, mas a profundidade está atualmente limitada a 4.

Quando um programa excede a profundidade permitida de invocação entre programas, ele receberá um erro CallDepth

Os programas suportam um subconjunto limitado de operações de ponto flutuante do Rust. Se um programa tentar usar uma operação de ponto flutuante que não é suportada, o runtime reportará um erro de símbolo não resolvido.

Operações de ponto flutuante são realizadas através de bibliotecas de software, especificamente as funções built-in de ponto flutuante do LLVM. Por serem emuladas via software, elas consomem mais unidades de computação do que operações com números inteiros. Em geral, recomenda-se o uso de operações de ponto fixo quando possível.

Os testes da biblioteca de matemática da Solana Program Library reportarão o desempenho de algumas operações matemáticas. Para executar o teste, sincronize o repositório e execute:

cargo test-sbf -- --nocapture --test-threads=1

Resultados recentes mostram que as operações de ponto flutuante exigem mais instruções em comparação com equivalentes de números inteiros. Implementações de ponto fixo podem variar, mas também serão menos exigentes que os equivalentes de ponto flutuante:

          u64   f32
Multiply    8   176
Divide      9   219

Dados estáticos graváveis

Os objetos compartilhados de programa não suportam dados compartilhados graváveis. Os programas são compartilhados entre múltiplas execuções paralelas usando o mesmo código e dados compartilhados somente para leitura. Isso significa que os desenvolvedores não devem incluir variáveis estáticas graváveis ou globais nos programas. No futuro, um mecanismo de cópia na escrita poderia ser adicionado para suportar dados graváveis.

Divisão com sinal

O conjunto de instruções SBF não suporta divisão com sinal.