@mikeatlast/ponder 0.16.1-fork.1

package/dist/esm/sync-store/index.js

@@ -0,0 +1,885 @@
+import crypto from "node:crypto";
+import { extractBlockNumberParam } from '../indexing/client.js';
+import { getFilterFactories, isAddressFactory, unionFilterIncludeBlock, unionFilterIncludeTrace, unionFilterIncludeTransaction, unionFilterIncludeTransactionReceipt, } from '../runtime/filter.js';
+import { encodeFragment, getFactoryFragments, getFragments, } from '../runtime/fragments.js';
+import { intervalUnion } from '../utils/interval.js';
+import { toLowerCase } from '../utils/lowercase.js';
+import { orderObject } from '../utils/order.js';
+import { startClock } from '../utils/timer.js';
+import { and, asc, desc, eq, gte, inArray, isNull, lt, lte, or, sql, } from "drizzle-orm";
+import { unionAll, } from "drizzle-orm/pg-core";
+import { hexToNumber, isHex } from "viem";
+import { encodeBlock, encodeLog, encodeTrace, encodeTransaction, encodeTransactionReceipt, } from "./encode.js";
+import * as PONDER_SYNC from "./schema.js";
+export const createSyncStore = ({ common, qb, }) => {
+    const syncStore = {
+        insertIntervals: async ({ intervals, factoryIntervals, chainId }, context) => {
+            if (intervals.length === 0 && factoryIntervals.length === 0)
+                return;
+            const perFragmentIntervals = new Map();
+            const values = [];
+            // dedupe and merge matching fragments
+            for (const { filter, interval } of intervals) {
+                for (const fragment of getFragments(filter)) {
+                    const fragmentId = encodeFragment(fragment.fragment);
+                    if (perFragmentIntervals.has(fragmentId) === false) {
+                        perFragmentIntervals.set(fragmentId, []);
+                    }
+                    perFragmentIntervals.get(fragmentId).push(interval);
+                }
+            }
+            for (const { factory, interval } of factoryIntervals) {
+                for (const fragment of getFactoryFragments(factory)) {
+                    const fragmentId = encodeFragment(fragment);
+                    if (perFragmentIntervals.has(fragmentId) === false) {
+                        perFragmentIntervals.set(fragmentId, []);
+                    }
+                    perFragmentIntervals.get(fragmentId).push(interval);
+                }
+            }
+            // NOTE: In order to force proper range union behavior, `interval[1]` must
+            // be rounded up.
+            for (const [fragmentId, intervals] of perFragmentIntervals) {
+                const numranges = intervals
+                    .map((interval) => {
+                    const start = interval[0];
+                    const end = interval[1] + 1;
+                    return `numrange(${start}, ${end}, '[]')`;
+                })
+                    .join(", ");
+                values.push({
+                    fragmentId: fragmentId,
+                    chainId: BigInt(chainId),
+                    // @ts-expect-error
+                    blocks: sql.raw(`nummultirange(${numranges})`),
+                });
+            }
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters / 3);
+            for (let i = 0; i < values.length; i += batchSize) {
+                await qb.wrap({ label: "insert_intervals" }, (db) => db
+                    .insert(PONDER_SYNC.intervals)
+                    .values(values.slice(i, i + batchSize))
+                    .onConflictDoUpdate({
+                    target: PONDER_SYNC.intervals.fragmentId,
+                    set: { blocks: sql `intervals.blocks + excluded.blocks` },
+                }), context);
+            }
+        },
+        getIntervals: async ({ filters }, context) => {
+            const queries = [];
+            let index = 0;
+            for (const filter of filters) {
+                const fragments = getFragments(filter);
+                for (const fragment of fragments) {
+                    queries.push(qb.raw
+                        .select({
+                        mergedBlocks: sql `range_agg(unnested.blocks)`.as("merged_blocks"),
+                        fragment: sql.raw(`'${index++}'`).as("fragment"),
+                    })
+                        .from(qb.raw
+                        .select({ blocks: sql.raw("unnest(blocks)").as("blocks") })
+                        .from(PONDER_SYNC.intervals)
+                        .where(sql.raw(`fragment_id IN (${fragment.adjacentIds.map((id) => `'${id}'`).join(", ")})`))
+                        .as("unnested")));
+                }
+                for (const factory of getFilterFactories(filter)) {
+                    for (const fragment of getFactoryFragments(factory)) {
+                        queries.push(qb.raw
+                            .select({
+                            mergedBlocks: sql `range_agg(unnested.blocks)`.as("merged_blocks"),
+                            fragment: sql.raw(`'${index++}'`).as("fragment"),
+                        })
+                            .from(qb.raw
+                            .select({
+                            blocks: sql.raw("unnest(blocks)").as("blocks"),
+                        })
+                            .from(PONDER_SYNC.intervals)
+                            .where(sql.raw(`fragment_id = '${encodeFragment(fragment)}'`))
+                            .as("unnested")));
+                    }
+                }
+            }
+            let rows = [];
+            if (queries.length > 1) {
+                // Note: This query has no parameters, but there is a bug with
+                // drizzle causing a "maximum call stack size exceeded" error.
+                // Related: https://github.com/drizzle-team/drizzle-orm/issues/1740
+                const batchSize = 200;
+                for (let i = 0; i < queries.length; i += batchSize) {
+                    const _rows = await qb.wrap({ label: "select_intervals" }, () => 
+                    // @ts-expect-error
+                    unionAll(...queries.slice(i, i + batchSize)), context);
+                    if (i === 0) {
+                        rows = _rows;
+                    }
+                    else {
+                        rows.push(..._rows);
+                    }
+                }
+            }
+            else {
+                rows = await qb.wrap({ label: "select_intervals" }, () => queries[0].execute(), context);
+            }
+            const result = new Map();
+            // NOTE: `interval[1]` must be rounded down in order to offset the previous
+            // rounding.
+            index = 0;
+            for (const filter of filters) {
+                const fragments = getFragments(filter);
+                result.set(filter, []);
+                for (const fragment of fragments) {
+                    const intervals = rows
+                        .filter((row) => row.fragment === `${index}`)
+                        .map((row) => (row.mergedBlocks
+                        ? JSON.parse(`[${row.mergedBlocks.slice(1, -1)}]`)
+                        : []).map((interval) => [interval[0], interval[1] - 1]))[0];
+                    index += 1;
+                    result.get(filter).push({ fragment: fragment.fragment, intervals });
+                }
+                for (const factory of getFilterFactories(filter)) {
+                    result.set(factory, []);
+                    for (const fragment of getFactoryFragments(factory)) {
+                        const intervals = rows
+                            .filter((row) => row.fragment === `${index}`)
+                            .map((row) => (row.mergedBlocks
+                            ? JSON.parse(`[${row.mergedBlocks.slice(1, -1)}]`)
+                            : []).map((interval) => [interval[0], interval[1] - 1]))[0];
+                        index += 1;
+                        result.get(factory).push({ fragment, intervals });
+                    }
+                    // Note: This is a stand-in for a migration to the `intervals` table
+                    // required in `v0.15`. It is an invariant that filter with factories
+                    // have a row in the intervals table for both the filter and the factory.
+                    // If this invariant is broken, it must be because of the migration from
+                    // `v0.14` to `v0.15`. In this case, we can assume that the factory interval
+                    // is the same as the filter interval.
+                    const filterIntervals = intervalUnion(result.get(filter).flatMap(({ intervals }) => intervals));
+                    const factoryIntervals = intervalUnion(result.get(factory).flatMap(({ intervals }) => intervals));
+                    if (filterIntervals.length > 0 &&
+                        factoryIntervals.length === 0 &&
+                        filter.fromBlock === factory.fromBlock &&
+                        filter.toBlock === factory.toBlock) {
+                        for (const factoryInterval of result.get(factory)) {
+                            factoryInterval.intervals = filterIntervals;
+                        }
+                    }
+                }
+            }
+            return result;
+        },
+        insertChildAddresses: async ({ factory, childAddresses, chainId }, context) => {
+            if (childAddresses.size === 0)
+                return;
+            const { id, sourceId: _sourceId, ..._factory } = factory;
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters / 3);
+            const values = [];
+            const factoryInsert = qb.raw.$with("factory_insert").as(qb.raw
+                .insert(PONDER_SYNC.factories)
+                .values({ factory: _factory })
+                // @ts-expect-error bug with drizzle-orm
+                .returning({ id: PONDER_SYNC.factories.id })
+                .onConflictDoUpdate({
+                target: PONDER_SYNC.factories.factory,
+                set: { factory: sql `excluded.factory` },
+            }));
+            for (const [address, blockNumber] of childAddresses) {
+                values.push({
+                    // @ts-expect-error
+                    factoryId: sql `(SELECT id FROM factory_insert)`,
+                    chainId: BigInt(chainId),
+                    blockNumber: BigInt(blockNumber),
+                    address,
+                });
+            }
+            for (let i = 0; i < values.length; i += batchSize) {
+                await qb.wrap({ label: "insert_child_addresses" }, (db) => db
+                    .with(factoryInsert)
+                    .insert(PONDER_SYNC.factoryAddresses)
+                    .values(values.slice(i, i + batchSize)), context);
+            }
+        },
+        getChildAddresses: ({ factory }, context) => {
+            const { id, sourceId: _sourceId, ..._factory } = factory;
+            const factoryInsert = qb.raw.$with("factory_insert").as(qb.raw
+                .insert(PONDER_SYNC.factories)
+                .values({ factory: _factory })
+                // @ts-expect-error bug with drizzle-orm
+                .returning({ id: PONDER_SYNC.factories.id })
+                .onConflictDoUpdate({
+                target: PONDER_SYNC.factories.factory,
+                set: { factory: sql `excluded.factory` },
+            }));
+            return qb
+                .wrap({ label: "select_child_addresses" }, (db) => db
+                .with(factoryInsert)
+                .select({
+                address: PONDER_SYNC.factoryAddresses.address,
+                blockNumber: PONDER_SYNC.factoryAddresses.blockNumber,
+            })
+                .from(PONDER_SYNC.factoryAddresses)
+                .where(eq(PONDER_SYNC.factoryAddresses.factoryId, qb.raw.select({ id: factoryInsert.id }).from(factoryInsert))), context)
+                .then((rows) => {
+                const result = new Map();
+                for (const { address, blockNumber } of rows) {
+                    if (result.has(address) === false ||
+                        result.get(address) > Number(blockNumber)) {
+                        result.set(address, Number(blockNumber));
+                    }
+                }
+                return result;
+            });
+        },
+        getSafeCrashRecoveryBlock: async ({ chainId, timestamp }, context) => {
+            const rows = await qb.wrap({ label: "select_crash_recovery_block" }, (db) => db
+                .select({
+                number: PONDER_SYNC.blocks.number,
+                timestamp: PONDER_SYNC.blocks.timestamp,
+            })
+                .from(PONDER_SYNC.blocks)
+                .where(and(eq(PONDER_SYNC.blocks.chainId, BigInt(chainId)), lt(PONDER_SYNC.blocks.timestamp, BigInt(timestamp))))
+                .orderBy(desc(PONDER_SYNC.blocks.number))
+                .limit(1), context);
+            return rows[0];
+        },
+        insertLogs: async ({ logs, chainId }, context) => {
+            if (logs.length === 0)
+                return;
+            // Calculate `batchSize` based on how many parameters the
+            // input will have
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters /
+                Object.keys(encodeLog({ log: logs[0], chainId })).length);
+            // As an optimization, logs that are matched by a factory do
+            // not contain a checkpoint, because not corresponding block is
+            // fetched (no block.timestamp). However, when a log is matched by
+            // both a log filter and a factory, the checkpoint must be included
+            // in the db.
+            for (let i = 0; i < logs.length; i += batchSize) {
+                await qb.wrap({ label: "insert_logs" }, (db) => db
+                    .insert(PONDER_SYNC.logs)
+                    .values(logs
+                    .slice(i, i + batchSize)
+                    .map((log) => encodeLog({ log, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        PONDER_SYNC.logs.chainId,
+                        PONDER_SYNC.logs.blockNumber,
+                        PONDER_SYNC.logs.logIndex,
+                    ],
+                }), context);
+            }
+        },
+        insertBlocks: async ({ blocks, chainId }, context) => {
+            if (blocks.length === 0)
+                return;
+            // Calculate `batchSize` based on how many parameters the
+            // input will have
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters /
+                Object.keys(encodeBlock({ block: blocks[0], chainId })).length);
+            for (let i = 0; i < blocks.length; i += batchSize) {
+                await qb.wrap({ label: "insert_blocks" }, (db) => db
+                    .insert(PONDER_SYNC.blocks)
+                    .values(blocks
+                    .slice(i, i + batchSize)
+                    .map((block) => encodeBlock({ block, chainId })))
+                    .onConflictDoNothing({
+                    target: [PONDER_SYNC.blocks.chainId, PONDER_SYNC.blocks.number],
+                }), context);
+            }
+        },
+        insertTransactions: async ({ transactions, chainId }, context) => {
+            if (transactions.length === 0)
+                return;
+            // Calculate `batchSize` based on how many parameters the
+            // input will have
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters /
+                Object.keys(encodeTransaction({
+                    transaction: transactions[0],
+                    chainId,
+                })).length);
+            for (let i = 0; i < transactions.length; i += batchSize) {
+                await qb.wrap({ label: "insert_transactions" }, (db) => db
+                    .insert(PONDER_SYNC.transactions)
+                    .values(transactions
+                    .slice(i, i + batchSize)
+                    .map((transaction) => encodeTransaction({ transaction, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        PONDER_SYNC.transactions.chainId,
+                        PONDER_SYNC.transactions.blockNumber,
+                        PONDER_SYNC.transactions.transactionIndex,
+                    ],
+                }), context);
+            }
+        },
+        insertTransactionReceipts: async ({ transactionReceipts, chainId }, context) => {
+            if (transactionReceipts.length === 0)
+                return;
+            // Calculate `batchSize` based on how many parameters the
+            // input will have
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters /
+                Object.keys(encodeTransactionReceipt({
+                    transactionReceipt: transactionReceipts[0],
+                    chainId,
+                })).length);
+            for (let i = 0; i < transactionReceipts.length; i += batchSize) {
+                await qb.wrap({ label: "insert_transaction_receipts" }, (db) => db
+                    .insert(PONDER_SYNC.transactionReceipts)
+                    .values(transactionReceipts
+                    .slice(i, i + batchSize)
+                    .map((transactionReceipt) => encodeTransactionReceipt({
+                    transactionReceipt,
+                    chainId,
+                })))
+                    .onConflictDoNothing({
+                    target: [
+                        PONDER_SYNC.transactionReceipts.chainId,
+                        PONDER_SYNC.transactionReceipts.blockNumber,
+                        PONDER_SYNC.transactionReceipts.transactionIndex,
+                    ],
+                }), context);
+            }
+        },
+        insertTraces: async ({ traces, chainId }, context) => {
+            if (traces.length === 0)
+                return;
+            // Calculate `batchSize` based on how many parameters the
+            // input will have
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters /
+                Object.keys(encodeTrace({
+                    trace: traces[0].trace,
+                    block: traces[0].block,
+                    transaction: traces[0].transaction,
+                    chainId,
+                })).length);
+            for (let i = 0; i < traces.length; i += batchSize) {
+                await qb.wrap({ label: "insert_traces" }, (db) => db
+                    .insert(PONDER_SYNC.traces)
+                    .values(traces
+                    .slice(i, i + batchSize)
+                    .map(({ trace, block, transaction }) => encodeTrace({ trace, block, transaction, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        PONDER_SYNC.traces.chainId,
+                        PONDER_SYNC.traces.blockNumber,
+                        PONDER_SYNC.traces.transactionIndex,
+                        PONDER_SYNC.traces.traceIndex,
+                    ],
+                }), context);
+            }
+        },
+        getEventData: async ({ filters, fromBlock, toBlock, chainId, limit }, context) => {
+            const logFilters = filters.filter((f) => f.type === "log");
+            const transactionFilters = filters.filter((f) => f.type === "transaction");
+            const traceFilters = filters.filter((f) => f.type === "trace");
+            const transferFilters = filters.filter((f) => f.type === "transfer");
+            const shouldQueryBlocks = true;
+            const shouldQueryLogs = logFilters.length > 0;
+            const shouldQueryTraces = traceFilters.length > 0 || transferFilters.length > 0;
+            const shouldQueryTransactions = transactionFilters.length > 0 || shouldQueryLogs || shouldQueryTraces;
+            const shouldQueryTransactionReceipts = filters.some((filter) => filter.hasTransactionReceipt);
+            // Note: `LogSelect` doesn't exist because all log columns are required.
+            const blockSelect = {
+                number: PONDER_SYNC.blocks.number,
+                hash: PONDER_SYNC.blocks.hash,
+                timestamp: PONDER_SYNC.blocks.timestamp,
+            };
+            for (const column of unionFilterIncludeBlock(filters)) {
+                // @ts-ignore
+                blockSelect[column] = PONDER_SYNC.blocks[column];
+            }
+            const blocksQuery = qb.raw
+                .select(blockSelect)
+                .from(PONDER_SYNC.blocks)
+                .where(and(eq(PONDER_SYNC.blocks.chainId, BigInt(chainId)), gte(PONDER_SYNC.blocks.number, BigInt(fromBlock)), lte(PONDER_SYNC.blocks.number, BigInt(toBlock))))
+                .orderBy(asc(PONDER_SYNC.blocks.number))
+                .limit(limit);
+            const transactionSelect = {
+                blockNumber: PONDER_SYNC.transactions.blockNumber,
+                transactionIndex: PONDER_SYNC.transactions.transactionIndex,
+                from: PONDER_SYNC.transactions.from,
+                to: PONDER_SYNC.transactions.to,
+                hash: PONDER_SYNC.transactions.hash,
+                type: PONDER_SYNC.transactions.type,
+            };
+            for (const column of unionFilterIncludeTransaction(filters)) {
+                // @ts-ignore
+                transactionSelect[column] = PONDER_SYNC.transactions[column];
+            }
+            const transactionsQuery = qb.raw
+                .select(transactionSelect)
+                .from(PONDER_SYNC.transactions)
+                .where(and(eq(PONDER_SYNC.transactions.chainId, BigInt(chainId)), gte(PONDER_SYNC.transactions.blockNumber, BigInt(fromBlock)), lte(PONDER_SYNC.transactions.blockNumber, BigInt(toBlock))))
+                .orderBy(asc(PONDER_SYNC.transactions.blockNumber), asc(PONDER_SYNC.transactions.transactionIndex))
+                .limit(limit);
+            const transactionReceiptSelect = {
+                blockNumber: PONDER_SYNC.transactionReceipts.blockNumber,
+                transactionIndex: PONDER_SYNC.transactionReceipts.transactionIndex,
+                status: PONDER_SYNC.transactionReceipts.status,
+                from: PONDER_SYNC.transactionReceipts.from,
+                to: PONDER_SYNC.transactionReceipts.to,
+            };
+            for (const column of unionFilterIncludeTransactionReceipt(filters)) {
+                // @ts-ignore
+                transactionReceiptSelect[column] =
+                    PONDER_SYNC.transactionReceipts[column];
+            }
+            const transactionReceiptsQuery = qb.raw
+                .select(transactionReceiptSelect)
+                .from(PONDER_SYNC.transactionReceipts)
+                .where(and(eq(PONDER_SYNC.transactionReceipts.chainId, BigInt(chainId)), gte(PONDER_SYNC.transactionReceipts.blockNumber, BigInt(fromBlock)), lte(PONDER_SYNC.transactionReceipts.blockNumber, BigInt(toBlock))))
+                .orderBy(asc(PONDER_SYNC.transactionReceipts.blockNumber), asc(PONDER_SYNC.transactionReceipts.transactionIndex))
+                .limit(limit);
+            const traceSelect = {
+                blockNumber: PONDER_SYNC.traces.blockNumber,
+                transactionIndex: PONDER_SYNC.traces.transactionIndex,
+                from: PONDER_SYNC.traces.from,
+                to: PONDER_SYNC.traces.to,
+                input: PONDER_SYNC.traces.input,
+                output: PONDER_SYNC.traces.output,
+                value: PONDER_SYNC.traces.value,
+                type: PONDER_SYNC.traces.type,
+                error: PONDER_SYNC.traces.error,
+                traceIndex: PONDER_SYNC.traces.traceIndex,
+            };
+            for (const column of unionFilterIncludeTrace(filters)) {
+                // @ts-ignore
+                traceSelect[column] = PONDER_SYNC.traces[column];
+            }
+            const tracesQuery = qb.raw
+                .select(traceSelect)
+                .from(PONDER_SYNC.traces)
+                .where(and(eq(PONDER_SYNC.traces.chainId, BigInt(chainId)), gte(PONDER_SYNC.traces.blockNumber, BigInt(fromBlock)), lte(PONDER_SYNC.traces.blockNumber, BigInt(toBlock)), or(...traceFilters.map((filter) => traceFilter(filter)), ...transferFilters.map((filter) => transferFilter(filter)))))
+                .orderBy(asc(PONDER_SYNC.traces.blockNumber), asc(PONDER_SYNC.traces.transactionIndex), asc(PONDER_SYNC.traces.traceIndex))
+                .limit(limit);
+            const logsQuery = qb.raw
+                .select({
+                blockNumber: PONDER_SYNC.logs.blockNumber,
+                logIndex: PONDER_SYNC.logs.logIndex,
+                transactionIndex: PONDER_SYNC.logs.transactionIndex,
+                address: PONDER_SYNC.logs.address,
+                topic0: PONDER_SYNC.logs.topic0,
+                topic1: PONDER_SYNC.logs.topic1,
+                topic2: PONDER_SYNC.logs.topic2,
+                topic3: PONDER_SYNC.logs.topic3,
+                data: PONDER_SYNC.logs.data,
+            })
+                .from(PONDER_SYNC.logs)
+                .where(and(eq(PONDER_SYNC.logs.chainId, BigInt(chainId)), gte(PONDER_SYNC.logs.blockNumber, BigInt(fromBlock)), lte(PONDER_SYNC.logs.blockNumber, BigInt(toBlock)), or(...logFilters.map((filter) => logFilter(filter)))))
+                .orderBy(asc(PONDER_SYNC.logs.blockNumber), asc(PONDER_SYNC.logs.logIndex))
+                .limit(limit);
+            let endClock = startClock();
+            const [blocksRows, transactionsRows, transactionReceiptsRows, logsRows, tracesRows,] = await Promise.all([
+                shouldQueryBlocks
+                    ? qb.wrap({ label: "select_blocks" }, () => blocksQuery)
+                    : [],
+                shouldQueryTransactions
+                    ? qb.wrap({ label: "select_transactions" }, () => transactionsQuery, context)
+                    : [],
+                shouldQueryTransactionReceipts
+                    ? qb.wrap({ label: "select_transaction_receipts" }, () => transactionReceiptsQuery, context)
+                    : [],
+                shouldQueryLogs
+                    ? qb.wrap({ label: "select_logs" }, () => logsQuery, context)
+                    : [],
+                shouldQueryTraces
+                    ? qb.wrap({ label: "select_traces" }, () => tracesQuery, context)
+                    : [],
+            ]);
+            const supremum = Math.min(blocksRows.length < limit
+                ? Number.POSITIVE_INFINITY
+                : Number(blocksRows[blocksRows.length - 1].number), transactionsRows.length < limit
+                ? Number.POSITIVE_INFINITY
+                : Number(transactionsRows[transactionsRows.length - 1].blockNumber), transactionReceiptsRows.length < limit
+                ? Number.POSITIVE_INFINITY
+                : Number(transactionReceiptsRows[transactionReceiptsRows.length - 1]
+                    .blockNumber), logsRows.length < limit
+                ? Number.POSITIVE_INFINITY
+                : Number(logsRows[logsRows.length - 1].blockNumber), tracesRows.length < limit
+                ? Number.POSITIVE_INFINITY
+                : Number(tracesRows[tracesRows.length - 1].blockNumber));
+            endClock = startClock();
+            let cursor;
+            if (Math.max(blocksRows.length, transactionsRows.length, transactionReceiptsRows.length, logsRows.length, tracesRows.length) !== limit) {
+                cursor = toBlock;
+            }
+            else if (blocksRows.length === limit &&
+                Math.max(transactionsRows.length, transactionReceiptsRows.length, logsRows.length, tracesRows.length) !== limit) {
+                // all events for `supremum` block have been extracted
+                cursor = supremum;
+            }
+            else {
+                // there may be events for `supremum` block that have not been extracted
+                cursor = supremum - 1;
+                if (cursor < fromBlock) {
+                    return syncStore.getEventData({
+                        filters,
+                        fromBlock,
+                        toBlock,
+                        chainId,
+                        limit: limit * 2,
+                    }, context);
+                }
+            }
+            endClock = startClock();
+            for (let i = 0; i < blocksRows.length; i++) {
+                if (Number(blocksRows[i].number) > cursor) {
+                    blocksRows.length = i;
+                    break;
+                }
+                const block = blocksRows[i];
+                if (block.miner) {
+                    block.miner = toLowerCase(block.miner);
+                }
+            }
+            for (let i = 0; i < transactionsRows.length; i++) {
+                if (Number(transactionsRows[i].blockNumber) > cursor) {
+                    transactionsRows.length = i;
+                    break;
+                }
+                const transaction = transactionsRows[i];
+                const internalTransaction = transaction;
+                internalTransaction.blockNumber = Number(transaction.blockNumber);
+                internalTransaction.from = toLowerCase(transaction.from);
+                if (transaction.to !== null) {
+                    internalTransaction.to = toLowerCase(transaction.to);
+                }
+                if (transaction.type === "0x0") {
+                    internalTransaction.type = "legacy";
+                    internalTransaction.accessList = undefined;
+                    internalTransaction.maxFeePerGas = undefined;
+                    internalTransaction.maxPriorityFeePerGas = undefined;
+                }
+                else if (transaction.type === "0x1") {
+                    internalTransaction.type = "eip2930";
+                    internalTransaction.accessList =
+                        transaction.accessList === undefined
+                            ? undefined
+                            : JSON.parse(transaction.accessList);
+                    internalTransaction.maxFeePerGas = undefined;
+                    internalTransaction.maxPriorityFeePerGas = undefined;
+                }
+                else if (transaction.type === "0x2") {
+                    internalTransaction.type = "eip1559";
+                    internalTransaction.gasPrice = undefined;
+                    internalTransaction.accessList = undefined;
+                }
+                else if (transaction.type === "0x7e") {
+                    internalTransaction.type = "deposit";
+                    internalTransaction.gasPrice = undefined;
+                    internalTransaction.accessList = undefined;
+                }
+            }
+            for (let i = 0; i < transactionReceiptsRows.length; i++) {
+                if (Number(transactionReceiptsRows[i].blockNumber) > cursor) {
+                    transactionReceiptsRows.length = i;
+                    break;
+                }
+                const transactionReceipt = transactionReceiptsRows[i];
+                const internalTransactionReceipt = transactionReceipt;
+                internalTransactionReceipt.blockNumber = Number(transactionReceipt.blockNumber);
+                if (transactionReceipt.contractAddress) {
+                    internalTransactionReceipt.contractAddress = toLowerCase(transactionReceipt.contractAddress);
+                }
+                internalTransactionReceipt.from = toLowerCase(transactionReceipt.from);
+                if (transactionReceipt.to !== null) {
+                    internalTransactionReceipt.to = toLowerCase(transactionReceipt.to);
+                }
+                internalTransactionReceipt.status =
+                    transactionReceipt.status === "0x1"
+                        ? "success"
+                        : transactionReceipt.status === "0x0"
+                            ? "reverted"
+                            : transactionReceipt.status;
+                internalTransactionReceipt.type =
+                    transactionReceipt.type === "0x0"
+                        ? "legacy"
+                        : transactionReceipt.type === "0x1"
+                            ? "eip2930"
+                            : transactionReceipt.type === "0x2"
+                                ? "eip1559"
+                                : transactionReceipt.type === "0x7e"
+                                    ? "deposit"
+                                    : transactionReceipt.type;
+            }
+            for (let i = 0; i < tracesRows.length; i++) {
+                if (Number(tracesRows[i].blockNumber) > cursor) {
+                    tracesRows.length = i;
+                    break;
+                }
+                const trace = tracesRows[i];
+                const internalTrace = trace;
+                internalTrace.blockNumber = Number(trace.blockNumber);
+                internalTrace.from = toLowerCase(trace.from);
+                if (trace.to !== null) {
+                    internalTrace.to = toLowerCase(trace.to);
+                }
+                if (trace.output === null) {
+                    internalTrace.output = undefined;
+                }
+                if (trace.error === null) {
+                    internalTrace.error = undefined;
+                }
+                if (trace.revertReason === null) {
+                    internalTrace.revertReason = undefined;
+                }
+            }
+            for (let i = 0; i < logsRows.length; i++) {
+                if (Number(logsRows[i].blockNumber) > cursor) {
+                    logsRows.length = i;
+                    break;
+                }
+                const log = logsRows[i];
+                const internalLog = log;
+                internalLog.blockNumber = Number(log.blockNumber);
+                internalLog.address = toLowerCase(log.address);
+                internalLog.removed = false;
+                internalLog.topics = [
+                    // @ts-ignore
+                    log.topic0,
+                    log.topic1,
+                    log.topic2,
+                    log.topic3,
+                ];
+                // @ts-ignore
+                log.topic0 = undefined;
+                // @ts-ignore
+                log.topic1 = undefined;
+                // @ts-ignore
+                log.topic2 = undefined;
+                // @ts-ignore
+                log.topic3 = undefined;
+            }
+            common.metrics.ponder_historical_extract_duration.inc({ step: "format" }, endClock());
+            await new Promise(setImmediate);
+            return {
+                blocks: blocksRows,
+                logs: logsRows,
+                transactions: transactionsRows,
+                transactionReceipts: transactionReceiptsRows,
+                traces: tracesRows,
+                cursor,
+            };
+        },
+        insertRpcRequestResults: async ({ requests, chainId }, context) => {
+            if (requests.length === 0)
+                return;
+            const values = requests.map(({ request, blockNumber, result }) => ({
+                requestHash: crypto
+                    .createHash("md5")
+                    .update(toLowerCase(JSON.stringify(orderObject(request))))
+                    .digest("hex"),
+                chainId: BigInt(chainId),
+                blockNumber: blockNumber ? BigInt(blockNumber) : undefined,
+                result,
+            }));
+            await qb.wrap({ label: "insert_rpc_requests" }, (db) => db
+                .insert(PONDER_SYNC.rpcRequestResults)
+                .values(values)
+                .onConflictDoNothing({
+                target: [
+                    PONDER_SYNC.rpcRequestResults.requestHash,
+                    PONDER_SYNC.rpcRequestResults.chainId,
+                ],
+            }), context);
+        },
+        getRpcRequestResults: async ({ requests, chainId }, context) => {
+            if (requests.length === 0)
+                return [];
+            // Optimized fast path for high number of `requests` using a range of block numbers
+            // rather than querying each request individually.
+            const blockNumbersByRequest = new Array(requests.length);
+            const requestHashes = new Array(requests.length);
+            for (let i = 0; i < requests.length; i++) {
+                const request = requests[i];
+                const blockNumber = extractBlockNumberParam(request);
+                // Note: "latest" is not considered a block number
+                if (isHex(blockNumber)) {
+                    blockNumbersByRequest[i] = hexToNumber(blockNumber);
+                }
+                else {
+                    blockNumbersByRequest[i] = undefined;
+                }
+                const requestHash = crypto
+                    .createHash("md5")
+                    .update(toLowerCase(JSON.stringify(orderObject(request))))
+                    .digest("hex");
+                requestHashes[i] = requestHash;
+            }
+            const blockNumbers = blockNumbersByRequest.filter((blockNumber) => blockNumber !== undefined);
+            if (blockNumbers.length > 100) {
+                const minBlockNumber = Math.min(...blockNumbers);
+                const maxBlockNumber = Math.max(...blockNumbers);
+                const nonBlockRequestHashes = requestHashes.filter((_, i) => blockNumbersByRequest[i] === undefined);
+                const result = await Promise.all([
+                    qb.wrap({ label: "select_rpc_requests" }, (db) => db
+                        .select({
+                        request_hash: PONDER_SYNC.rpcRequestResults.requestHash,
+                        result: PONDER_SYNC.rpcRequestResults.result,
+                    })
+                        .from(PONDER_SYNC.rpcRequestResults)
+                        .where(and(eq(PONDER_SYNC.rpcRequestResults.chainId, BigInt(chainId)), gte(PONDER_SYNC.rpcRequestResults.blockNumber, BigInt(minBlockNumber)), lte(PONDER_SYNC.rpcRequestResults.blockNumber, BigInt(maxBlockNumber)))), context),
+                    nonBlockRequestHashes.length === 0
+                        ? []
+                        : qb.wrap({ label: "select_rpc_requests" }, (db) => db
+                            .select({
+                            request_hash: PONDER_SYNC.rpcRequestResults.requestHash,
+                            result: PONDER_SYNC.rpcRequestResults.result,
+                        })
+                            .from(PONDER_SYNC.rpcRequestResults)
+                            .where(and(eq(PONDER_SYNC.rpcRequestResults.chainId, BigInt(chainId)), inArray(PONDER_SYNC.rpcRequestResults.requestHash, nonBlockRequestHashes))), context),
+                ]);
+                const results = new Map();
+                for (const row of result[0]) {
+                    results.set(row.request_hash, row.result);
+                }
+                for (const row of result[1]) {
+                    results.set(row.request_hash, row.result);
+                }
+                return requestHashes.map((requestHash) => results.get(requestHash));
+            }
+            const result = await qb.wrap({ label: "select_rpc_requests" }, (db) => db
+                .select({
+                request_hash: PONDER_SYNC.rpcRequestResults.requestHash,
+                result: PONDER_SYNC.rpcRequestResults.result,
+            })
+                .from(PONDER_SYNC.rpcRequestResults)
+                .where(and(eq(PONDER_SYNC.rpcRequestResults.chainId, BigInt(chainId)), inArray(PONDER_SYNC.rpcRequestResults.requestHash, requestHashes))), context);
+            const results = new Map();
+            for (const row of result) {
+                results.set(row.request_hash, row.result);
+            }
+            return requestHashes.map((requestHash) => results.get(requestHash));
+        },
+        pruneRpcRequestResults: async ({ blocks, chainId }, context) => {
+            if (blocks.length === 0)
+                return;
+            const numbers = blocks.map(({ number }) => BigInt(hexToNumber(number)));
+            await qb.wrap({ label: "delete_rpc_requests" }, (db) => db
+                .delete(PONDER_SYNC.rpcRequestResults)
+                .where(and(eq(PONDER_SYNC.rpcRequestResults.chainId, BigInt(chainId)), inArray(PONDER_SYNC.rpcRequestResults.blockNumber, numbers))), context);
+        },
+        pruneByChain: async ({ chainId }, context) => qb.transaction(async (tx) => {
+            await tx.wrap({ label: "delete_logs" }, (db) => db
+                .delete(PONDER_SYNC.logs)
+                .where(eq(PONDER_SYNC.logs.chainId, BigInt(chainId)))
+                .execute(), context);
+            await tx.wrap({ label: "delete_blocks" }, (db) => db
+                .delete(PONDER_SYNC.blocks)
+                .where(eq(PONDER_SYNC.blocks.chainId, BigInt(chainId)))
+                .execute(), context);
+            await tx.wrap({ label: "delete_traces" }, (db) => db
+                .delete(PONDER_SYNC.traces)
+                .where(eq(PONDER_SYNC.traces.chainId, BigInt(chainId)))
+                .execute(), context);
+            await tx.wrap({ label: "delete_transactions" }, (db) => db
+                .delete(PONDER_SYNC.transactions)
+                .where(eq(PONDER_SYNC.transactions.chainId, BigInt(chainId)))
+                .execute(), context);
+            await tx.wrap({ label: "delete_transaction_receipts" }, (db) => db
+                .delete(PONDER_SYNC.transactionReceipts)
+                .where(eq(PONDER_SYNC.transactionReceipts.chainId, BigInt(chainId)))
+                .execute(), context);
+            await tx.wrap({ label: "delete_factory_addresses" }, (db) => db
+                .delete(PONDER_SYNC.factoryAddresses)
+                .where(eq(PONDER_SYNC.factoryAddresses.chainId, BigInt(chainId)))
+                .execute(), context);
+        }),
+    };
+    return syncStore;
+};
+const addressFilter = (address, column) => {
+    // `factory` filtering is handled in-memory
+    if (isAddressFactory(address))
+        return sql `true`;
+    // @ts-ignore
+    if (Array.isArray(address))
+        return inArray(column, address);
+    // @ts-ignore
+    if (typeof address === "string")
+        return eq(column, address);
+    return sql `true`;
+};
+export const logFilter = (filter) => {
+    const conditions = [];
+    for (const idx of [0, 1, 2, 3]) {
+        // If it's an array of length 1, collapse it.
+        const raw = filter[`topic${idx}`] ?? null;
+        if (raw === null)
+            continue;
+        const topic = Array.isArray(raw) && raw.length === 1 ? raw[0] : raw;
+        if (Array.isArray(topic)) {
+            conditions.push(inArray(PONDER_SYNC.logs[`topic${idx}`], topic));
+        }
+        else {
+            conditions.push(eq(PONDER_SYNC.logs[`topic${idx}`], topic));
+        }
+    }
+    conditions.push(addressFilter(filter.address, PONDER_SYNC.logs.address));
+    if (filter.fromBlock !== undefined) {
+        conditions.push(gte(PONDER_SYNC.logs.blockNumber, BigInt(filter.fromBlock)));
+    }
+    if (filter.toBlock !== undefined) {
+        conditions.push(lte(PONDER_SYNC.logs.blockNumber, BigInt(filter.toBlock)));
+    }
+    return and(...conditions);
+};
+export const blockFilter = (filter) => {
+    const conditions = [];
+    conditions.push(sql `(blocks.number - ${filter.offset}) % ${filter.interval} = 0`);
+    if (filter.fromBlock !== undefined) {
+        conditions.push(gte(PONDER_SYNC.blocks.number, BigInt(filter.fromBlock)));
+    }
+    if (filter.toBlock !== undefined) {
+        conditions.push(lte(PONDER_SYNC.blocks.number, BigInt(filter.toBlock)));
+    }
+    return and(...conditions);
+};
+export const transactionFilter = (filter) => {
+    const conditions = [];
+    conditions.push(addressFilter(filter.fromAddress, PONDER_SYNC.transactions.from));
+    conditions.push(addressFilter(filter.toAddress, PONDER_SYNC.transactions.to));
+    if (filter.fromBlock !== undefined) {
+        conditions.push(gte(PONDER_SYNC.transactions.blockNumber, BigInt(filter.fromBlock)));
+    }
+    if (filter.toBlock !== undefined) {
+        conditions.push(lte(PONDER_SYNC.transactions.blockNumber, BigInt(filter.toBlock)));
+    }
+    return and(...conditions);
+};
+export const transferFilter = (filter) => {
+    const conditions = [];
+    conditions.push(addressFilter(filter.fromAddress, PONDER_SYNC.traces.from));
+    conditions.push(addressFilter(filter.toAddress, PONDER_SYNC.traces.to));
+    if (filter.includeReverted === false) {
+        conditions.push(isNull(PONDER_SYNC.traces.error));
+    }
+    if (filter.fromBlock !== undefined) {
+        conditions.push(gte(PONDER_SYNC.traces.blockNumber, BigInt(filter.fromBlock)));
+    }
+    if (filter.toBlock !== undefined) {
+        conditions.push(lte(PONDER_SYNC.traces.blockNumber, BigInt(filter.toBlock)));
+    }
+    return and(...conditions);
+};
+export const traceFilter = (filter) => {
+    const conditions = [];
+    conditions.push(addressFilter(filter.fromAddress, PONDER_SYNC.traces.from));
+    conditions.push(addressFilter(filter.toAddress, PONDER_SYNC.traces.to));
+    if (filter.includeReverted === false) {
+        conditions.push(isNull(PONDER_SYNC.traces.error));
+    }
+    if (filter.callType !== undefined) {
+        conditions.push(eq(PONDER_SYNC.traces.type, filter.callType));
+    }
+    if (filter.functionSelector !== undefined) {
+        conditions.push(eq(sql `substring(traces.input from 1 for 10)`, filter.functionSelector));
+    }
+    if (filter.fromBlock !== undefined) {
+        conditions.push(gte(PONDER_SYNC.traces.blockNumber, BigInt(filter.fromBlock)));
+    }
+    if (filter.toBlock !== undefined) {
+        conditions.push(lte(PONDER_SYNC.traces.blockNumber, BigInt(filter.toBlock)));
+    }
+    return and(...conditions);
+};
+//# sourceMappingURL=index.js.map