@mikeatlast/ponder 0.16.1-fork.1

package/dist/esm/runtime/events.js

@@ -0,0 +1,664 @@
+import { EVENT_TYPES, MAX_CHECKPOINT, ZERO_CHECKPOINT, encodeCheckpoint, } from '../utils/checkpoint.js';
+import { decodeEventLog } from '../utils/decodeEventLog.js';
+import { toLowerCase } from '../utils/lowercase.js';
+import { decodeFunctionData, decodeFunctionResult, hexToBigInt, hexToNumber, toEventSelector, toFunctionSelector, } from "viem";
+import { isAddressMatched, isBlockFilterMatched, isLogFilterMatched, isTraceFilterMatched, isTransactionFilterMatched, isTransferFilterMatched, } from "./filter.js";
+import { isAddressFactory } from "./filter.js";
+/**
+ * Create `RawEvent`s from raw data types
+ */
+export const buildEvents = ({ eventCallbacks, blocks, logs, transactions, transactionReceipts, traces, childAddresses, chainId, }) => {
+    const events = [];
+    const blockEventCallbackIndexes = [];
+    const transactionEventCallbackIndexes = [];
+    const logEventCallbackIndexes = [];
+    const traceEventCallbackIndexes = [];
+    const transferEventCallbackIndexes = [];
+    for (let i = 0; i < eventCallbacks.length; i++) {
+        const eventCallback = eventCallbacks[i];
+        if (chainId !== eventCallback.filter.chainId)
+            continue;
+        if (eventCallback.filter.type === "block") {
+            blockEventCallbackIndexes.push(i);
+        }
+        else if (eventCallback.filter.type === "transaction") {
+            transactionEventCallbackIndexes.push(i);
+        }
+        else if (eventCallback.filter.type === "log") {
+            logEventCallbackIndexes.push(i);
+        }
+        else if (eventCallback.filter.type === "trace") {
+            traceEventCallbackIndexes.push(i);
+        }
+        else if (eventCallback.filter.type === "transfer") {
+            transferEventCallbackIndexes.push(i);
+        }
+    }
+    let blocksIndex = 0;
+    let transactionsIndex = 0;
+    let transactionReceiptsIndex = 0;
+    for (const block of blocks) {
+        for (const blockEventCallbackIndex of blockEventCallbackIndexes) {
+            const filter = eventCallbacks[blockEventCallbackIndex]
+                .filter;
+            if (isBlockFilterMatched({ filter, block })) {
+                events.push({
+                    chainId: filter.chainId,
+                    eventCallbackIndex: blockEventCallbackIndex,
+                    checkpoint: encodeCheckpoint({
+                        blockTimestamp: block.timestamp,
+                        chainId: filter.chainId,
+                        blockNumber: block.number,
+                        transactionIndex: MAX_CHECKPOINT.transactionIndex,
+                        eventType: EVENT_TYPES.blocks,
+                        eventIndex: ZERO_CHECKPOINT.eventIndex,
+                    }),
+                    block,
+                    log: undefined,
+                    trace: undefined,
+                    transaction: undefined,
+                    transactionReceipt: undefined,
+                });
+            }
+        }
+    }
+    for (const transaction of transactions) {
+        const blockNumber = transaction.blockNumber;
+        const transactionIndex = transaction.transactionIndex;
+        while (blocksIndex < blocks.length &&
+            Number(blocks[blocksIndex].number) < blockNumber) {
+            blocksIndex++;
+        }
+        const block = blocks[blocksIndex];
+        if (block === undefined) {
+            throw new Error(`Failed to build events from block data. Missing block ${blockNumber} for chain ID ${chainId}`);
+        }
+        while (transactionReceiptsIndex < transactionReceipts.length &&
+            (transactionReceipts[transactionReceiptsIndex].blockNumber <
+                blockNumber ||
+                (transactionReceipts[transactionReceiptsIndex].blockNumber ===
+                    blockNumber &&
+                    transactionReceipts[transactionReceiptsIndex].transactionIndex <
+                        transactionIndex))) {
+            transactionReceiptsIndex++;
+        }
+        const transactionReceipt = transactionReceipts[transactionReceiptsIndex];
+        for (const transactionEventCallbackIndex of transactionEventCallbackIndexes) {
+            const filter = eventCallbacks[transactionEventCallbackIndex]
+                .filter;
+            if (isTransactionFilterMatched({ filter, transaction }) &&
+                (isAddressFactory(filter.fromAddress)
+                    ? isAddressMatched({
+                        address: transaction.from,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.fromAddress.id),
+                    })
+                    : true) &&
+                (isAddressFactory(filter.toAddress)
+                    ? isAddressMatched({
+                        address: transaction.to ?? undefined,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.toAddress.id),
+                    })
+                    : true) &&
+                (filter.includeReverted
+                    ? true
+                    : transactionReceipt.status === "success")) {
+                if (filter.hasTransactionReceipt && transactionReceipt === undefined) {
+                    throw new Error(`Failed to build events from block data. Missing transaction receipt for block ${blockNumber} and transaction index ${transactionIndex} for chain ID ${chainId}`);
+                }
+                events.push({
+                    chainId: filter.chainId,
+                    eventCallbackIndex: transactionEventCallbackIndex,
+                    checkpoint: encodeCheckpoint({
+                        blockTimestamp: block.timestamp,
+                        chainId: filter.chainId,
+                        blockNumber,
+                        transactionIndex,
+                        eventType: EVENT_TYPES.transactions,
+                        eventIndex: 0n,
+                    }),
+                    log: undefined,
+                    trace: undefined,
+                    block,
+                    transaction,
+                    transactionReceipt,
+                });
+            }
+        }
+    }
+    blocksIndex = 0;
+    transactionReceiptsIndex = 0;
+    for (const trace of traces) {
+        const blockNumber = trace.blockNumber;
+        const transactionIndex = trace.transactionIndex;
+        const traceIndex = trace.traceIndex;
+        while (blocksIndex < blocks.length &&
+            Number(blocks[blocksIndex].number) < blockNumber) {
+            blocksIndex++;
+        }
+        const block = blocks[blocksIndex];
+        if (block === undefined) {
+            throw new Error(`Failed to build events from block data. Missing block ${blockNumber} for chain ID ${chainId}`);
+        }
+        while (transactionsIndex < transactions.length &&
+            (transactions[transactionsIndex].blockNumber < blockNumber ||
+                (transactions[transactionsIndex].blockNumber === blockNumber &&
+                    transactions[transactionsIndex].transactionIndex < transactionIndex))) {
+            transactionsIndex++;
+        }
+        let transaction;
+        if (transactionsIndex < transactions.length &&
+            transactions[transactionsIndex].blockNumber === blockNumber &&
+            transactions[transactionsIndex].transactionIndex === transactionIndex) {
+            transaction = transactions[transactionsIndex];
+        }
+        if (transaction === undefined) {
+            throw new Error(`Failed to build events from block data. Missing transaction for block ${blockNumber} and transaction index ${transactionIndex} for chain ID ${chainId}`);
+        }
+        while (transactionReceiptsIndex < transactionReceipts.length &&
+            (transactionReceipts[transactionReceiptsIndex].blockNumber <
+                blockNumber ||
+                (transactionReceipts[transactionReceiptsIndex].blockNumber ===
+                    blockNumber &&
+                    transactionReceipts[transactionReceiptsIndex].transactionIndex <
+                        transactionIndex))) {
+            transactionReceiptsIndex++;
+        }
+        let transactionReceipt;
+        if (transactionReceiptsIndex < transactionReceipts.length &&
+            transactionReceipts[transactionReceiptsIndex].blockNumber ===
+                blockNumber &&
+            transactionReceipts[transactionReceiptsIndex].transactionIndex ===
+                transactionIndex) {
+            transactionReceipt = transactionReceipts[transactionReceiptsIndex];
+        }
+        for (const traceEventCallbackIndex of traceEventCallbackIndexes) {
+            const filter = eventCallbacks[traceEventCallbackIndex]
+                .filter;
+            if (isTraceFilterMatched({ filter, trace, block }) &&
+                (isAddressFactory(filter.fromAddress)
+                    ? isAddressMatched({
+                        address: trace.from,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.fromAddress.id),
+                    })
+                    : true) &&
+                (isAddressFactory(filter.toAddress)
+                    ? isAddressMatched({
+                        address: trace.to ?? undefined,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.toAddress.id),
+                    })
+                    : true) &&
+                (filter.callType === undefined
+                    ? true
+                    : filter.callType === trace.type) &&
+                (filter.includeReverted ? true : trace.error === undefined)) {
+                if (filter.hasTransactionReceipt && transactionReceipt === undefined) {
+                    throw new Error(`Failed to build events from block data. Missing transaction receipt for block ${blockNumber} and transaction index ${transactionIndex} for chain ID ${chainId}`);
+                }
+                events.push({
+                    chainId: filter.chainId,
+                    eventCallbackIndex: traceEventCallbackIndex,
+                    checkpoint: encodeCheckpoint({
+                        blockTimestamp: block.timestamp,
+                        chainId: filter.chainId,
+                        blockNumber,
+                        transactionIndex,
+                        eventType: EVENT_TYPES.traces,
+                        eventIndex: traceIndex,
+                    }),
+                    log: undefined,
+                    trace,
+                    block,
+                    transaction,
+                    transactionReceipt: filter.hasTransactionReceipt
+                        ? transactionReceipt
+                        : undefined,
+                });
+            }
+        }
+        for (const transferEventCallbackIndex of transferEventCallbackIndexes) {
+            const filter = eventCallbacks[transferEventCallbackIndex]
+                .filter;
+            if (isTransferFilterMatched({ filter, trace, block }) &&
+                (isAddressFactory(filter.fromAddress)
+                    ? isAddressMatched({
+                        address: trace.from,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.fromAddress.id),
+                    })
+                    : true) &&
+                (isAddressFactory(filter.toAddress)
+                    ? isAddressMatched({
+                        address: trace.to ?? undefined,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.toAddress.id),
+                    })
+                    : true) &&
+                (filter.includeReverted ? true : trace.error === undefined)) {
+                if (filter.hasTransactionReceipt && transactionReceipt === undefined) {
+                    throw new Error(`Failed to build events from block data. Missing transaction receipt for block ${blockNumber} and transaction index ${transactionIndex} for chain ID ${chainId}`);
+                }
+                events.push({
+                    chainId: filter.chainId,
+                    eventCallbackIndex: transferEventCallbackIndex,
+                    checkpoint: encodeCheckpoint({
+                        blockTimestamp: block.timestamp,
+                        chainId: filter.chainId,
+                        blockNumber,
+                        transactionIndex,
+                        eventType: EVENT_TYPES.traces,
+                        eventIndex: trace.traceIndex,
+                    }),
+                    log: undefined,
+                    trace,
+                    block,
+                    transaction,
+                    transactionReceipt: filter.hasTransactionReceipt
+                        ? transactionReceipt
+                        : undefined,
+                });
+            }
+        }
+    }
+    blocksIndex = 0;
+    transactionsIndex = 0;
+    transactionReceiptsIndex = 0;
+    for (const log of logs) {
+        const blockNumber = log.blockNumber;
+        const transactionIndex = log.transactionIndex;
+        while (blocksIndex < blocks.length &&
+            Number(blocks[blocksIndex].number) < blockNumber) {
+            blocksIndex++;
+        }
+        const block = blocks[blocksIndex];
+        if (block === undefined) {
+            throw new Error(`Failed to build events from block data. Missing block ${blockNumber} for chain ID ${chainId}`);
+        }
+        while (transactionsIndex < transactions.length &&
+            (transactions[transactionsIndex].blockNumber < blockNumber ||
+                (transactions[transactionsIndex].blockNumber === blockNumber &&
+                    transactions[transactionsIndex].transactionIndex < transactionIndex))) {
+            transactionsIndex++;
+        }
+        let transaction;
+        if (transactionsIndex < transactions.length &&
+            transactions[transactionsIndex].blockNumber === blockNumber &&
+            transactions[transactionsIndex].transactionIndex === transactionIndex) {
+            transaction = transactions[transactionsIndex];
+        }
+        // Note: transaction can be undefined, this is expected behavior on
+        // chains like zkSync.
+        while (transactionReceiptsIndex < transactionReceipts.length &&
+            (transactionReceipts[transactionReceiptsIndex].blockNumber <
+                blockNumber ||
+                (transactionReceipts[transactionReceiptsIndex].blockNumber ===
+                    blockNumber &&
+                    transactionReceipts[transactionReceiptsIndex].transactionIndex <
+                        transactionIndex))) {
+            transactionReceiptsIndex++;
+        }
+        let transactionReceipt;
+        if (transactionReceiptsIndex < transactionReceipts.length &&
+            transactionReceipts[transactionReceiptsIndex].blockNumber ===
+                blockNumber &&
+            transactionReceipts[transactionReceiptsIndex].transactionIndex ===
+                transactionIndex) {
+            transactionReceipt = transactionReceipts[transactionReceiptsIndex];
+        }
+        for (const logEventCallbackIndex of logEventCallbackIndexes) {
+            const filter = eventCallbacks[logEventCallbackIndex].filter;
+            if (isLogFilterMatched({ filter, log }) &&
+                (isAddressFactory(filter.address)
+                    ? isAddressMatched({
+                        address: log.address,
+                        blockNumber,
+                        childAddresses: childAddresses.get(filter.address.id),
+                    })
+                    : true)) {
+                if (filter.hasTransactionReceipt && transactionReceipt === undefined) {
+                    throw new Error(`Failed to build events from block data. Missing transaction receipt for block ${blockNumber} and transaction index ${transactionIndex} for chain ID ${chainId}`);
+                }
+                events.push({
+                    chainId: filter.chainId,
+                    eventCallbackIndex: logEventCallbackIndex,
+                    checkpoint: encodeCheckpoint({
+                        blockTimestamp: block.timestamp,
+                        chainId: filter.chainId,
+                        blockNumber,
+                        transactionIndex: log.transactionIndex,
+                        eventType: EVENT_TYPES.logs,
+                        eventIndex: log.logIndex,
+                    }),
+                    log,
+                    block,
+                    transaction,
+                    transactionReceipt: filter.hasTransactionReceipt
+                        ? transactionReceipt
+                        : undefined,
+                    trace: undefined,
+                });
+            }
+        }
+    }
+    return events.sort((a, b) => (a.checkpoint < b.checkpoint ? -1 : 1));
+};
+export const splitEvents = (events) => {
+    let hash;
+    const result = [];
+    for (const event of events) {
+        if (hash === undefined || hash !== event.event.block.hash) {
+            result.push({
+                events: [],
+                chainId: event.chain.id,
+                checkpoint: encodeCheckpoint({
+                    ...MAX_CHECKPOINT,
+                    blockTimestamp: event.event.block.timestamp,
+                    chainId: BigInt(event.chain.id),
+                    blockNumber: event.event.block.number,
+                }),
+            });
+            hash = event.event.block.hash;
+        }
+        result[result.length - 1].events.push(event);
+    }
+    return result;
+};
+export const decodeEvents = (common, chain, eventCallbacks, rawEvents) => {
+    const events = [];
+    const logDecodeFailureSelectors = new Set();
+    let logDecodeFailureCount = 0;
+    let logDecodeSuccessCount = 0;
+    const traceDecodeFailureSelectors = new Set();
+    let traceDecodeFailureCount = 0;
+    let traceDecodeSuccessCount = 0;
+    for (const event of rawEvents) {
+        const eventCallback = eventCallbacks[event.eventCallbackIndex];
+        if (eventCallback.type === "contract" &&
+            eventCallback.filter.type === "log") {
+            let args;
+            try {
+                args = decodeEventLog({
+                    abiItem: eventCallback.abiItem,
+                    data: event.log.data,
+                    topics: event.log.topics,
+                });
+                logDecodeSuccessCount++;
+            }
+            catch (err) {
+                logDecodeFailureCount++;
+                const selector = toEventSelector(eventCallback.abiItem);
+                if (!logDecodeFailureSelectors.has(selector)) {
+                    logDecodeFailureSelectors.add(selector);
+                    common.logger.debug({
+                        msg: "Failed to decode matched event log using provided ABI item",
+                        chain: eventCallback.chain.name,
+                        chain_id: eventCallback.chain.id,
+                        event: eventCallback.name,
+                        block_number: event?.block?.number ?? "unknown",
+                        log_index: event.log?.logIndex,
+                        data: event.log?.data,
+                        topics: JSON.stringify(event.log?.topics),
+                    });
+                }
+                continue;
+            }
+            events.push({
+                type: "log",
+                checkpoint: event.checkpoint,
+                chain,
+                eventCallback,
+                event: {
+                    id: event.checkpoint,
+                    args,
+                    log: event.log,
+                    block: event.block,
+                    transaction: event.transaction,
+                    transactionReceipt: event.transactionReceipt,
+                },
+            });
+        }
+        else if (eventCallback.type === "contract" &&
+            eventCallback.filter.type === "trace") {
+            let decodedData;
+            let decodedResult;
+            try {
+                decodedData = decodeFunctionData({
+                    abi: [eventCallback.abiItem],
+                    data: event.trace.input,
+                });
+                decodedResult = decodeFunctionResult({
+                    abi: [eventCallback.abiItem],
+                    data: event.trace.output ?? "0x",
+                    functionName: decodedData.functionName,
+                });
+                traceDecodeSuccessCount++;
+            }
+            catch (err) {
+                traceDecodeFailureCount++;
+                const selector = toFunctionSelector(eventCallback.abiItem);
+                if (!traceDecodeFailureSelectors.has(selector)) {
+                    traceDecodeFailureSelectors.add(selector);
+                    common.logger.debug({
+                        msg: "Failed to decode matched call trace using provided ABI item",
+                        chain: eventCallback.chain.name,
+                        chain_id: eventCallback.chain.id,
+                        function: eventCallback.name,
+                        block_number: event?.block?.number ?? "unknown",
+                        transaction_index: event.transaction?.transactionIndex,
+                        trace_index: event.trace?.traceIndex,
+                        input: event.trace?.input,
+                        output: event.trace?.output,
+                    });
+                }
+                continue;
+            }
+            events.push({
+                type: "trace",
+                checkpoint: event.checkpoint,
+                chain,
+                eventCallback,
+                event: {
+                    id: event.checkpoint,
+                    args: decodedData.args,
+                    result: decodedResult,
+                    trace: event.trace,
+                    block: event.block,
+                    transaction: event.transaction,
+                    transactionReceipt: event.transactionReceipt,
+                },
+            });
+        }
+        else if (eventCallback.type === "account" &&
+            eventCallback.filter.type === "transaction") {
+            events.push({
+                type: "transaction",
+                checkpoint: event.checkpoint,
+                chain,
+                eventCallback,
+                event: {
+                    id: event.checkpoint,
+                    block: event.block,
+                    transaction: event.transaction,
+                    transactionReceipt: event.transactionReceipt,
+                },
+            });
+        }
+        else if (eventCallback.type === "account" &&
+            eventCallback.filter.type === "transfer") {
+            events.push({
+                type: "transfer",
+                checkpoint: event.checkpoint,
+                chain,
+                eventCallback,
+                event: {
+                    id: event.checkpoint,
+                    transfer: {
+                        from: event.trace.from,
+                        to: event.trace.to,
+                        value: event.trace.value,
+                    },
+                    block: event.block,
+                    transaction: event.transaction,
+                    transactionReceipt: event.transactionReceipt,
+                    trace: event.trace,
+                },
+            });
+        }
+        else if (eventCallback.type === "block") {
+            events.push({
+                type: "block",
+                checkpoint: event.checkpoint,
+                chain,
+                eventCallback,
+                event: {
+                    id: event.checkpoint,
+                    block: event.block,
+                },
+            });
+        }
+    }
+    if (logDecodeFailureCount > 0) {
+        common.logger.debug({
+            msg: "Event batch contained logs that could not be decoded",
+            failure_count: logDecodeFailureCount,
+            success_count: logDecodeSuccessCount,
+        });
+    }
+    if (traceDecodeFailureCount > 0) {
+        common.logger.debug({
+            msg: "Event batch contained traces that could not be decoded",
+            failure_count: traceDecodeFailureCount,
+            success_count: traceDecodeSuccessCount,
+        });
+    }
+    return events;
+};
+export const syncBlockToInternal = ({ block, }) => ({
+    baseFeePerGas: block.baseFeePerGas ? hexToBigInt(block.baseFeePerGas) : null,
+    difficulty: hexToBigInt(block.difficulty),
+    extraData: block.extraData,
+    gasLimit: hexToBigInt(block.gasLimit),
+    gasUsed: hexToBigInt(block.gasUsed),
+    hash: block.hash,
+    logsBloom: block.logsBloom,
+    miner: toLowerCase(block.miner),
+    mixHash: block.mixHash,
+    nonce: block.nonce,
+    number: hexToBigInt(block.number),
+    parentHash: block.parentHash,
+    receiptsRoot: block.receiptsRoot,
+    sha3Uncles: block.sha3Uncles,
+    size: hexToBigInt(block.size),
+    stateRoot: block.stateRoot,
+    timestamp: hexToBigInt(block.timestamp),
+    totalDifficulty: block.totalDifficulty
+        ? hexToBigInt(block.totalDifficulty)
+        : null,
+    transactionsRoot: block.transactionsRoot,
+});
+export const syncLogToInternal = ({ log }) => ({
+    blockNumber: hexToNumber(log.blockNumber),
+    logIndex: hexToNumber(log.logIndex),
+    transactionIndex: hexToNumber(log.transactionIndex),
+    address: toLowerCase(log.address),
+    data: log.data,
+    removed: false,
+    topics: log.topics,
+});
+export const syncTransactionToInternal = ({ transaction, }) => ({
+    blockNumber: hexToNumber(transaction.blockNumber),
+    transactionIndex: hexToNumber(transaction.transactionIndex),
+    from: toLowerCase(transaction.from),
+    gas: hexToBigInt(transaction.gas),
+    hash: transaction.hash,
+    input: transaction.input,
+    nonce: hexToNumber(transaction.nonce),
+    r: transaction.r,
+    s: transaction.s,
+    to: transaction.to ? toLowerCase(transaction.to) : transaction.to,
+    value: hexToBigInt(transaction.value),
+    v: transaction.v ? hexToBigInt(transaction.v) : null,
+    ...(transaction.type === "0x0"
+        ? {
+            type: "legacy",
+            gasPrice: hexToBigInt(transaction.gasPrice),
+        }
+        : transaction.type === "0x1"
+            ? {
+                type: "eip2930",
+                gasPrice: hexToBigInt(transaction.gasPrice),
+                accessList: transaction.accessList,
+            }
+            : transaction.type === "0x2"
+                ? {
+                    type: "eip1559",
+                    maxFeePerGas: hexToBigInt(transaction.maxFeePerGas),
+                    maxPriorityFeePerGas: hexToBigInt(transaction.maxPriorityFeePerGas),
+                }
+                : // @ts-ignore
+                    transaction.type === "0x7e"
+                        ? {
+                            type: "deposit",
+                            // @ts-ignore
+                            maxFeePerGas: transaction.maxFeePerGas
+                                ? // @ts-ignore
+                                    hexToBigInt(transaction.maxFeePerGas)
+                                : undefined,
+                            // @ts-ignore
+                            maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+                                ? // @ts-ignore
+                                    hexToBigInt(transaction.maxPriorityFeePerGas)
+                                : undefined,
+                        }
+                        : {
+                            // @ts-ignore
+                            type: transaction.type,
+                        }),
+});
+export const syncTransactionReceiptToInternal = ({ transactionReceipt, }) => ({
+    blockNumber: hexToNumber(transactionReceipt.blockNumber),
+    transactionIndex: hexToNumber(transactionReceipt.transactionIndex),
+    contractAddress: transactionReceipt.contractAddress
+        ? toLowerCase(transactionReceipt.contractAddress)
+        : null,
+    cumulativeGasUsed: hexToBigInt(transactionReceipt.cumulativeGasUsed),
+    effectiveGasPrice: hexToBigInt(transactionReceipt.effectiveGasPrice),
+    from: toLowerCase(transactionReceipt.from),
+    gasUsed: hexToBigInt(transactionReceipt.gasUsed),
+    logsBloom: transactionReceipt.logsBloom,
+    status: transactionReceipt.status === "0x1"
+        ? "success"
+        : transactionReceipt.status === "0x0"
+            ? "reverted"
+            : transactionReceipt.status,
+    to: transactionReceipt.to ? toLowerCase(transactionReceipt.to) : null,
+    type: transactionReceipt.type === "0x0"
+        ? "legacy"
+        : transactionReceipt.type === "0x1"
+            ? "eip2930"
+            : transactionReceipt.type === "0x2"
+                ? "eip1559"
+                : transactionReceipt.type === "0x7e"
+                    ? "deposit"
+                    : transactionReceipt.type,
+});
+export const syncTraceToInternal = ({ trace, block, transaction, }) => ({
+    blockNumber: hexToNumber(block.number),
+    traceIndex: trace.trace.index,
+    transactionIndex: hexToNumber(transaction.transactionIndex),
+    type: trace.trace.type,
+    from: toLowerCase(trace.trace.from),
+    to: trace.trace.to ? toLowerCase(trace.trace.to) : null,
+    gas: hexToBigInt(trace.trace.gas),
+    gasUsed: hexToBigInt(trace.trace.gasUsed),
+    input: trace.trace.input,
+    output: trace.trace.output,
+    error: trace.trace.error,
+    revertReason: trace.trace.revertReason,
+    value: trace.trace.value ? hexToBigInt(trace.trace.value) : null,
+    subcalls: trace.trace.subcalls,
+});
+//# sourceMappingURL=events.js.map