Receipts & Logs

import { createTevmNode } from 'tevm'
import { createImpersonatedTx } from 'tevm/tx'
import { runTx } from 'tevm/vm'
import { createAddress } from 'tevm/utils'
 
const node = createTevmNode() 
const receiptsManager = await node.getReceiptsManager() 
 
// Execute a transaction
const vm = await node.getVm() 
const tx = createImpersonatedTx({ 
  impersonatedAddress: createAddress('0x1234567890123456789012345678901234567890'), 
  to: createAddress('0x2345678901234567890123456789012345678901'), 
  value: 1000000000000000000n, // 1 ETH 
  gasLimit: 21000n, 
}) 
 
// Run the transaction
const result = await runTx(vm)({ tx }) 
const txHash = tx.hash() 
 
// Get the receipt
const receiptResult = await receiptsManager.getReceiptByTxHash(txHash) 
 
if (receiptResult) { 
  const [receipt, blockHash, txIndex, logIndex] = receiptResult 
  // Access receipt data
  console.log({ 
    status: 'status' in receipt ? receipt.status : undefined, 
    gasUsed: receipt.cumulativeBlockGasUsed, 
    logs: receipt.logs 
  }) 
} 

import { createTevmNode } from 'tevm'
import { createImpersonatedTx } from 'tevm/tx'
import { runTx } from 'tevm/vm'
import { createAddress, hexToBytes } from 'tevm/utils'
 
const node = createTevmNode() 
const receiptsManager = await node.getReceiptsManager() 
 
// Get blocks for filtering
const vm = await node.getVm() 
const fromBlock = await vm.blockchain.getBlockByTag('earliest') 
const toBlock = await vm.blockchain.getBlockByTag('latest') 
const contractAddress = createAddress('0x1234567890123456789012345678901234567890') 
 
// Filter by contract address
const addressLogs = await receiptsManager.getLogs( 
  fromBlock, 
  toBlock, 
  [contractAddress.toBytes()], // Filter by this address 
  undefined // No topic filter 
) 
 
// Filter by event topic (event signature hash)
const eventTopic = hexToBytes('0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef') // Transfer event 
const topicLogs = await receiptsManager.getLogs( 
  fromBlock, 
  toBlock, 
  undefined, // Any address 
  [eventTopic] // Filter by this topic 
) 
 
// Print results
console.log(`Found ${addressLogs.length} logs from the contract`)
console.log(`Found ${topicLogs.length} Transfer events`)

interface PreByzantiumReceipt {
  stateRoot: Uint8Array        // Merkle root after transaction
  cumulativeBlockGasUsed: bigint
  logs: Log[]                  // Event logs
  // No status field
}
 
interface PostByzantiumReceipt {
  status: number               // 1 for success, 0 for failure
  cumulativeBlockGasUsed: bigint
  logs: Log[]                  // Event logs
}
 
interface EIP4844Receipt extends PostByzantiumReceipt {
  blobGasUsed: bigint          // Gas used for blob data
  blobGasPrice: bigint         // Price paid for blob data
}

// Function to handle different receipt types
function processReceipt(receiptResult) {
  if (!receiptResult) return 'Receipt not found'
 
  const [receipt] = receiptResult
 
  if ('status' in receipt) {
    // Post-Byzantium receipt
    return `Transaction ${receipt.status === 1 ? 'succeeded' : 'failed'}`
  } else {
    // Pre-Byzantium receipt
    return `Transaction included with state root: 0x${Buffer.from(receipt.stateRoot).toString('hex')}`
  }
}

// Get logs with complex filters:
// 1. From a specific contract
// 2. With Transfer event signature
// 3. From a specific sender
// 4. To a specific receiver
 
const fromAddress = '0x1234567890123456789012345678901234567890'
const toAddress = '0x2345678901234567890123456789012345678901'
 
// Event topics with wildcards (undefined means "any value")
const topics = [
  hexToBytes('0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'), // Transfer event
  hexToBytes('0x000000000000000000000000' + fromAddress.slice(2)),                   // From address (padded)
  hexToBytes('0x000000000000000000000000' + toAddress.slice(2))                      // To address (padded)
]
 
const filteredLogs = await receiptsManager.getLogs(
  fromBlock,
  toBlock,
  [contractAddress.toBytes()], // Contract address
  topics                        // Topic filters
)

// Track events across multiple contracts (e.g., a token and a marketplace)
const tokenAddress = createAddress('0x1234567890123456789012345678901234567890')
const marketplaceAddress = createAddress('0x2345678901234567890123456789012345678901')
 
// Get Transfer events from either contract
const transferEvent = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
 
const transfers = await receiptsManager.getLogs(
  fromBlock,
  toBlock,
  [tokenAddress.toBytes(), marketplaceAddress.toBytes()], // Multiple addresses
  [hexToBytes(transferEvent)]
)
 
console.log('Events by contract:')
const tokenEvents = transfers.filter(log =>
  Buffer.from(log.address).toString('hex') ===
  Buffer.from(tokenAddress.toBytes()).toString('hex')
)
const marketplaceEvents = transfers.filter(log =>
  Buffer.from(log.address).toString('hex') ===
  Buffer.from(marketplaceAddress.toBytes()).toString('hex')
)

// The ReceiptsManager maintains indexes for:
// 1. Transaction hash → receipt
// 2. Block hash → receipts
// 3. Address → logs
// 4. Topics → logs
 
// You can directly get a receipt by transaction hash
const receipt = await receiptsManager.getReceiptByTxHash(txHash)
 
// Or get all receipts in a block
const block = await vm.blockchain.getLatestBlock()
const blockHash = block.hash()
const receipts = await receiptsManager.getBlockReceipts(blockHash)
 
// Performance considerations:
// - Receipt storage grows with blockchain size
// - ReceiptsManager implements limits to prevent excessive resource usage
 
// Built-in limits
const GET_LOGS_LIMIT = 10000          // Maximum number of logs returned
const GET_LOGS_LIMIT_MEGABYTES = 150  // Maximum response size
const GET_LOGS_BLOCK_RANGE_LIMIT = 2500 // Maximum block range for queries
 
// For large-scale applications, implement pagination or additional filtering