Insights mais profundos de aplicação a custos menores

Construa o que você quiser, do jeito que quiser, acessando o máximo de valor a preços justos e transparentes.

Por isso, depois de ouvir seu feedback, reduzimos o custo em Compute Units (CU) de quatro métodos críticos do debug\_trace, oferecendo uma solução mais econômica para coletar detalhes abrangentes de execução de transações.

Os métodos debug\_trace são importantes para depuração, resolução de problemas e para entender por que um contrato se comportou de determinada forma.

Ao reestruturar a infraestrutura de back end, a Alchemy conseguiu repassar a você uma economia de eficiência de até 3x em quatro métodos-chave do debug\_trace:

• debug_traceBlockByHash
• debug_traceBlockByNumber
• debug_traceTransaction
• debug_traceCall

Na prática, a redução nos CUs significa que você pode acessar muito mais valor e insights importantes a um custo significativamente menor.

Pronto? Comece agora com os métodos debug\_trace.

Lembrando, o que é uma compute unit (cu)?

Compute Units (CUs) medem o total de recursos computacionais que os apps usam ao fazer requisições na Alchemy, levando em conta que algumas queries são leves e rápidas de executar (por exemplo, eth\_blockNumber), enquanto outras são mais intensas (por exemplo, eth\_getLogs).

Para isso, cada método recebe uma quantidade de CUs. Você é cobrado com base nos recursos que sua aplicação realmente usa, em vez de uma taxa fixa por requisição. Nesse sentido, os CUs funcionam como o gas na mainnet, onde a taxa está correlacionada com a execução de uma transação.

Em breve, mais detalhes sobre como pensar nos CUs dentro do marketplace mais amplo.

Explorando o debug_trace

A redução substancial nos CUs para debug\_trace torna todas essas chamadas consideravelmente mais acessíveis de usar, permitindo que você explore a execução de transações em um nível granular.

Por que esse nível de detalhe importa?

É simples: o problema da execução de contratos é que é muito difícil saber o que uma transação de fato fez.

Métodos existentes para obter recibos de transação, como o eth\_getTransactionReceipt, embora úteis, carecem de granularidade no nível de execução da transação.

Quando você está tentando resolver um bug, isso significa que, embora algumas informações possam ser obtidas, muitos dados ficam faltando.

Em contrapartida, os métodos debug\_trace capturam uma descrição detalhada do que acontece durante a execução de uma transação, um recurso essencial para desenvolvedores. Esses métodos capturam os detalhes intrincados das interações de smart contracts, como:

• A sequência de chamadas feitas entre contratos
• Os dados passados e modificados durante essas chamadas
• O uso de gas em cada etapa
• O status de sucesso ou falha de cada ação individual

Nesse nível de granularidade, você pode depurar, buscar eficiências e entender melhor seu app.

Quem vai se beneficiar dessa redução de custo?

Você! 😁

Métodos debug_trace mais acessíveis são muito importantes em todos os segmentos da Web3:

• Criadores de wallets: Obtenha insights mais profundos sobre o processamento de transações e as interações dos usuários dentro da sua wallet.
• Plataformas de analytics: Dados detalhados de transações para insights mais precisos e valiosos sobre os usuários.
• Marketplaces: Tenha uma visão melhor do fluxo de transações para reforçar a segurança, ajudar a rastrear atividades e otimizar as operações da plataforma.
• Qualquer desenvolvedor de apps: Seja qual for o seu projeto, os métodos debug\_trace oferecem os melhores insights para construir um app excelente e sem bugs.

Então, o que você está esperando?

Milhares de desenvolvedores e equipes já estão construindo com a Alchemy. Na verdade, se você já usou algum app Web3, provavelmente já usou a Alchemy.

Quer saber mais? Confira a documentação hoje mesmo.

Perguntas frequentes

Para que servem os métodos debug_trace?

Os métodos debug_trace fornecem descrições detalhadas da execução de transações, incluindo a sequência de chamadas entre contratos, modificações de dados, uso de gas em cada etapa e o status de sucesso ou falha de cada ação individual. Essa granularidade ajuda desenvolvedores a depurar problemas, otimizar eficiência e entender o comportamento de smart contracts além dos recibos de transação básicos.

Quais métodos debug_trace agora custam 3x menos?

Reduzimos os custos em Compute Units em até 3x para quatro métodos-chave: debug_traceBlockByHash, debug_traceBlockByNumber, debug_traceTransaction e debug_traceCall.

O que é uma Compute Unit (CU)?

Compute Units medem o total de recursos computacionais que os apps usam ao fazer requisições na nossa plataforma. Você é cobrado com base nos recursos que sua aplicação usa, em vez de uma taxa fixa por requisição, de forma semelhante a como o gas funciona na mainnet.

Por que usar debug_trace em vez de eth_getTransactionReceipt?

Embora o eth_getTransactionReceipt seja útil, ele carece de granularidade no nível de execução da transação. Os métodos debug_trace capturam detalhes intrincados das interações de smart contracts que são essenciais para depuração e para entender o que uma transação fez.

Quem se beneficia dos métodos debug_trace mais baratos?

Criadores de wallets obtêm insights mais profundos sobre as interações dos usuários, plataformas de analytics acessam dados detalhados de transações, marketplaces conseguem reforçar a segurança e rastrear atividades, e qualquer desenvolvedor de apps pode depurar e otimizar com mais eficácia.

Como reduzimos os custos do debug_trace?

Reestruturamos a infraestrutura de back end para alcançar uma economia de eficiência de até 3x, que é repassada diretamente aos desenvolvedores por meio da redução nos custos de Compute Unit.

Onde posso aprender mais sobre como usar os métodos debug_trace?

Você pode consultar nossa documentação para começar a usar os métodos debug_trace, incluindo guias de implementação e exemplos de uso.