# Optimism | Bitquery Data Store

OP Mainnet since its genesis block of November 2021 as flat Parquet: blocks, transactions, internal calls, decoded events, transfers, DEX trades and sequencer fee rewards, at block resolution.

Dataset page: https://bitquery.io/datastore/datasets/optimism
Network: Optimism
Category: Blocks, Transactions, Calls, Events, Transfers, Trades, Rewards
Tables: 7
Columns: 295
Coverage: 2021-11-11 to 2026-10-06
Format: Apache Parquet, ZSTD compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

Seven flat Parquet tables covering OP Mainnet from its genesis block of 11 November 2021 to yesterday, at block resolution: blocks, transactions, calls, events, transfers, dex_trades and miner_rewards. Every table carries Block_Number and Block_Time, and every table but blocks and miner_rewards carries Transaction_Hash, so they join without a lookup table.

The calls and events tables are the ones an archive node will not give you cheaply: each internal call frame with its decoded function signature, arguments and return values, gas and revert state, and each log with its decoded topic signature and the call frame that emitted it. Decoded arguments come as parallel arrays, one entry per argument, with the value typed in the column that matches its ABI type.

Optimism is the original OP Stack rollup, rebuilt on Bedrock in June 2023. Gas is paid in ETH, deposits from Ethereum arrive as type 126 transactions, and the S3 prefix is optimism/.

## What people use it for

- Full-chain analytics without running an archive node or paying per RPC call
- Contract forensics on decoded internal calls, with gas and revert state
- Token and stablecoin flow analysis across the whole chain, not one contract at a time
- Sequencer economics: base fee burn, priority fees and block rewards per block

## Tables (7)

### blocks: 22 columns

One row per OP Mainnet block, with the sequencer, gas, base fee and the trie roots.

Bucket prefix: optimism/blocks
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/blocks/153654200_153654249.parquet
Sample updated: Oct 5, 2026

| column | type | description |
| --- | --- | --- |
| Block_BaseFee | String | EIP-1559 base fee per gas, in ETH, as a decimal string |
| Block_BaseFeeInUSD | Float64 | Base fee per gas valued in USD at the block's hourly ETH price; 0 when unpriced |
| Block_Bloom | String | Bloom filter over the block's logs, hex |
| Block_Coinbase | String | Address credited as block producer, 0x-prefixed; on OP Mainnet this is the sequencer fee vault predeploy |
| Block_Date | Date | UTC date of the block |
| Block_Difficulty | String | Difficulty field as recorded; OP Mainnet has no proof of work, so it carries no mining meaning |
| Block_GasLimit | UInt64 | Gas limit of the block |
| Block_GasUsed | UInt64 | Total gas used by the block's transactions |
| Block_Hash | String | Block hash, 0x-prefixed |
| Block_MixDigest | String | Mix digest field, hex |
| Block_Number | UInt64 | Block height |
| Block_Nonce | UInt64 | Block nonce |
| Block_ParentHash | String | Hash of the parent block, 0x-prefixed |
| Block_ReceiptHash | String | Root of the receipts trie |
| Block_Result_Errors | String | Errors recorded while executing the block; empty when there were none |
| Block_Result_Gas | UInt64 | Gas accounted for in the block's execution result |
| Block_Root | String | State root after the block |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_TxCount | UInt32 | Number of transactions in the block |
| Block_TxHash | String | Root of the transactions trie |
| Block_UncleHash | String | Root of the uncles list. OP Mainnet produces no uncles, so this is the empty-list hash on every block |
| Block_UnclesCount | UInt32 | Number of uncles; always 0 on OP Mainnet |

### transactions: 40 columns

One row per OP Mainnet transaction, with the fee breakdown, receipt status, call count and outcome.

Bucket prefix: optimism/transactions
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/transactions/153654200_153654249.parquet
Sample updated: Oct 7, 2026

| column | type | description |
| --- | --- | --- |
| ChainId | UInt32 | EVM chain id; 10 for Optimism mainnet |
| Block_Date | Date | UTC date of the block |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_Number | UInt64 | Block height |
| Block_Hash | String | Block hash, 0x-prefixed |
| Block_Coinbase | String | Address credited as block producer, 0x-prefixed; on OP Mainnet this is the sequencer fee vault predeploy |
| Block_GasUsed | UInt64 | Total gas used by the block's transactions |
| Block_BaseFee | String | Base fee per gas of the containing block, in ETH, as a decimal string |
| Transaction_Index | UInt32 | Position of the transaction within the block |
| Transaction_Hash | String | Transaction hash, 0x-prefixed. The join key across every table |
| Transaction_Nonce | UInt64 | Sender's nonce |
| Transaction_Type | UInt32 | EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702, 126 deposit from Ethereum L1 |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Transaction_To | String | Address the transaction called, 0x-prefixed; the string 0x for a contract deployment |
| Transaction_Value | String | Native ETH sent with the transaction, decimal adjusted, as a decimal string |
| Transaction_ValueInUSD | Float64 | That value in USD at the block's hourly ETH price |
| Transaction_Gas | UInt64 | Gas limit the sender set |
| Transaction_GasPrice | String | Gas price the sender offered, as a decimal string |
| Transaction_GasPriceInUSD | Float64 | Offered gas price in USD |
| Transaction_GasFeeCap | String | EIP-1559 max fee per gas, as a decimal string |
| Transaction_GasTipCap | String | EIP-1559 max priority fee per gas, as a decimal string |
| Transaction_CallCount | UInt32 | Number of call frames the transaction produced, the top-level call included. Join to the calls table on Transaction_Hash to read them |
| Receipt_Type | UInt32 | Receipt type, mirroring the transaction type |
| Receipt_Status | UInt32 | Receipt status: 1 succeeded, 0 failed |
| Receipt_GasUsed | UInt64 | Gas used by this transaction alone |
| Receipt_ContractAddress | String | Address of the contract deployed by this transaction, 0x-prefixed; the string 0x when none |
| Fee_SenderFee | String | Total network fee the sender paid for the transaction, in ETH, as a decimal string |
| Fee_SenderFeeInUSD | Float64 | Total sender fee in USD |
| Fee_MinerReward | String | Portion of the fee paid to the validator, as a decimal string |
| Fee_MinerRewardInUSD | Float64 | Validator's share of the fee in USD |
| Fee_Burnt | String | ETH burnt by the base fee, as a decimal string |
| Fee_BurntInUSD | Float64 | Burnt fee in USD at the block's hourly ETH price |
| Fee_EffectiveGasPrice | String | Gas price actually charged, in ETH, as a decimal string |
| Fee_EffectiveGasPriceInUSD | Float64 | Effective gas price in USD |
| Fee_PriorityFeePerGas | String | Priority fee per gas, in ETH, as a decimal string |
| Fee_PriorityFeePerGasInUSD | Float64 | Priority fee per gas in USD |
| Fee_GasRefund | UInt64 | Gas refunded to the sender, in gas units |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |
| TransactionStatus_EndError | String | Error the transaction ended with; empty when it succeeded |
| TransactionStatus_FaultError | String | Fault-level error raised during execution; empty when none |

### calls: 65 columns

One row per call frame, internal calls included, with decoded signature, arguments and return values, gas and revert state.

Bucket prefix: optimism/calls
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/calls/153654200_153654249.parquet
Sample updated: Oct 7, 2026

| column | type | description |
| --- | --- | --- |
| ChainId | UInt32 | EVM chain id; 10 for Optimism mainnet |
| Block_Date | Date | UTC date of the block |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_Number | UInt64 | Block height |
| Block_BaseFee | String | Base fee per gas of the containing block, in ETH, as a decimal string |
| Transaction_Index | UInt32 | Position of the transaction within the block |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_To | String | Address the transaction called, 0x-prefixed; the string 0x for a contract deployment |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Receipt_ContractAddress | String | Address of the contract deployed by this transaction, 0x-prefixed; the string 0x when none |
| Receipt_Status | UInt32 | Receipt status: 1 succeeded, 0 failed |
| Fee_SenderFee | String | Total network fee the sender paid for the transaction, in ETH, as a decimal string |
| TransactionStatus_Success | String | Whether the parent transaction succeeded; true or false |
| Call_Index | UInt32 | Position of the frame within the transaction. Events reference it to name the frame that emitted a log |
| Call_Depth | UInt32 | Nesting depth, 0 for the top-level call |
| Call_EnterIndex | UInt32 | Order in which the frame was entered within the transaction |
| Call_ExitIndex | UInt32 | Order in which the frame was exited |
| Call_CallerIndex | Int32 | Call_Index of the calling frame; -1 for the top-level call |
| Call_CallPath | Array | Path of call indexes from the transaction root down to this frame, as an array of integers |
| Call_InternalCalls | UInt32 | Number of calls made beneath this frame |
| Call_From | String | Calling address, 0x-prefixed |
| Call_To | String | Called address, 0x-prefixed |
| Call_Create | String | Whether this frame deployed a contract; true or false |
| Call_Input | String | Raw calldata passed to the frame, hex |
| Call_Gas | UInt64 | Gas supplied to the call |
| Call_Value | String | Native ETH sent with the call, decimal adjusted, as a decimal string |
| Call_ValueInUSD | Float64 | That value in USD at the block's hourly ETH price; 0 when the value is 0 |
| Call_Output | String | Raw return data, hex |
| Call_GasUsed | UInt64 | Gas consumed by this call and everything beneath it |
| Call_Error | String | Error the call returned; empty on success |
| Call_Opcode_Code | UInt32 | Numeric opcode that produced the frame |
| Call_Opcode_Name | String | Opcode name, for example CALL, DELEGATECALL, STATICCALL, CREATE or CREATE2 |
| Call_SelfDestruct | String | Whether the called contract self-destructed; true or false |
| Call_Delegated | String | Whether the frame ran through delegatecall, as proxies do; true or false |
| Call_Success | String | Whether the frame succeeded; true or false |
| Call_Reverted | String | Whether the frame reverted; true or false. A frame can revert inside a transaction that succeeded |
| Call_Signature_Parsed | String | Whether the function signature was resolved and the arguments decoded; the string true or false |
| Call_Signature_Name | String | Function name, when resolved |
| Call_Signature_Signature | String | Canonical function signature, for example transfer(address,uint256) |
| Call_Signature_Abi | String | ABI fragment for the resolved function; empty when the selector is unknown |
| Call_Signature_SignatureHash | String | Four-byte function selector, lower-case hex without 0x |
| Call_Signature_SignatureType | UInt32 | How the function signature was resolved, as a numeric code |
| Arguments_Type_Name | Array | Name of each decoded argument, in ABI order; empty when the signature did not resolve |
| Arguments_Type_Type | Array | Solidity type of each decoded argument, for example address, uint256 or bytes32 |
| Arguments_Type_Index | Array | Position of each decoded argument in the ABI, from 0 |
| Arguments_Path_Name | Array | For struct and array arguments, the member names along the path to each decoded value; an empty list for a plain value |
| Arguments_Path_Type | Array | For struct and array arguments, the member types along the path to each decoded value; an empty list for a plain value |
| Arguments_Path_Index | Array | For struct and array arguments, the member indexes along the path to each decoded value; an empty list for a plain value |
| Arguments_Value_String | Array | Value of each argument rendered as a string; integers appear here in decimal, addresses in hex, and the other Value columns are empty or 0 for that position |
| Arguments_Value_Bytes | Array | Value of each argument whose ABI type is address, bytes or bytesN, as lower-case hex without 0x; empty for other types |
| Arguments_Value_UInt | Array | Value of each unsigned-integer argument that fits in 64 bits; 0 for other types and for larger values, which appear in Arguments_Value_String |
| Arguments_Value_Int | Array | Value of each signed-integer argument that fits in 64 bits; 0 for other types |
| Arguments_Value_Bool | Array | Value of each bool argument as 0 or 1; 0 for other types |
| Returns_Type_Name | Array | Name of each decoded return value, in ABI order; empty when the signature did not resolve or the call returned nothing |
| Returns_Type_Type | Array | Solidity type of each decoded return value |
| Returns_Type_Index | Array | Position of each decoded return value in the ABI, from 0 |
| Returns_Path_Name | Array | For struct and array return values, the member names along the path to each decoded value; an empty list for a plain value |
| Returns_Path_Type | Array | For struct and array return values, the member types along the path to each decoded value; an empty list for a plain value |
| Returns_Path_Index | Array | For struct and array return values, the member indexes along the path to each decoded value; an empty list for a plain value |
| Returns_Value_String | Array | Value of each return value rendered as a string; integers in decimal, addresses in hex |
| Returns_Value_Bytes | Array | Value of each return value whose ABI type is address, bytes or bytesN, as lower-case hex without 0x; empty for other types |
| Returns_Value_UInt | Array | Value of each unsigned-integer return value that fits in 64 bits; 0 for other types and for larger values |
| Returns_Value_Int | Array | Value of each signed-integer return value that fits in 64 bits; 0 for other types |
| Returns_Value_Bool | Array | Value of each bool return value as 0 or 1; 0 for other types |
| Call_LogCount | UInt32 | Number of logs this frame emitted |

### events: 63 columns

One row per log, with the decoded event signature, topics, raw data and the call frame that emitted it.

Bucket prefix: optimism/events
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/events/153654200_153654249.parquet
Sample updated: Oct 7, 2026

| column | type | description |
| --- | --- | --- |
| ChainId | UInt32 | EVM chain id; 10 for Optimism mainnet |
| Block_Date | Date | UTC date of the block |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_Number | UInt64 | Block height |
| Block_BaseFee | String | Base fee per gas of the containing block, in ETH, as a decimal string |
| Transaction_Index | UInt32 | Position of the transaction within the block |
| Transaction_Hash | String | Hash of the containing transaction, 0x-prefixed. The join key |
| Transaction_To | String | Address the transaction called, 0x-prefixed; the string 0x for a contract deployment |
| Transaction_From | String | Address that signed the transaction, 0x-prefixed |
| Receipt_ContractAddress | String | Address of the contract deployed by this transaction, 0x-prefixed; the string 0x when none |
| Receipt_Status | UInt32 | Receipt status: 1 succeeded, 0 failed |
| Fee_SenderFee | String | Total network fee the sender paid for the transaction, in ETH, as a decimal string |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |
| Call_Index | UInt32 | Position of the emitting frame within the transaction; join to calls on this plus Transaction_Hash |
| Call_CallerIndex | Int32 | Call_Index of the frame that called the emitting frame; -1 at the top level |
| Call_CallPath | Array | Path of call indexes from the transaction root down to the emitting frame |
| Call_InternalCalls | UInt32 | Number of calls made beneath the emitting frame |
| Call_From | String | Caller of the emitting frame, 0x-prefixed |
| Call_To | String | Address the emitting frame called, 0x-prefixed |
| Call_Create | String | Whether the emitting frame deployed a contract; true or false |
| Call_Gas | UInt64 | Gas supplied to the emitting frame |
| Call_Value | String | Native ETH sent with the emitting frame, decimal adjusted |
| Call_GasUsed | UInt64 | Gas consumed by the emitting frame and everything beneath it |
| Call_Error | String | Error the emitting frame returned; empty on success |
| Call_SelfDestruct | String | Whether the emitting contract self-destructed; true or false |
| Call_Delegated | String | Whether the frame ran through delegatecall, as proxies do; true or false |
| Call_Success | String | Whether the frame succeeded; true or false |
| Call_Reverted | String | Whether the emitting frame reverted; true or false |
| Call_Signature_Parsed | String | Whether the function signature was resolved and the arguments decoded; the string true or false |
| Call_Signature_Name | String | Name of that function, when resolved |
| Call_Signature_Signature | String | Canonical signature of that function |
| Call_Signature_Abi | String | ABI fragment of the function the emitting frame ran |
| Call_Signature_SignatureHash | String | Four-byte function selector, lower-case hex without 0x |
| Call_Signature_SignatureType | UInt32 | How the function signature was resolved, as a numeric code |
| Log_Index | UInt32 | Position of the log within the transaction |
| Log_EnterIndex | UInt32 | Enter index of the emitting frame |
| Log_ExitIndex | UInt32 | Exit index of the emitting frame |
| Log_LogAfterCallIndex | UInt32 | Index of the last call frame entered before this log, for ordering logs against calls |
| Log_SmartContract | String | Contract that emitted the log, 0x-prefixed. Filter on this for one contract's events |
| Log_Signature_Parsed | String | Whether the event signature was resolved and the arguments decoded; the string true or false |
| Log_Signature_Name | String | Event name, for example Transfer or Swap, when resolved |
| Log_Signature_Signature | String | Canonical event signature, for example Transfer(address,address,uint256) |
| Log_Signature_Abi | String | ABI fragment for the resolved event; empty when the topic is unknown |
| Log_Signature_SignatureHash | String | Keccak hash of the event signature, lower-case hex without 0x; the same value as topic 0 |
| Log_Signature_SignatureType | UInt32 | How the event signature was resolved, as a numeric code |
| LogHeader_Index | UInt64 | Index of the log within the block, as the receipt records it |
| LogHeader_Address | String | Address recorded in the log header, 0x-prefixed |
| LogHeader_Data | String | Raw non-indexed log data, lower-case hex without 0x |
| LogHeader_Removed | String | Whether the log was removed by a reorg; true or false |
| Topics_Hash | Array | Indexed topics of the log, as an array of lower-case hex strings without 0x; the first is the event signature hash |
| Arguments_Type_Name | Array | Name of each decoded argument, in ABI order; empty when the signature did not resolve |
| Arguments_Type_Type | Array | Solidity type of each decoded argument, for example address, uint256 or bytes32 |
| Arguments_Type_Index | Array | Position of each decoded argument in the ABI, from 0 |
| Arguments_Path_Name | Array | For struct and array arguments, the member names along the path to each decoded value; an empty list for a plain value |
| Arguments_Path_Type | Array | For struct and array arguments, the member types along the path to each decoded value; an empty list for a plain value |
| Arguments_Path_Index | Array | For struct and array arguments, the member indexes along the path to each decoded value; an empty list for a plain value |
| Arguments_Value_String | Array | Value of each argument rendered as a string; integers appear here in decimal, addresses in hex, and the other Value columns are empty or 0 for that position |
| Arguments_Value_Bytes | Array | Value of each argument whose ABI type is address, bytes or bytesN, as lower-case hex without 0x; empty for other types |
| Arguments_Value_UInt | Array | Value of each unsigned-integer argument that fits in 64 bits; 0 for other types and for larger values, which appear in Arguments_Value_String |
| Arguments_Value_Int | Array | Value of each signed-integer argument that fits in 64 bits; 0 for other types |
| Arguments_Value_Bool | Array | Value of each bool argument as 0 or 1; 0 for other types |
| Arguments_Value_IsHashed | Array | 1 when the argument was an indexed dynamic type and only its keccak hash is on chain, so the value is the hash; else 0 |
| Arguments_Value_IsIndexed | Array | 1 when the argument was an indexed event parameter, carried in the topics rather than the data; else 0 |

### transfers: 24 columns

One row per native ETH or token transfer on OP Mainnet, with sender, receiver, token metadata and a USD value where a price exists.

Bucket prefix: optimism/transfers
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/transfers/153654200_153654249.parquet
Sample updated: Oct 5, 2026

| column | type | description |
| --- | --- | --- |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in ETH, as a decimal string. It repeats on every row of the transaction, so count it once per transaction |
| Transaction_Hash | String | Hash of the transaction this row settled in, 0x-prefixed; the join key to transactions and logs |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| TransactionStatus_Success | String | Whether the transaction succeeded; the string true or false. Failed transactions are kept |
| Transaction_Type | UInt32 | EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702, 126 deposit from Ethereum L1 |
| Transfer_Amount | String | Amount moved, decimal adjusted, as a decimal string with exactly as many places as the token has decimals. Multiply by 10 to the power of the decimals for the raw on-chain integer |
| Transfer_AmountInUSD | Float64 | Amount valued in USD at the hourly price for the block's hour; 0 when the amount is 0 or the token has no price |
| Transfer_Currency_Decimals | Int32 | Decimals of the transferred currency, as its contract reports them |
| Transfer_Currency_DelegatedTo | String | Implementation address for proxy tokens; the string 0x when there is none |
| Transfer_Currency_Fungible | String | Whether the currency is fungible; the string true or false, and false for NFTs |
| Transfer_Currency_Name | String | Name reported by the contract; lookalike tokens copy real names |
| Transfer_Currency_Native | String | true for native ETH, false for tokens. Filter on this column to separate ETH movement from token movement |
| Transfer_Currency_ProtocolName | String | Token standard, for example erc20 or erc721; empty for native ETH |
| Transfer_Currency_SmartContract | String | Contract of the transferred token, 0x-prefixed; the string 0x for native ETH |
| Transfer_Currency_Symbol | String | Symbol reported by the contract; repeats across tokens, so join on the contract address |
| Transfer_Id | String | Token id for NFT transfers; the string 0 for fungible transfers |
| Transfer_Index | UInt32 | Position within the transaction. Several rows in one transaction can share it |
| Transfer_Sender | String | Sending address, 0x-prefixed |
| Transfer_Receiver | String | Receiving address, 0x-prefixed |
| Transfer_Type | String | token for token transfers, transaction for a plain ETH send, call for ETH moved by a contract in an internal call |
| Transfer_URI | String | Metadata URI for NFT transfers; empty otherwise |

### dex_trades: 54 columns

One row per DEX swap on OP Mainnet, with both sides, pool and protocol, fees, transaction details and a USD value where a price exists.

Bucket prefix: optimism/dex_trades
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/dex_trades/153654263_153654312.parquet
Sample updated: Sep 26, 2026

| column | type | description |
| --- | --- | --- |
| Block_Date | Date | UTC date of the block |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Fee_SenderFee | String | Network fee the sender paid for the whole transaction, in ETH, as a decimal string. It repeats on every row of the transaction, so count it once per transaction |
| Trade_Buy_Amount | String | Amount bought, decimal adjusted, as a decimal string with exactly as many places as the token has decimals; for NFTs, the number of items |
| Trade_Buy_AmountInUSD | Float64 | USD value of the swap at the block's hourly price, set from its best-priced side and the same on both sides; 0 when neither side has a price |
| Trade_Buy_Buyer | String | Address that received the bought currency, usually a router or the trader |
| Trade_Buy_Currency_Decimals | Int32 | Decimals of the bought token, as its contract reports them |
| Trade_Buy_Currency_Fungible | String | Whether the bought token is fungible; true or false, and false for NFTs |
| Trade_Buy_Currency_HasURI | String | Whether the bought token carries a metadata URI; true or false |
| Trade_Buy_Currency_Name | String | Name reported by the bought token's contract; lookalike tokens copy real names |
| Trade_Buy_Currency_ProtocolName | String | Token standard on the bought side, for example erc20 or erc1155; empty for native ETH |
| Trade_Buy_Currency_SmartContract | String | Contract of the bought token, 0x-prefixed; the string 0x for native ETH |
| Trade_Buy_Currency_Symbol | String | Symbol reported by the bought token's contract; not unique, so join on the contract |
| Trade_Buy_Ids | Array | Token ids bought, as strings; empty for fungible tokens |
| Trade_Buy_OrderId | String | Order id for order-book and marketplace trades such as Seaport, hex without 0x; empty for pool swaps. The same value on both sides |
| Trade_Buy_Price | Float64 | Price of the bought currency in units of the sold currency |
| Trade_Buy_PriceInUSD | Float64 | USD price of one unit of the bought currency: the swap's USD value divided by the bought amount, so per item for NFTs; 0 when unpriced |
| Trade_Buy_Seller | String | Address that sent the bought currency, usually the pool |
| Trade_Dex_Delegated | String | true when the pool ran through a delegate call, as proxy and clone pools do, else false; the implementation address is not included |
| Trade_Dex_OwnerAddress | String | Factory or owner the index records for the pool, 0x-prefixed; the string 0x when none. Use it to tell forks apart |
| Trade_Dex_Pair_Decimals | Int32 | Decimals of the pool's own LP token; 0 when the pool has none, as in v3 and v4 |
| Trade_Dex_Pair_Name | String | Name of the pool's own LP token, for example Uniswap V2; empty for v3, v4 and other pools without one |
| Trade_Dex_Pair_SmartContract | String | Pool token contract for v2-style pools, 0x-prefixed; the string 0x otherwise, where Trade_Dex_SmartContract or Trade_PoolId names the pool |
| Trade_Dex_Pair_Symbol | String | Symbol of the pool's own LP token, for example UNI-V2; not unique |
| Trade_Dex_ProtocolFamily | String | Protocol family, for example Uniswap, Aerodrome or Balancer. Filter this column to keep or drop a venue |
| Trade_Dex_ProtocolName | String | Protocol and version as indexed, for example uniswap_v3 or seaport_v1.4. It names the pool design, so forks can share it |
| Trade_Dex_ProtocolVersion | String | Protocol version string |
| Trade_Dex_SmartContract | String | Contract that emitted the swap, 0x-prefixed: the pool for v2 and v3 designs, the shared PoolManager for Uniswap v4 and PancakeSwap Infinity, the exchange for marketplaces |
| Trade_Fees | String | Fees charged on the swap as a JSON array of [amount, amountInUSD, [decimals, name, token standard, contract hex, symbol], payer, recipient]; the USD value is set when the fee token is one side of the swap; [] when none |
| Trade_Index | UInt32 | Position of the swap within the transaction |
| Trade_PoolId | String | 32-byte pool id, 0x-prefixed, for Uniswap v4 and PancakeSwap Infinity, whose pools share one contract; empty for other protocols |
| Trade_Sell_Amount | String | Amount sold, decimal adjusted, as a decimal string with exactly as many places as the token has decimals; for NFTs, the number of items |
| Trade_Sell_AmountInUSD | Float64 | USD value of the swap at the block's hourly price, set from its best-priced side and the same on both sides; 0 when neither side has a price |
| Trade_Sell_Buyer | String | Address that received the sold currency, usually the pool |
| Trade_Sell_Currency_Decimals | Int32 | Decimals of the sold token, as its contract reports them |
| Trade_Sell_Currency_Fungible | String | Whether the sold token is fungible; true or false, and false for NFTs |
| Trade_Sell_Currency_HasURI | String | Whether the sold token carries a metadata URI; true or false |
| Trade_Sell_Currency_Name | String | Name reported by the sold token's contract; lookalike tokens copy real names |
| Trade_Sell_Currency_ProtocolName | String | Token standard on the sold side, for example erc20 or erc1155; empty for native ETH |
| Trade_Sell_Currency_SmartContract | String | Contract of the sold token, 0x-prefixed; the string 0x for native ETH |
| Trade_Sell_Currency_Symbol | String | Symbol reported by the sold token's contract; not unique, so join on the contract |
| Trade_Sell_Ids | Array | Token ids sold, as strings; empty for fungible tokens |
| Trade_Sell_OrderId | String | Order id for order-book and marketplace trades such as Seaport, hex without 0x; empty for pool swaps. The same value on both sides |
| Trade_Sell_Price | Float64 | Price of the sold currency in units of the bought currency |
| Trade_Sell_PriceInUSD | Float64 | USD price of one unit of the sold currency: the swap's USD value divided by the sold amount, so per item for NFTs; 0 when unpriced |
| Trade_Sell_Seller | String | Address that sent the sold currency, usually a router or the trader |
| Trade_Sender | String | Address that called the pool, often a router or aggregator |
| Transaction_From | String | Address that signed the transaction: the trader behind any router |
| Transaction_Hash | String | Hash of the transaction, 0x-prefixed; the join key to transfers and logs |
| Transaction_Index | UInt64 | Position of the transaction within the block |
| Transaction_To | String | Contract the transaction called, often a router |
| TransactionStatus_Success | String | Whether the transaction succeeded; true or false |
| Trade_Success | String | Whether this swap succeeded; true or false. A swap can fail inside a successful transaction, so filter on this column |

### miner_rewards: 27 columns

One row per block, splitting the sequencer's take into static, dynamic, transaction-fee and burnt components. Indexed from 9 July 2026 (block 154,016,455).

Bucket prefix: optimism/miner_rewards
File naming: <start_block>_<end_block>.parquet, 50 blocks per file, sorted ascending
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/optimism/miner_rewards/157326212_157326261.parquet
Sample updated: Oct 5, 2026

| column | type | description |
| --- | --- | --- |
| Block_Number | UInt64 | Block height |
| Block_Time | DateTime | Block timestamp, UTC |
| Block_TxCount | UInt32 | Number of transactions in the block |
| Block_Root | String | State root after the block |
| Block_UnclesCount | UInt32 | Number of uncles; always 0 on OP Mainnet |
| Block_TxHash | String | Root of the transactions trie |
| Block_GasUsed | UInt64 | Total gas used by the block |
| Block_BaseFee | String | Base fee per gas of the block, in ETH, as a decimal string |
| Block_Coinbase | String | Validator credited with the block, 0x-prefixed |
| Block_GasLimit | UInt64 | Gas limit of the block |
| Block_Date | Date | UTC date of the block |
| Block_Hash | String | Block hash, 0x-prefixed |
| Reward_BurntFees | String | ETH burnt by the base fee across the block, as a decimal string |
| Reward_BurntFeesInUSD | Float64 | Burnt fees in USD at the block's hourly ETH price |
| Reward_DynamicInUSD | Float64 | Dynamic reward component in USD |
| Reward_Dynamic | String | Dynamic reward component, as a decimal string |
| Reward_Static | String | Fixed block subsidy, as a decimal string. OP Mainnet pays no protocol subsidy, so this is 0 |
| Reward_StaticInUSD | Float64 | Static reward in USD |
| Reward_Total | String | Total reward credited for the block, as a decimal string |
| Reward_TotalInUSD | Float64 | Total reward in USD |
| Reward_TxFees | String | Transaction fees credited to the sequencer, as a decimal string. On OP Mainnet this is effectively the whole reward |
| Reward_TxFeesInUSD | Float64 | Transaction fees in USD |
| Reward_UncleInUSD | Float64 | Uncle reward in USD; always 0 on OP Mainnet |
| Reward_Uncle | String | Uncle reward, as a decimal string; always 0 on OP Mainnet |
| Uncle_Block_Number | UInt64 | Block height of the uncle; always 0 on OP Mainnet |
| Uncle_Index | UInt32 | Index of the uncle; always 0 on OP Mainnet |
| ChainId | UInt64 | EVM chain id; 10 for Optimism mainnet |

## Price

- Latest month (Sep 6, 2026 → Oct 6, 2026): $400 one-time, USD
- Last 12 months (Oct 6, 2025 → Oct 6, 2026): $2,400 one-time, USD
- Last 24 months (Oct 6, 2024 → Oct 6, 2026): $4,800 one-time, USD
- Full history (Nov 11, 2021 → Oct 6, 2026): $12,000 one-time, USD

Every window includes all 7 tables and 295 columns. Only the time range changes.

## Questions buyers ask

Q: What is included in the Optimism dataset?
A: Seven Parquet tables with 295 documented columns in total: blocks (22), transactions (40), calls (65), events (63), transfers (24), dex_trades (54) and miner_rewards (27). Each purchase covers the window you choose, through to yesterday, refreshed daily. The Full tier starts at the genesis block of 11 November 2021 for six tables; miner_rewards is indexed from 9 July 2026.

Q: How far back does the full history go?
A: To block 0 of the current chain on 11 November 2021, the regenesis that reset OP Mainnet's state. The Bedrock upgrade of June 2023 then changed how blocks are produced, from one block per transaction to fixed two-second blocks, so block-level statistics before and after it are not directly comparable; Block_Time and Block_TxCount make the boundary easy to find.

Q: How large is the full dataset?
A: The largest tier by a wide margin, and calls and events dominate it; both carry several rows per transaction, where transfers and dex_trades carry one per movement. We size it per table before delivery and send you the exact figures with the manifest, so you can plan storage before downloading. If calls and events are more than you need, we can quote the other five tables on their own.

Q: How do the tables join?
A: On Transaction_Hash, which appears in every table except blocks and miner_rewards; those join on Block_Number. Within a transaction, Call_Index orders the call frames, Log_Index orders the logs, Transfer_Index orders the transfers and Trade_Index orders the swaps. A log points back to the frame that emitted it through Call_Index.

Q: What is deliberately not in this dataset?
A: Balance updates. The chain-wide balance_updates table exists in our store but is not part of this bundle, because it carries several rows per transfer and would dominate the size. If you need it, ask and we will quote it alongside this one.

Q: How are decoded arguments laid out?
A: As parallel arrays rather than one JSON column: element i of Arguments_Type_Name, Arguments_Type_Type and the Arguments_Value_* columns all describe argument i. Each value sits in the column matching its ABI type, addresses and bytes in Arguments_Value_Bytes as hex, small integers in Arguments_Value_UInt or Arguments_Value_Int, and every value also rendered in Arguments_Value_String. The Arguments_Path_* arrays give the member path for struct and array arguments. In calls, the Returns_* columns follow the same layout for return values.

Q: Does the dataset include the L1 data fee?
A: The fee columns carry what the execution layer records for the transaction: gas used, effective gas price, base fee and priority fee, in ETH and USD. The separate L1 data fee that OP Stack chains charge is not a column in this schema. If you need it, ask and we will scope it.

Q: What are type 126 transactions?
A: Deposits from Ethereum. The OP Stack delivers each L1-to-L2 deposit as a system transaction with Transaction_Type 126, at the top of a block, with no signature from a user. They are included, and they are the rows to filter out if you want user activity only.

Q: Does OP Mainnet have uncles? The schema has uncle columns.
A: No. OP Mainnet has a single sequencer and produces no uncle blocks, so Block_UnclesCount is 0 on every block, Block_UncleHash is the empty-list hash, and Reward_Uncle, Uncle_Block_Number and Uncle_Index in miner_rewards are 0 throughout. The columns exist because the schema is shared with chains that do have uncles; they are kept so a query written against one EVM chain runs unchanged here.

Q: Which DEXes are in dex_trades?
A: Every venue we decode on OP Mainnet, in one table, identified by Trade_Dex_ProtocolFamily and Trade_Dex_ProtocolName on each row. In the sample window the families present were Uniswap, Aerodrome and Balancer. Filter the family column to keep or drop a venue.

Q: How much of it is valued in USD?
A: Only currencies with an hourly price series are valued, and the dataset says so rather than filling the gap: a USD value of 0 means either a zero-value row or no price, and the column cannot tell the two apart. DEX trades are priced from the safer side of the swap, so most swaps with a stablecoin or ETH on one side carry a value; transfers of long-tail and spam tokens mostly do not.

Q: Are failed transactions included?
A: Yes, throughout, and the export applies no filter of its own. TransactionStatus_Success carries the transaction's outcome on every table that has it, and dex_trades additionally carries Trade_Success, because a single swap can fail inside a transaction that succeeded. Spam tokens, zero-value rows and lookalike contracts are all kept too; the columns let you drop what you do not want.

Q: How do I get one contract's activity?
A: Filter Call_To in calls and Log_SmartContract in events to the contract, lower case with 0x. For token flow, filter Transfer_Currency_SmartContract in transfers. Join on contract addresses rather than symbols or names; both repeat, and lookalike tokens copy them deliberately.

Q: How are amounts and booleans encoded?
A: Amounts are decimal-adjusted decimal strings, carrying exactly as many places as the token has decimals; multiply by ten to the power of the decimals for the raw on-chain integer. Casting to float loses precision on large values. Boolean flags are the strings true and false; only the Arguments_Value_Bool and Returns_Value_Bool arrays use 0 and 1, one entry per decoded argument.

Q: How do I load it?
A: One line in DuckDB: SELECT * FROM read_parquet('transfers/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). The sample files open without credentials.

Q: How is the data delivered, and how current is it?
A: As flat Parquet named by block range, 50 blocks per file and sorted ascending, one prefix per table, with a JSON manifest listing every file and its sha256. We prepare the files within 7 business days of purchase and email you the location. You choose at checkout where to collect them: a Requester Pays S3 bucket, downloaded with your own AWS account, or a Cloudflare R2 bucket with a read-only API key and no egress fees. Files stay available for 7 days from delivery. Enterprise orders can be delivered into your own S3, GCS or R2 bucket. Refreshed daily with T+1 latency, so a purchase made today includes everything to yesterday.

Q: Can I try before I buy?
A: Yes. Each table links to a public sample file with real records, and the sample bucket holds full Parquet files you can load directly. No email address required.

## What this file is, and is not

This is a description of one dataset sold by Bitquery, written for assistants and for people. It lists every column but holds no data rows. The sample files linked under each table are real Parquet and are free to download. Figures here come from the product record and are exact unless marked otherwise; the delivery manifest is authoritative for a purchased file. If a question needs a row that is not in a sample, say so rather than guessing at it.