eth_getBlockReceipts - Pulsechain RPC Method

Returns all transaction receipts for a block on Pulsechain. This is more efficient than calling eth_getTransactionReceipt once per transaction when you already know the target block.

Why Pulsechain? Build on the Ethereum fork L1 with lower gas fees and proof-of-stake consensus with full Ethereum state fork, proof-of-stake consensus, lower gas fees than Ethereum mainnet, and PulseX DEX ecosystem.

When to Use This Method

eth_getBlockReceipts is useful for DeFi developers, staking protocol builders, and teams migrating from Ethereum:

• Indexer Backfills: Pull every receipt in a block with one request instead of looping over transaction hashes
• Event Collection: Scan all logs emitted by a block when building analytics or data pipelines
• Settlement Auditing: Verify every transaction outcome in a target block for low-cost DeFi, staking protocols, and Ethereum-compatible dApps with reduced fees
• Operational Debugging: Compare receipt-level gas usage, status, and logs across multiple transactions at once

Common Use Cases

1. Backfill Transaction Receipts for an Indexer

When bootstrapping an indexer for Pulsechain, use eth_getBlockReceipts to backfill historical receipt data efficiently. One RPC call per block replaces dozens of individual eth_getTransactionReceipt calls.

import { JsonRpcProvider } from 'ethers';

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

async function backfillReceipts(startBlock, endBlock) {
  const receipts = {};

  for (let i = startBlock; i <= endBlock; i++) {
    const hexBlock = '0x' + i.toString(16);
    const results = await provider.send('eth_getBlockReceipts', [hexBlock]);

    if (results) {
      for (const receipt of results) {
        receipts[receipt.transactionHash] = {
          block: i,
          status: receipt.status === '0x1' ? 'success' : 'failed',
          gasUsed: parseInt(receipt.gasUsed, 16),
          logCount: receipt.logs.length,
        };
      }
    }
    console.log(`Backfilled block ${i}: ${results ? results.length : 0} receipts`);
  }

  return receipts;
}

backfillReceipts(10000000, 10000050);

2. Audit Gas Usage Across All Transactions in a Range

Compute total gas consumption and identify high-gas transactions within a target block range on Pulsechain. This is useful for gas cost analysis and identifying optimization targets in smart contract usage.

from web3 import Web3

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

def audit_gas_usage(block_identifier):
    response = w3.provider.make_request(
        'eth_getBlockReceipts', [block_identifier]
    )

    receipts = response.get('result')
    if not receipts:
        print(f'No receipts found for block {block_identifier}')
        return

    total_gas = 0
    for receipt in receipts:
        gas = int(receipt['gasUsed'], 16)
        total_gas += gas
        if gas > 500_000:
            print(f'High gas tx: {receipt["transactionHash"]} used {gas:,} gas')

    print(f'Block {block_identifier}: {len(receipts)} txs, '
          f'total gas {total_gas:,}')

audit_gas_usage('0x6f593d6cf3e5a475798567e4defeef46367cdc22556d310bd39bb8f23bdd8f52')

3. Extract Contract Creation Events from Deployment Blocks

When monitoring contract deployments on the Ethereum fork L1 with lower gas fees and proof-of-stake consensus, use eth_getBlockReceipts to scan for receipts where contractAddress is non-null. This identifies all new contract deployments within a block in a single call.

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, _ := rpc.Dial("https://api-pulse-mainnet.n.dwellir.com/YOUR_API_KEY")

    var receipts []map[string]interface{}
    err := client.CallContext(
        context.Background(),
        &receipts,
        "eth_getBlockReceipts",
        "0x6f593d6cf3e5a475798567e4defeef46367cdc22556d310bd39bb8f23bdd8f52",
    )
    if err != nil {
        log.Fatal(err)
    }

    for _, r := range receipts {
        contractAddr, ok := r["contractAddress"]
        if ok && contractAddr != nil {
            fmt.Printf("Contract deployed: %s\n", contractAddr)
            fmt.Printf("  Creator: %s\n", r["from"])
            fmt.Printf("  Tx hash: %s\n", r["transactionHash"])
        }
    }
}

Best Practices

• Use block hash instead of block number for deterministic results: Hash-based lookups guarantee you are querying the exact block intended, even if chain reorganizations shift block numbers
• Paginate large receipt arrays client-side: Blocks with thousands of transactions return large payloads; paginate processing to avoid memory pressure in your application
• Cache individual receipt data per transaction hash: Receipts are immutable once a block is finalized, so cache them indefinitely for repeated lookups
• For historical blocks, archive nodes may return more complete receipt data: Full nodes may prune older state; archive nodes retain complete historical receipt information

Code Examples

Error Handling

Related Methods

• eth_getTransactionReceipt - Retrieve a single transaction receipt
• eth_getBlockByHash - Retrieve the block object itself
• eth_getBlockByNumber - Retrieve a block by number or tag