> ## Documentation Index
> Fetch the complete documentation index at: https://voltaire.tevm.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# EventLog() / EventLog.from()

> Primary constructor for event logs

<Card title="Try it Live" icon="play" href="https://playground.tevm.sh?example=primitives/event-log.ts">
  Run EventLog examples in the interactive playground
</Card>

<Tabs />

## Usage Patterns

### From RPC Response

```typescript theme={null}
import { EventLog, Address, Hash, Hex } from 'tevm';

// Transform eth_getLogs response
const rpcLog = {
  address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb2',
  topics: [
    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
    '0x000000000000000000000000a1b2c3d4e5f67890abcdef1234567890abcdef12',
  ],
  data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
  blockNumber: '0x112a880',
  blockHash: '0xabc...',
  transactionHash: '0xdef...',
  transactionIndex: '0xa',
  logIndex: '0x5',
  removed: false,
};

const log = EventLog({
  address: Address(rpcLog.address),
  topics: rpcLog.topics.map(Hash.fromHex),
  data: Hex.toBytes(rpcLog.data),
  blockNumber: BigInt(rpcLog.blockNumber),
  blockHash: Hash(rpcLog.blockHash),
  transactionHash: Hash(rpcLog.transactionHash),
  transactionIndex: Number(rpcLog.transactionIndex),
  logIndex: Number(rpcLog.logIndex),
  removed: rpcLog.removed,
});
```

### Minimal Log (Testing)

```typescript theme={null}
import { EventLog, Address, Hash } from 'tevm';

// Minimal log with required fields only
const testLog = EventLog({
  address: Address.zero(),
  topics: [Hash('0xddf252ad...')],
  data: Hex('0x'),
});

console.log(testLog.blockNumber); // undefined
console.log(testLog.removed); // undefined (defaults to false)
```

### Complete Log with Metadata

```typescript theme={null}
import { EventLog, Address, Hash, Hex } from 'tevm';

const log = EventLog({
  address: Address('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb2'),
  topics: [
    Hash('0xddf252ad...'), // Transfer signature
    Hash('0x000...from'),  // from address
    Hash('0x000...to'),    // to address
  ],
  data: Hex.toBytes('0x0000...0001'), // value
  blockNumber: 18000000n,
  blockHash: Hash('0xabc...'),
  transactionHash: Hash('0xdef...'),
  transactionIndex: 10,
  logIndex: 5,
  removed: false,
});
```

### Anonymous Event

```typescript theme={null}
import { EventLog, Address, Hash } from 'tevm';

// Anonymous event with 4 indexed parameters (no signature in topic0)
const anonymousLog = EventLog({
  address: contractAddress,
  topics: [
    Hash('0x000...param1'),
    Hash('0x000...param2'),
    Hash('0x000...param3'),
    Hash('0x000...param4'),
  ],
  data: Hex('0x'),
});

// getTopic0 returns first indexed parameter (not signature)
const firstParam = anonymousLog.getTopic0();
```

## Type Details

### EventLogParams

```typescript theme={null}
interface EventLogParams {
  address: AddressType;
  topics: readonly (HashType | null | undefined)[];
  data: HexType;
  blockNumber?: bigint;
  blockHash?: HashType;
  transactionHash?: HashType;
  transactionIndex?: number;
  logIndex?: number;
  removed?: boolean;
}
```

### Field Requirements

**Required:**

* `address` - Must be valid 20-byte address
* `topics` - Array of 32-byte hashes (can be empty)
* `data` - Event data as Uint8Array (can be empty)

**Optional:**

* `blockNumber` - Present for mined logs, undefined for pending
* `blockHash` - Present for mined logs, undefined for pending
* `transactionHash` - Present for mined logs, undefined for pending
* `transactionIndex` - Transaction position in block
* `logIndex` - Log position in block (used for sorting)
* `removed` - Chain reorganization flag (defaults to false)

### Topics Array

Maximum 4 topics:

* **Non-anonymous events**: topic0 = signature, topic1-3 = indexed params (max 3)
* **Anonymous events**: topic0-3 = indexed params (max 4)

```typescript theme={null}
// Non-anonymous: Transfer(address indexed from, address indexed to, uint256 value)
const topics = [
  eventSignature,  // topic0
  fromAddress,     // topic1
  toAddress,       // topic2
  // topic3 unused
];

// Anonymous: event AnonymousTransfer(address indexed from, address indexed to, uint256 indexed tokenId, uint256 indexed price) anonymous
const anonymousTopics = [
  fromAddress,     // topic0 (NOT signature)
  toAddress,       // topic1
  tokenIdHash,     // topic2
  priceHash,       // topic3
];
```

## See Also

* [create](/primitives/eventlog/create) - Explicit constructor (alias for from)
* [clone](/primitives/eventlog/clone) - Deep clone existing log
* [Fundamentals](/primitives/eventlog/fundamentals) - Event log structure and topics