Você conhece esse cenário? Você está executando um robô de trading. Cada milissegundo é crucial — cada chamada de RPC custa dinheiro.
Você paga um prêmio por um provedor de RPC de alta velocidade capaz de executar transações imediatamente. Mas o problema é que: 90% das suas chamadas RPC são para leitura, não para escrita. Você consulta preços, verifica saldos e faz varredura na mempool — mas, a cada chamada, paga o mesmo preço alto.
E se você mantiver o caminho de gravação rápido exatamente como está, mas direcionar todo o tráfego de leitura para um canal barato, só um pouco melhor?
Isso não é hipótese. Esse padrão é chamado de separação entre leitura e escrita, uma das arquiteturas de redução de custos mais eficazes para qualquer dApp sério, robô ou indexador.
Principais dores que todo mundo sente
Para ser direto: hoje, a forma como a maioria dos projetos usa RPC é assim.
while True:
price = web3.eth.call(price_feed_contract) # leitura
balance = web3.eth.get_balance(user_wallet) # leitura
# ... verificar condições ...
tx_hash = web3.eth.send_raw_transaction(signed) # escrita
Em um ciclo típico de transações, cada transação executa 10–50 leituras. Porém, a maioria dos desenvolvedores roteia todas as requisições por um único endpoint de RPC — geralmente aquele otimizado para velocidade de submissão de transações, e portanto mais caro.
Se você paga $X pelo RPC de aceleração de transações, mas 95% das suas chamadas são leituras, então na prática você está desperdiçando $0,95X pagando pelo mesmo tipo de consulta de dados que poderia ser fornecida por um provedor bem mais barato.
Na verdade, não é um problema de precificação, e sim de arquitetura — e a solução é surpreendentemente simples. A seguir, eu vou detalhar.
Nossa solução: separação entre leitura e escrita
A arquitetura é bem simples:
Consultas de leitura (eth_call, eth_getBalance...) ➡️ BlockPI (barato, estável, suporta arquivamento)
Transações de escrita (RPC de aceleração de transações) ➡️ seu RPC de aceleração de transações (envio com baixa latência)
Basta manter dois provedores no seu código e rotear as requisições de forma inteligente — e o custo de RPC cai imediatamente em 60–80%.
Como funciona no código
Implementação extremamente simples. Veja um padrão Python útil a seguir:
from web3 import Web3
from web3.middleware import geth_poa_middleware
import os
READ_RPC_URL = os.getenv("BLOCKPI_RPC_URL")
WRITE_RPC_URL = os.getenv("TRANSACTION_ACCELERATION_RPC_URL")
w3_read = Web3(Web3.HTTPProvider(READ_RPC_URL))
w3_write = Web3(Web3.HTTPProvider(WRITE_RPC_URL))
w3_read.middleware_onion.inject(geth_poa_middleware, layer=0)
w3_write.middleware_onion.inject(geth_poa_middleware, layer=0)
def get_eth_price():
price_feed = w3_read.eth.contract(
address="0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
abi=[{"inputs":[],"name":"latestAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"}]
)
return price_feed.functions.latestAnswer().call()
def execute_swap(signed_tx):
return w3_write.eth.send_raw_transaction(signed_tx)
def wait_for_receipt(tx_hash):
return w3_read.eth.wait_for_transaction_receipt(tx_hash)
Ou, de um jeito mais limpo, use um wrapper Web3 que faça o roteamento automaticamente:
class SmartWeb3:
"""Wrapper Web3 para rotear requisições de leitura e escrita para provedores diferentes."""
def __init__(self, read_rpc: str, write_rpc: str):
self._read = Web3(Web3.HTTPProvider(read_rpc))
self._write = Web3(Web3.HTTPProvider(write_rpc))
@property
def eth(self):
return self._routed_eth()
def _routed_eth(self):
class RoutedEth:
def __init__(self, read, write):
self._read = read.eth
self._write = write.eth
def get_balance(self, address, block=None):
return self._read.get_balance(address, block)
def call(self, transaction, block=None):
return self._read.call(transaction, block)
def get_logs(self, filter_params):
return self._read.get_logs(filter_params)
def send_raw_transaction(self, signed_tx):
return self._write.send_raw_transaction(signed_tx)
def estimate_gas(self, transaction):
return self._write.estimate_gas(transaction)
def get_transaction_count(self, address, block=None):
return self._write.get_transaction_count(address, block)
def block_number(self):
return self._read.block_number()
def wait_for_transaction_receipt(self, tx_hash, timeout=120):
return self._read.wait_for_transaction_receipt(tx_hash, timeout)
return RoutedEth(self._read, self._write)
w3 = SmartWeb3(
read_rpc=os.getenv("BLOCKPI_RPC_URL"),
write_rpc=os.getenv("TRANSACTION_ACCELERATION_RPC_URL")
)
balance = w3.eth.get_balance("0x...")
price = w3.eth.call(tx)
tx_hash = w3.eth.send_raw_transaction(signed_tx)
A lógica do negócio não muda em nenhum aspecto — a única diferença é a fatura.
Por que a BlockPI foi desenhada para cenários com foco em leituras
Depois de separar leitura e escrita, o provedor de leitura precisa ter três coisas:
Confiabilidade em escala
Seu robô ou dApp não pode dar ao luxo de perder um bloco. A infraestrutura da BlockPI foi construída para workloads de produção — nós distribuídos, failover automático e buffers de rate limit que realmente funcionam.
Suporte a arquivamento — porque leituras frequentemente precisam de dados históricos
Muitos padrões de leitura exigem dados históricos — buscar logs da semana passada, verificar posições antigas de LP, reexecutar eventos ao reiniciar. A BlockPI oferece modo de arquivamento no Ethereum e na Base (a partir do bloco genesis), o eth_getLogs suporta faixas de 5.000 blocos e permite consultas paginadas até qualquer profundidade.
Eficiência de custo que realmente faça diferença
A cobrança da BlockPI baseada em RU é competitiva, então você pode rotear leituras de alta capacidade sem precisar ficar ponderando o custo de cada chamada repetidamente. O custo por chamada é apenas uma fração do que você pagaria ao usar um provedor premium voltado à execução.
Volume de chamadas Leituras via RPC de aceleração de transações Leituras via BlockPI
1M calls/dia $XX–$XXX 60–80% menos
10M calls/dia $XXX–$XXXX A lacuna aumenta
Para quem a separação leitura/escrita é indicada?
A seguir, veja como um robô típico de MEV ou arbitragem faz a configuração em JavaScript:
const { Web3 } = require('web3');
const web3Read = new Web3('https://base.blockpi.network/v1/rpc/{YOUR_API_KEY}');
const web3Write = new Web3(process.env.TRANSACTION_ACCELERATION_RPC_URL);
async function tradingCycle() {
// Passo 1: varrer oportunidades (todas as leituras passam pela BlockPI)
const currentPrice = await web3Read.eth.call({
to: '0x...',
priceFeed.encodeABI()
});
const poolReserves = await web3Read.eth.call({
to: poolAddress,
poolAbi.encodeReserves()
});
const profit = calculateProfit(currentPrice, poolReserves);
// Passo 2: se for lucrativo, executar (escrita via RPC rápido)
if (profit > threshold) {
const nonce = await web3Write.eth.getTransactionCount(wallet.address);
const gasPrice = await web3Write.eth.getGasPrice();
const tx = {
from: wallet.address,
to: routerAddress,
swapData,
gas: 300000,
gasPrice: gasPrice * 2,
nonce: nonce,
chainId: 8453
};
const signed = await wallet.signTransaction(tx);
const txHash = await web3Write.eth.sendRawTransaction(signed);
// Passo 3: aguardar confirmação (leitura passa pela BlockPI)
const receipt = await web3Read.eth.getTransactionReceipt(txHash);
return receipt;
}
}
A cada bloco, o robô executa centenas de leituras para varrer oportunidades, mas quando encontra uma oportunidade, envia apenas uma ou duas transações. Sem separação leitura/escrita, esses custos de varredura se acumulam em cada eth_call com a taxa do RPC mais caro.
A BlockPI oferece aos desenvolvedores:
• Preço competitivo de RU — torna cargas com muitas leituras realmente acessíveis
• Beacon API + blob_sidecars, para análise de dados L2
• Suporte a múltiplas redes — um único painel, várias chains, cobrança unificada
• Faixa getLogs de 5.000 blocos — paginável para qualquer profundidade
Isso significa para o seu projeto:
• Robôs de transação — varredura de baixo custo de mempool e dados on-chain; executam transações rapidamente via provedor
• Rastreador de portfólio — executa centenas de consultas de saldo/chamada em lote, sem ser assustado pela fatura
• Indexer — reproduz dados históricos com profundidade de arquivamento e encaminha transações quando necessário
• Painel DeFi — manter a leitura contínua de dados on-chain também pode ser sustentável financeiramente
🛡️ Não é só leitura — é uma infraestrutura de transações mais flexível
Separação leitura/escrita não significa que a BlockPI sirva apenas para leitura. Quando sua aplicação também envia transações via BlockPI, você pode ativar proteção contra MEV para ajudar a reduzir o risco de ataques de sandwich e outras extrações do mempool. Transações sensíveis podem ser roteadas por um caminho de envio protegido e, por padrão, não ficam expostas no mempool público.
Na prática, muitos times usam a BlockPI como camada principal de leitura de alta capacidade para eth_call, saldos, logs e consultas de recibos; ao mesmo tempo, escolhem o caminho de escrita conforme a tarefa: use o RPC de aceleração de transações quando a prioridade for latência ultrabaixa on-chain; e, quando a qualidade de execução com mais segurança for mais importante do que a velocidade original, use a BlockPI com proteção de MEV. Assim, o desenvolvedor recebe uma arquitetura flexível — não uma escolha forçada entre provedores únicos.
🔒 Ao habilitar a proteção contra MEV, a BlockPI pode ajudar seu time a preservar mais do valor que, de outra forma, ele esperaria obter on-chain — especialmente para trocas, liquidações e outras transações sensíveis a preço — sem abrir mão da infraestrutura de leitura com excelente custo-benefício. Também permite que você envie transações sensíveis sem ser interceptado por arbitradores.
Comece a usar a separação leitura/escrita em poucos minutos
A migração não exige grandes mudanças no código:
1. Cadastre-se em https://dashboard.blockpi.io e obtenha um endpoint
2. Configure, no código, uma instância Web3 apenas leitura apontando para a BlockPI
3. Use essa instância para rotear as requisições de leitura — eth_call, eth_getBalance, eth_getLogs, eth_blockNumber, eth_getTransactionReceipt...
4. Mantenha o provedor atual de escrita para o RPC de aceleração de transações. Ou use o nosso serviço de MEV
Sem reescrever código, sem reformar profundamente a arquitetura — apenas tome decisões de roteamento mais inteligentes.
Comparação do custo real
Suponha que seu projeto faça 100.000 chamadas por dia:
• Das quais 95.000 são leituras (eth_call, getBalance, getLogs, blockNumber)
• 5.000 são escritas (RPC de aceleração de transações)
Forma Custo de leitura Custo de escrita Total
All through accelerated transaction RPC High x 95K High x 5K $$$$
Separação leitura/escrita com BlockPI Low x 95K High x 5K ~60–80% menos
A economia cresce linearmente com a quantidade de leituras. Para cargas de trabalho com muitas leituras — que é exatamente o caso da maioria dos projetos — separar leitura e escrita não é só uma escolha sensata, mas também uma necessidade econômica.
Escolha o plano adequado para você
Sua aplicação não precisa usar o mesmo caminho de RPC para cada tipo de operação. O ponto-chave é fazer cada carga de trabalho combinar com as características de infraestrutura de que realmente precisa:
Leitura: capacidade, estabilidade, profundidade de arquivamento ➡️ BlockPI
Escrita: velocidade de transação ➡️ seu RPC de aceleração de transações
Não é para substituir os RPCs existentes, e sim para evitar pagar mais do que o necessário pelo que você já faz.
A BlockPI entrega o lado de leitura dessa equação — preços acessíveis, suporte a arquivamento e infraestrutura no nível de produção — para você ampliar sua escala de leituras sem aumentar os custos na mesma proporção.
Escolha o modelo de compra adequado para a sua carga de trabalho:
1️⃣ Pacote RU — compre um pacote de recursos RPC predefinido; ideal para cargas de trabalho previsíveis, com orçamento mais claro e melhor economia por unidade no nível de uso comprometido.
2️⃣ Pague conforme uso (PAYG) — comece sem pacotes fixos e pague pelo consumo real. Ideal para cargas com mudanças grandes de tráfego, testes e para quem precisa escalar com flexibilidade.
Experimente separar leitura e escrita agora ➡️ https://dashboard.blockpi.io
Fique de olho na BLOCKPI:
X oficial: https://x.com/RealBlockPI
YouTube: https://www.youtube.com/@BlockPINetwork
Telegram: @BlockPIdaily
Console: https://dashboard.blockpi.io/