Blast - Build on the High-Performance EVM L2

Blast RPC
With Dwellir, you get access to our global Blast network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Blast?

Blast is a next-generation Ethereum Layer 2 solution designed for high-performance applications and DeFi protocols. Built to optimize developer and user experience, Blast offers:

🚀 High-Performance EVM

• Fast transaction finality - Sub-second confirmation times
• Low gas costs - Significantly reduced fees compared to Ethereum L1
• High throughput - Optimized for demanding applications

💰 Native Yield Generation

• Built-in yield - ETH and USDB automatically earn yield
• Developer incentives - Gas fee rebates and yield sharing
• Capital efficiency - Maximize returns for users and protocols

🔧 Developer-First Design

• Full EVM compatibility - Deploy existing Ethereum contracts seamlessly
• Rich tooling support - Works with Hardhat, Foundry, and all standard tools
• Growing ecosystem - Active developer community and partnerships

🌐 Decentralized & Secure

• Ethereum security - Inherits L1 security properties
• Decentralized sequencing - Robust network architecture
• Battle-tested infrastructure - Proven reliability and uptime

Quick Start with Blast

Connect to Blast in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Blast Mainnet (Chain ID: 81457)Live

https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY

✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

curl -X POST https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Installation & Setup

Ethers.js v6

import { JsonRpcProvider } from 'ethers';

// Connect to Blast mainnet
const provider = new JsonRpcProvider(
  'https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

// Get the latest block
const block = await provider.getBlock('latest');
console.log('Latest block:', block.number);

// Query account balance
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString());

Web3.js

const Web3 = require('web3');

// Connect to Blast mainnet
const web3 = new Web3(
  'https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

// Get chain ID to verify connection
const chainId = await web3.eth.getChainId();
console.log('Connected to Blast:', chainId === 81457n);

// Get gas price for optimal transaction pricing
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);

Viem

import { createPublicClient, http } from 'viem';
import { blast } from 'viem/chains';

// Create Blast client
const client = createPublicClient({
  chain: blast,
  transport: http('https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'),
});

// Read contract data
const data = await client.readContract({
  address: '0x...',
  abi: contractAbi,
  functionName: 'balanceOf',
  args: ['0x...'],
});

Web3.py

from web3 import Web3

# Connect to Blast mainnet
w3 = Web3(Web3.HTTPProvider(
    'https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
))

# Verify connection
print(f'Connected: {w3.is_connected()}')
print(f'Chain ID: {w3.eth.chain_id}')

# Get latest block number
latest_block = w3.eth.block_number
print(f'Latest block: {latest_block}')

# Get account balance
balance = w3.eth.get_balance('0x...')
print(f'Balance: {w3.from_wei(balance, "ether")} ETH')

Network Information

Chain ID

81457

Mainnet

Testnet Chain ID

168587773

Sepolia Testnet

Gas Token

ETH

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference

Blast supports the full Ethereum JSON-RPC API specification.

Available JSON-RPC Methods

📊 Reading Blockchain Data

Query blocks, transactions, and account states

+

📤 Sending Transactions

Submit and manage transactions

+

📝 Smart Contract Interaction

Call and interact with smart contracts

+

🔧 Node & Network Info

Query node status and network information

+

Ready to integrate Blast into your dApp?

Get your API key →

Common Integration Patterns

🔄 Transaction Monitoring

Monitor pending and confirmed transactions efficiently:

// Watch for transaction confirmation
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  // Check transaction status
  if (receipt.status === 1) {
    console.log('Transaction confirmed:', receipt.transactionHash);
  }
  
  return receipt;
}

💰 Gas Optimization

Optimize gas costs on Blast:

// Estimate gas for transaction
const gasEstimate = await provider.estimateGas(tx);

// Get current fee data for EIP-1559
const feeData = await provider.getFeeData();

// Prepare transaction with optimal gas settings
const optimizedTx = {
  ...tx,
  gasLimit: gasEstimate,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
};

🔍 Event Filtering

Efficiently query contract events:

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 2000; // Recommended batch size
  
  for (let i = fromBlock; i <= currentBlock; i += batchSize) {
    const batch = await contract.queryFilter(
      filter, 
      i, 
      Math.min(i + batchSize - 1, currentBlock)
    );
    events.push(...batch);
  }
  
  return events;
}

Performance Best Practices

1. Batch Requests

Combine multiple RPC calls for optimal performance:

const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);

2. Connection Pooling

Reuse provider instances to minimize connection overhead:

// Singleton pattern for provider
class BlastProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
      );
    }
    return this.instance;
  }
}

3. Smart Caching

Cache immutable data to reduce API calls:

const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;
  
  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }
  
  return cache.get(key);
}

Troubleshooting Common Issues

Error: "Wrong chain ID"

Verify you're connecting to the correct Blast network:

// Check current chain ID
const chainId = await provider.send('eth_chainId', []);
console.log('Current chain ID:', parseInt(chainId, 16));

// Blast Mainnet should return 81457 (0x13e31)
// Blast Sepolia Testnet should return 168587773 (0xa0c71fd)

Error: "Transaction underpriced"

Blast uses EIP-1559 pricing. Always use dynamic gas pricing:

// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: 21000n
};

Error: "Rate limit exceeded"

Implement exponential backoff for resilient applications:

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}

FAQs

What makes Blast different from other L2s?

Blast is unique in providing native yield generation for ETH and USDB holdings, along with gas fee rebates for developers and automatic capital efficiency optimizations.

How do I bridge assets to Blast?

Use the official Blast Bridge at blast.io/bridge or integrate with supported bridging protocols.

Does Blast support all Ethereum tools?

Yes, Blast is fully EVM-compatible and works with all standard Ethereum development tools including Hardhat, Foundry, Remix, and MetaMask.

Smoke Tests

Test your connection to Blast:

curl (Mainnet)

curl -X POST https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

curl (Testnet)

curl -X POST https://api-blast-sepolia-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Ethers.js v6

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY');
const blockNumber = await provider.getBlockNumber();
const network = await provider.getNetwork();

console.log('Block number:', blockNumber);
console.log('Chain ID:', network.chainId); // Should be 81457

Web3.py

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'))

print(f'Connected: {w3.is_connected()}')
print(f'Chain ID: {w3.eth.chain_id}')  # Should be 81457
print(f'Latest block: {w3.eth.block_number}')

Migration Guide

From Ethereum Mainnet

Moving from L1 to Blast requires minimal changes:

// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

// After (Blast)
const provider = new JsonRpcProvider(
  'https://api-blast-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ⚠️ Different chain ID (81457)
// ⚠️ Separate block numbers
// ✅ Lower gas fees
// ✅ Native yield generation

Resources & Tools

Official Resources

• Blast Documentation
• Blast Bridge
• Blast Explorer

Developer Tools

• Blast GitHub
• Developer Portal
• Smart Contract Templates

Need Help?

• 📧 Email: support@dwellir.com
• 📚 Docs: You're here!
• 🎯 Dashboard: dashboard.dwellir.com

---

Start building on Blast with Dwellir's enterprise-grade RPC infrastructure. Get your API key →