eth_getBlockReceipts - Plasma RPC Method

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

Why Plasma? Build on an EVM Layer 1 for stablecoin payments with PlasmaBFT consensus and Reth execution with 1 second blocks, XPL gas, full EVM JSON-RPC, and debug plus txpool on Dwellir.

When to Use This MethodCopy Anchor Link

eth_getBlockReceipts is useful for payment app developers, wallet teams, and teams shipping Solidity contracts for dollar transfers:

• 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 stablecoin transfers, payment apps, and wallets that need 1 second confirmation
• Operational Debugging: Compare receipt-level gas usage, status, and logs across multiple transactions at once

{
  "jsonrpc": "2.0",
  "method": "eth_getBlockReceipts",
  "params": ["0xf8e25a8aece71a7a87e8aaefd242832cb0ce838ebbad206c48ca9e9f6b1a7a07"],
  "id": 1
}

Common Use CasesCopy Anchor Link

1. Backfill Transaction Receipts for an IndexerCopy Anchor Link

When bootstrapping an indexer for Plasma, 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-plasma-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 RangeCopy Anchor Link

Compute total gas consumption and identify high-gas transactions within a target block range on Plasma. 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-plasma-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('0xf8e25a8aece71a7a87e8aaefd242832cb0ce838ebbad206c48ca9e9f6b1a7a07')

3. Extract Contract Creation Events from Deployment BlocksCopy Anchor Link

When monitoring contract deployments on an EVM Layer 1 for stablecoin payments with PlasmaBFT consensus and Reth execution, 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-plasma-mainnet.n.dwellir.com/YOUR_API_KEY")

    var receipts []map[string]interface{}
    err := client.CallContext(
        context.Background(),
        &receipts,
        "eth_getBlockReceipts",
        "0xf8e25a8aece71a7a87e8aaefd242832cb0ce838ebbad206c48ca9e9f6b1a7a07",
    )
    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 PracticesCopy Anchor Link

• 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 ExamplesCopy Anchor Link

Error HandlingCopy Anchor Link

Related MethodsCopy Anchor Link

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