eth_getTransactionReceipt - Robinhood RPC Method

Returns the receipt of a transaction by transaction hash on Robinhood Chain. Receipt is only available for mined transactions.

Why Robinhood? Build on an Ethereum-compatible Layer 2 built with Arbitrum Nitro for tokenized real-world assets with Arbitrum Nitro compatibility, ETH gas, sub-second soft confirmations, archive history, and WebSocket access.

When to Use This Method

eth_getTransactionReceipt is essential for Robinhood Chain developers, financial application teams, and EVM builders:

• Transaction confirmation with success/failure status: Verify that a transaction has been mined on Robinhood Chain and determine whether it succeeded or reverted
• Gas usage analysis: Compare actual gas consumed against pre-transaction estimates for tokenized assets, DeFi applications, historical state analysis, and EVM smart contracts
• Event log parsing from emitted events: Extract and decode contract events for indexing, analytics, and notification systems
• Contract deployment detection: Identify newly deployed contracts on an Ethereum-compatible Layer 2 built with Arbitrum Nitro for tokenized real-world assets by checking the contractAddress field

Common Use Cases

1. Confirm Transaction Success and Parse Emitted Events

Poll eth_getTransactionReceipt after submitting a transaction to confirm it was mined successfully on Robinhood Chain. Once available, iterate through the logs array to decode and process events emitted by the transaction.

import { JsonRpcProvider } from 'ethers';

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

async function confirmAndParse(txHash) {
  let receipt = null;

  while (!receipt) {
    receipt = await provider.getTransactionReceipt(txHash);
    if (!receipt) {
      console.log('Waiting for confirmation...');
      await new Promise(r => setTimeout(r, 2000));
    }
  }

  const status = receipt.status === 1 ? 'Success' : 'Failed';
  console.log(`Transaction ${status} in block #${receipt.blockNumber}`);
  console.log(`Gas used: ${receipt.gasUsed.toString()}`);
  console.log(`Events emitted: ${receipt.logs.length}`);

  for (const log of receipt.logs) {
    console.log(`  Event from ${log.address} with topics:`, log.topics);
  }

  return receipt;
}

confirmAndParse('0x4e9f74aa8f9cdcbc8e694209cef9bc5400019cd4e9011fca5954efb4370dc067');

2. Detect Contract Deployments by Checking contractAddress

When monitoring the chain for new contract deployments on Robinhood Chain, check the contractAddress field in transaction receipts. A non-null value indicates a contract creation transaction.

from web3 import Web3

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

def detect_deployment(tx_hash):
    receipt = w3.eth.get_transaction_receipt(tx_hash)

    if not receipt:
        print(f'Transaction {tx_hash} not yet mined')
        return None

    if receipt['contractAddress']:
        print(f'Contract deployed at: {receipt["contractAddress"]}')
        print(f'Deployer: {receipt["from"]}')
        print(f'Gas used: {receipt["gasUsed"]}')
        return receipt['contractAddress']
    else:
        print(f'Transaction {tx_hash} is not a contract deployment')
        return None

detect_deployment('0x4e9f74aa8f9cdcbc8e694209cef9bc5400019cd4e9011fca5954efb4370dc067')

3. Compute Effective Gas Price Paid by the Sender

Use the effectiveGasPrice field from the receipt (available on EIP-1559 chains) to calculate the actual cost of a transaction on an Ethereum-compatible Layer 2 built with Arbitrum Nitro for tokenized real-world assets. Compare this against the gas price from the transaction object for fee analysis.

package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

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

    txHash := common.HexToHash("0x4e9f74aa8f9cdcbc8e694209cef9bc5400019cd4e9011fca5954efb4370dc067")
    receipt, _ := client.TransactionReceipt(context.Background(), txHash)

    if receipt == nil {
        log.Fatal("Transaction not yet mined")
    }

    status := "Success"
    if receipt.Status == 0 {
        status = "Failed"
    }

    fmt.Printf("Status: %s\n", status)
    fmt.Printf("Block: %d\n", receipt.BlockNumber.Uint64())
    fmt.Printf("Gas used: %d\n", receipt.GasUsed)

    // Calculate total cost: gasUsed * effectiveGasPrice
    totalCost := new(big.Int).Mul(
        big.NewInt(int64(receipt.GasUsed)),
        receipt.EffectiveGasPrice,
    )
    fmt.Printf("Total cost: %s wei\n", totalCost.String())

    if receipt.ContractAddress != (common.Address{}) {
        fmt.Printf("Contract deployed at: %s\n", receipt.ContractAddress.Hex())
    }
}

Best Practices

• Receipt is only available after mining; poll until non-null: A null response means the transaction is pending or not found; implement a polling loop with exponential backoff to wait for confirmation
• Check the status field: 0x1 indicates a successful execution; 0x0 means the transaction reverted and may have consumed all provided gas
• Parse the logs array for events using known topic hashes: Each log entry contains up to 4 indexed topics and a data field; use ABI definitions to decode them into readable event parameters
• For frontrunning detection, compare effective gas price across similar transactions: Monitoring the effectiveGasPrice across transactions in a block can reveal priority gas auction dynamics on an Ethereum-compatible Layer 2 built with Arbitrum Nitro for tokenized real-world assets
• contractAddress is non-null only for contract deployment transactions: Use this field to distinguish regular transfers from contract create operations

Code Examples

Error Handling

Note: Returns null if transaction is not yet mined.

Related Methods

• eth_getTransactionByHash - Get transaction details
• eth_getLogs - Query logs by filter