ponder 0.11.21 → 0.11.22

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

@@ -9,66 +9,65 @@ import { and, asc, desc, eq, gte, inArray, isNull, lt, lte, or, sql, } from "dri
 import { unionAll } from "drizzle-orm/pg-core";
 import { hexToNumber } from "viem";
 import { encodeBlock, encodeLog, encodeTrace, encodeTransaction, encodeTransactionReceipt, } from "./encode.js";
-import * as PONDER_SYNC from "./schema.js";
+import * as ponderSyncSchema from "./schema.js";
 export const createSyncStore = ({ common, database, }) => ({
     insertIntervals: async ({ intervals, chainId }) => {
         if (intervals.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, []);
+        await database.wrap({ method: "insertIntervals", includeTraceLogs: true }, async () => {
+            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);
                 }
-                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})`),
+            // 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})`),
+                });
+            }
+            await database.qb.sync
+                .insert(ponderSyncSchema.intervals)
+                .values(values)
+                .onConflictDoUpdate({
+                target: ponderSyncSchema.intervals.fragmentId,
+                set: {
+                    blocks: sql `intervals.blocks + excluded.blocks`,
+                },
             });
-        }
-        await database
-            .syncQB("insert_intervals")
-            .insert(PONDER_SYNC.intervals)
-            .values(values)
-            .onConflictDoUpdate({
-            target: PONDER_SYNC.intervals.fragmentId,
-            set: {
-                blocks: sql `intervals.blocks + excluded.blocks`,
-            },
         });
     },
-    getIntervals: async ({ filters }) => {
+    getIntervals: async ({ filters }) => database.wrap({ method: "getIntervals", includeTraceLogs: true }, async () => {
         const queries = filters.flatMap((filter, i) => {
             const fragments = getFragments(filter);
-            return fragments.map((fragment, j) => database
-                .syncQB("select_intervals")
+            return fragments.map((fragment, j) => database.qb.sync
                 .select({
                 mergedBlocks: sql `range_agg(unnested.blocks)`.as("merged_blocks"),
                 filter: sql.raw(`'${i}'`).as("filter"),
                 fragment: sql.raw(`'${j}'`).as("fragment"),
             })
-                .from(database
-                .syncQB()
+                .from(database.qb.sync
                 .select({ blocks: sql.raw("unnest(blocks)").as("blocks") })
-                .from(PONDER_SYNC.intervals)
-                .where(inArray(PONDER_SYNC.intervals.fragmentId, fragment.adjacentIds))
+                .from(ponderSyncSchema.intervals)
+                .where(inArray(ponderSyncSchema.intervals.fragmentId, fragment.adjacentIds))
                 .as("unnested")));
         });
         let rows;
@@ -94,83 +93,63 @@ export const createSyncStore = ({ common, database, }) => ({
                     .map((row) => (row.mergedBlocks
                     ? JSON.parse(`[${row.mergedBlocks.slice(1, -1)}]`)
                     : []).map((interval) => [interval[0], interval[1] - 1]))[0];
-                result.get(filter).push({ fragment: fragment.fragment, intervals });
+                result
+                    .get(filter)
+                    .push({ fragment: fragment.fragment, intervals });
             }
         }
         return result;
-    },
+    }),
     insertChildAddresses: async ({ factory, childAddresses, chainId }) => {
         if (childAddresses.size === 0)
             return;
-        const batchSize = Math.floor(common.options.databaseMaxQueryParameters / 3);
-        const values = [];
-        const factoryInsert = database
-            .syncQB()
-            .$with("factory_insert")
-            .as(database
-            .syncQB()
-            .insert(PONDER_SYNC.factories)
-            .values({ 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 database
-                .syncQB("insert_child_addresses")
-                .with(factoryInsert)
-                .insert(PONDER_SYNC.factoryAddresses)
-                .values(values.slice(i, i + batchSize));
-        }
-    },
-    getSafeCrashRecoveryBlock: async ({ chainId, timestamp }) => {
-        const rows = await database
-            .syncQB()
-            .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);
-        return rows[0];
+        await database.wrap({ method: "insertChildAddresses", includeTraceLogs: true }, async () => {
+            const batchSize = Math.floor(common.options.databaseMaxQueryParameters / 3);
+            const values = [];
+            const factoryInsert = database.qb.sync.$with("factory_insert").as(database.qb.sync
+                .insert(ponderSyncSchema.factories)
+                .values({ factory })
+                // @ts-expect-error bug with drizzle-orm
+                .returning({ id: ponderSyncSchema.factories.id })
+                .onConflictDoUpdate({
+                target: ponderSyncSchema.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 database.qb.sync
+                    .with(factoryInsert)
+                    .insert(ponderSyncSchema.factoryAddresses)
+                    .values(values.slice(i, i + batchSize));
+            }
+        });
     },
-    getChildAddresses: ({ factory }) => {
-        const factoryInsert = database
-            .syncQB()
-            .$with("factory_insert")
-            .as(database
-            .syncQB()
-            .insert(PONDER_SYNC.factories)
+    getChildAddresses: ({ factory }) => database.wrap({ method: "getChildAddresses", includeTraceLogs: true }, () => {
+        const factoryInsert = database.qb.sync.$with("factory_insert").as(database.qb.sync
+            .insert(ponderSyncSchema.factories)
             .values({ factory })
             // @ts-expect-error bug with drizzle-orm
-            .returning({ id: PONDER_SYNC.factories.id })
+            .returning({ id: ponderSyncSchema.factories.id })
             .onConflictDoUpdate({
-            target: PONDER_SYNC.factories.factory,
+            target: ponderSyncSchema.factories.factory,
             set: { factory: sql `excluded.factory` },
         }));
-        return database
-            .syncQB("select_child_addresses")
+        return database.qb.sync
             .with(factoryInsert)
             .select({
-            address: PONDER_SYNC.factoryAddresses.address,
-            blockNumber: PONDER_SYNC.factoryAddresses.blockNumber,
+            address: ponderSyncSchema.factoryAddresses.address,
+            blockNumber: ponderSyncSchema.factoryAddresses.blockNumber,
         })
-            .from(PONDER_SYNC.factoryAddresses)
-            .where(eq(PONDER_SYNC.factoryAddresses.factoryId, database
-            .syncQB()
+            .from(ponderSyncSchema.factoryAddresses)
+            .where(eq(ponderSyncSchema.factoryAddresses.factoryId, database.qb.sync
             .select({ id: factoryInsert.id })
             .from(factoryInsert)))
             .then((rows) => {
@@ -183,137 +162,164 @@ export const createSyncStore = ({ common, database, }) => ({
             }
             return result;
         });
+    }),
+    getSafeCrashRecoveryBlock: async ({ chainId, timestamp }) => {
+        return database.wrap({ method: "getSafeCrashRecoveryBlock" }, async () => {
+            const rows = await database.qb.sync
+                .select({
+                number: ponderSyncSchema.blocks.number,
+                timestamp: ponderSyncSchema.blocks.timestamp,
+            })
+                .from(ponderSyncSchema.blocks)
+                .where(and(eq(ponderSyncSchema.blocks.chainId, BigInt(chainId)), lt(ponderSyncSchema.blocks.timestamp, BigInt(timestamp))))
+                .orderBy(desc(ponderSyncSchema.blocks.number))
+                .limit(1);
+            return rows[0];
+        });
     },
     insertLogs: async ({ logs, chainId }) => {
         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);
-        for (let i = 0; i < logs.length; i += batchSize) {
-            await database
-                .syncQB("insert_logs")
-                .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,
-                ],
-            });
-        }
+        await database.wrap({ method: "insertLogs", includeTraceLogs: true }, async () => {
+            // 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 database.qb.sync
+                    .insert(ponderSyncSchema.logs)
+                    .values(logs
+                    .slice(i, i + batchSize)
+                    .map((log) => encodeLog({ log, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        ponderSyncSchema.logs.chainId,
+                        ponderSyncSchema.logs.blockNumber,
+                        ponderSyncSchema.logs.logIndex,
+                    ],
+                });
+            }
+        });
     },
     insertBlocks: async ({ blocks, chainId }) => {
         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 database
-                .syncQB("insert_blocks")
-                .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],
-            });
-        }
+        await database.wrap({ method: "insertBlocks", includeTraceLogs: true }, async () => {
+            // 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 database.qb.sync
+                    .insert(ponderSyncSchema.blocks)
+                    .values(blocks
+                    .slice(i, i + batchSize)
+                    .map((block) => encodeBlock({ block, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        ponderSyncSchema.blocks.chainId,
+                        ponderSyncSchema.blocks.number,
+                    ],
+                });
+            }
+        });
     },
     insertTransactions: async ({ transactions, chainId }) => {
         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);
-        // As an optimization for the migration, transactions inserted before 0.8 do not
-        // contain a checkpoint. However, for correctness the checkpoint must be inserted
-        // for new transactions (using onConflictDoUpdate).
-        for (let i = 0; i < transactions.length; i += batchSize) {
-            await database
-                .syncQB("insert_transactions")
-                .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,
-                ],
-            });
-        }
+        await database.wrap({ method: "insertTransactions", includeTraceLogs: true }, async () => {
+            // 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);
+            // As an optimization for the migration, transactions inserted before 0.8 do not
+            // contain a checkpoint. However, for correctness the checkpoint must be inserted
+            // for new transactions (using onConflictDoUpdate).
+            for (let i = 0; i < transactions.length; i += batchSize) {
+                await database.qb.sync
+                    .insert(ponderSyncSchema.transactions)
+                    .values(transactions
+                    .slice(i, i + batchSize)
+                    .map((transaction) => encodeTransaction({ transaction, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        ponderSyncSchema.transactions.chainId,
+                        ponderSyncSchema.transactions.blockNumber,
+                        ponderSyncSchema.transactions.transactionIndex,
+                    ],
+                });
+            }
+        });
     },
     insertTransactionReceipts: async ({ transactionReceipts, chainId }) => {
         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 database
-                .syncQB("insert_transaction_receipts")
-                .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,
-                ],
-            });
-        }
+        await database.wrap({ method: "insertTransactionReceipts", includeTraceLogs: true }, async () => {
+            // 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 database.qb.sync
+                    .insert(ponderSyncSchema.transactionReceipts)
+                    .values(transactionReceipts
+                    .slice(i, i + batchSize)
+                    .map((transactionReceipt) => encodeTransactionReceipt({
+                    transactionReceipt,
+                    chainId,
+                })))
+                    .onConflictDoNothing({
+                    target: [
+                        ponderSyncSchema.transactionReceipts.chainId,
+                        ponderSyncSchema.transactionReceipts.blockNumber,
+                        ponderSyncSchema.transactionReceipts.transactionIndex,
+                    ],
+                });
+            }
+        });
     },
     insertTraces: async ({ traces, chainId }) => {
         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 database
-                .syncQB("insert_traces")
-                .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,
-                ],
-            });
-        }
+        await database.wrap({ method: "insertTraces", includeTraceLogs: true }, async () => {
+            // 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 database.qb.sync
+                    .insert(ponderSyncSchema.traces)
+                    .values(traces
+                    .slice(i, i + batchSize)
+                    .map(({ trace, block, transaction }) => encodeTrace({ trace, block, transaction, chainId })))
+                    .onConflictDoNothing({
+                    target: [
+                        ponderSyncSchema.traces.chainId,
+                        ponderSyncSchema.traces.blockNumber,
+                        ponderSyncSchema.traces.transactionIndex,
+                        ponderSyncSchema.traces.traceIndex,
+                    ],
+                });
+            }
+        });
     },
-    getEventBlockData: async ({ filters, fromBlock, toBlock, chainId, limit, }) => {
+    getEventBlockData: async ({ filters, fromBlock, toBlock, chainId, limit }) => database.wrap({ method: "getEventBlockData", includeTraceLogs: true }, async () => {
         const logFilters = filters.filter((f) => f.type === "log");
         const transactionFilters = filters.filter((f) => f.type === "transaction");
         const traceFilters = filters.filter((f) => f.type === "trace");
@@ -323,123 +329,143 @@ export const createSyncStore = ({ common, database, }) => ({
         const shouldQueryTraces = traceFilters.length > 0 || transferFilters.length > 0;
         const shouldQueryTransactions = transactionFilters.length > 0 || shouldQueryLogs || shouldQueryTraces;
         const shouldQueryTransactionReceipts = filters.some(shouldGetTransactionReceipt);
-        const blocksQuery = database
-            .syncQB("select_blocks")
+        const blocksQuery = database.qb.sync
             .select({
-            number: PONDER_SYNC.blocks.number,
-            timestamp: PONDER_SYNC.blocks.timestamp,
-            hash: PONDER_SYNC.blocks.hash,
-            parentHash: PONDER_SYNC.blocks.parentHash,
-            logsBloom: PONDER_SYNC.blocks.logsBloom,
-            miner: PONDER_SYNC.blocks.miner,
-            gasUsed: PONDER_SYNC.blocks.gasUsed,
-            gasLimit: PONDER_SYNC.blocks.gasLimit,
-            baseFeePerGas: PONDER_SYNC.blocks.baseFeePerGas,
-            nonce: PONDER_SYNC.blocks.nonce,
-            mixHash: PONDER_SYNC.blocks.mixHash,
-            stateRoot: PONDER_SYNC.blocks.stateRoot,
-            receiptsRoot: PONDER_SYNC.blocks.receiptsRoot,
-            transactionsRoot: PONDER_SYNC.blocks.transactionsRoot,
-            sha3Uncles: PONDER_SYNC.blocks.sha3Uncles,
-            size: PONDER_SYNC.blocks.size,
-            difficulty: PONDER_SYNC.blocks.difficulty,
-            totalDifficulty: PONDER_SYNC.blocks.totalDifficulty,
-            extraData: PONDER_SYNC.blocks.extraData,
+            number: ponderSyncSchema.blocks.number,
+            timestamp: ponderSyncSchema.blocks.timestamp,
+            hash: ponderSyncSchema.blocks.hash,
+            parentHash: ponderSyncSchema.blocks.parentHash,
+            logsBloom: ponderSyncSchema.blocks.logsBloom,
+            miner: ponderSyncSchema.blocks.miner,
+            gasUsed: ponderSyncSchema.blocks.gasUsed,
+            gasLimit: ponderSyncSchema.blocks.gasLimit,
+            baseFeePerGas: ponderSyncSchema.blocks.baseFeePerGas,
+            nonce: ponderSyncSchema.blocks.nonce,
+            mixHash: ponderSyncSchema.blocks.mixHash,
+            stateRoot: ponderSyncSchema.blocks.stateRoot,
+            receiptsRoot: ponderSyncSchema.blocks.receiptsRoot,
+            transactionsRoot: ponderSyncSchema.blocks.transactionsRoot,
+            sha3Uncles: ponderSyncSchema.blocks.sha3Uncles,
+            size: ponderSyncSchema.blocks.size,
+            difficulty: ponderSyncSchema.blocks.difficulty,
+            totalDifficulty: ponderSyncSchema.blocks.totalDifficulty,
+            extraData: ponderSyncSchema.blocks.extraData,
         })
-            .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))
+            .from(ponderSyncSchema.blocks)
+            .where(and(eq(ponderSyncSchema.blocks.chainId, BigInt(chainId)), gte(ponderSyncSchema.blocks.number, BigInt(fromBlock)), lte(ponderSyncSchema.blocks.number, BigInt(toBlock))))
+            .orderBy(asc(ponderSyncSchema.blocks.number))
             .limit(limit);
-        const transactionsQuery = database
-            .syncQB("select_transactions")
+        const transactionsQuery = database.qb.sync
             .select({
-            blockNumber: PONDER_SYNC.transactions.blockNumber,
-            transactionIndex: PONDER_SYNC.transactions.transactionIndex,
-            hash: PONDER_SYNC.transactions.hash,
-            from: PONDER_SYNC.transactions.from,
-            to: PONDER_SYNC.transactions.to,
-            input: PONDER_SYNC.transactions.input,
-            value: PONDER_SYNC.transactions.value,
-            nonce: PONDER_SYNC.transactions.nonce,
-            r: PONDER_SYNC.transactions.r,
-            s: PONDER_SYNC.transactions.s,
-            v: PONDER_SYNC.transactions.v,
-            type: PONDER_SYNC.transactions.type,
-            gas: PONDER_SYNC.transactions.gas,
-            gasPrice: PONDER_SYNC.transactions.gasPrice,
-            maxFeePerGas: PONDER_SYNC.transactions.maxFeePerGas,
-            maxPriorityFeePerGas: PONDER_SYNC.transactions.maxPriorityFeePerGas,
-            accessList: PONDER_SYNC.transactions.accessList,
+            blockNumber: ponderSyncSchema.transactions.blockNumber,
+            transactionIndex: ponderSyncSchema.transactions.transactionIndex,
+            hash: ponderSyncSchema.transactions.hash,
+            from: ponderSyncSchema.transactions.from,
+            to: ponderSyncSchema.transactions.to,
+            input: ponderSyncSchema.transactions.input,
+            value: ponderSyncSchema.transactions.value,
+            nonce: ponderSyncSchema.transactions.nonce,
+            r: ponderSyncSchema.transactions.r,
+            s: ponderSyncSchema.transactions.s,
+            v: ponderSyncSchema.transactions.v,
+            type: ponderSyncSchema.transactions.type,
+            gas: ponderSyncSchema.transactions.gas,
+            gasPrice: ponderSyncSchema.transactions.gasPrice,
+            maxFeePerGas: ponderSyncSchema.transactions.maxFeePerGas,
+            maxPriorityFeePerGas: ponderSyncSchema.transactions.maxPriorityFeePerGas,
+            accessList: ponderSyncSchema.transactions.accessList,
         })
-            .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))
+            .from(ponderSyncSchema.transactions)
+            .where(and(eq(ponderSyncSchema.transactions.chainId, BigInt(chainId)), gte(ponderSyncSchema.transactions.blockNumber, BigInt(fromBlock)), lte(ponderSyncSchema.transactions.blockNumber, BigInt(toBlock))))
+            .orderBy(asc(ponderSyncSchema.transactions.blockNumber), asc(ponderSyncSchema.transactions.transactionIndex))
             .limit(limit);
-        const transactionReceiptsQuery = database
-            .syncQB("select_transaction_receipts")
+        const transactionReceiptsQuery = database.qb.sync
             .select({
-            blockNumber: PONDER_SYNC.transactionReceipts.blockNumber,
-            transactionIndex: PONDER_SYNC.transactionReceipts.transactionIndex,
-            from: PONDER_SYNC.transactionReceipts.from,
-            to: PONDER_SYNC.transactionReceipts.to,
-            contractAddress: PONDER_SYNC.transactionReceipts.contractAddress,
-            logsBloom: PONDER_SYNC.transactionReceipts.logsBloom,
-            gasUsed: PONDER_SYNC.transactionReceipts.gasUsed,
-            cumulativeGasUsed: PONDER_SYNC.transactionReceipts.cumulativeGasUsed,
-            effectiveGasPrice: PONDER_SYNC.transactionReceipts.effectiveGasPrice,
-            status: PONDER_SYNC.transactionReceipts.status,
-            type: PONDER_SYNC.transactionReceipts.type,
+            blockNumber: ponderSyncSchema.transactionReceipts.blockNumber,
+            transactionIndex: ponderSyncSchema.transactionReceipts.transactionIndex,
+            from: ponderSyncSchema.transactionReceipts.from,
+            to: ponderSyncSchema.transactionReceipts.to,
+            contractAddress: ponderSyncSchema.transactionReceipts.contractAddress,
+            logsBloom: ponderSyncSchema.transactionReceipts.logsBloom,
+            gasUsed: ponderSyncSchema.transactionReceipts.gasUsed,
+            cumulativeGasUsed: ponderSyncSchema.transactionReceipts.cumulativeGasUsed,
+            effectiveGasPrice: ponderSyncSchema.transactionReceipts.effectiveGasPrice,
+            status: ponderSyncSchema.transactionReceipts.status,
+            type: ponderSyncSchema.transactionReceipts.type,
         })
-            .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))
+            .from(ponderSyncSchema.transactionReceipts)
+            .where(and(eq(ponderSyncSchema.transactionReceipts.chainId, BigInt(chainId)), gte(ponderSyncSchema.transactionReceipts.blockNumber, BigInt(fromBlock)), lte(ponderSyncSchema.transactionReceipts.blockNumber, BigInt(toBlock))))
+            .orderBy(asc(ponderSyncSchema.transactionReceipts.blockNumber), asc(ponderSyncSchema.transactionReceipts.transactionIndex))
             .limit(limit);
-        const logsQuery = database
-            .syncQB("select_logs")
+        const logsQuery = database.qb.sync
             .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,
+            blockNumber: ponderSyncSchema.logs.blockNumber,
+            logIndex: ponderSyncSchema.logs.logIndex,
+            transactionIndex: ponderSyncSchema.logs.transactionIndex,
+            address: ponderSyncSchema.logs.address,
+            topic0: ponderSyncSchema.logs.topic0,
+            topic1: ponderSyncSchema.logs.topic1,
+            topic2: ponderSyncSchema.logs.topic2,
+            topic3: ponderSyncSchema.logs.topic3,
+            data: ponderSyncSchema.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))
+            .from(ponderSyncSchema.logs)
+            .where(and(eq(ponderSyncSchema.logs.chainId, BigInt(chainId)), gte(ponderSyncSchema.logs.blockNumber, BigInt(fromBlock)), lte(ponderSyncSchema.logs.blockNumber, BigInt(toBlock)), or(...logFilters.map((filter) => logFilter(filter)))))
+            .orderBy(asc(ponderSyncSchema.logs.blockNumber), asc(ponderSyncSchema.logs.logIndex))
             .limit(limit);
-        const tracesQuery = database
-            .syncQB("select_traces")
+        const tracesQuery = database.qb.sync
             .select({
-            blockNumber: PONDER_SYNC.traces.blockNumber,
-            transactionIndex: PONDER_SYNC.traces.transactionIndex,
-            traceIndex: PONDER_SYNC.traces.traceIndex,
-            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,
-            gas: PONDER_SYNC.traces.gas,
-            gasUsed: PONDER_SYNC.traces.gasUsed,
-            error: PONDER_SYNC.traces.error,
-            revertReason: PONDER_SYNC.traces.revertReason,
-            subcalls: PONDER_SYNC.traces.subcalls,
+            blockNumber: ponderSyncSchema.traces.blockNumber,
+            transactionIndex: ponderSyncSchema.traces.transactionIndex,
+            traceIndex: ponderSyncSchema.traces.traceIndex,
+            from: ponderSyncSchema.traces.from,
+            to: ponderSyncSchema.traces.to,
+            input: ponderSyncSchema.traces.input,
+            output: ponderSyncSchema.traces.output,
+            value: ponderSyncSchema.traces.value,
+            type: ponderSyncSchema.traces.type,
+            gas: ponderSyncSchema.traces.gas,
+            gasUsed: ponderSyncSchema.traces.gasUsed,
+            error: ponderSyncSchema.traces.error,
+            revertReason: ponderSyncSchema.traces.revertReason,
+            subcalls: ponderSyncSchema.traces.subcalls,
         })
-            .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.traceIndex))
+            .from(ponderSyncSchema.traces)
+            .where(and(eq(ponderSyncSchema.traces.chainId, BigInt(chainId)), gte(ponderSyncSchema.traces.blockNumber, BigInt(fromBlock)), lte(ponderSyncSchema.traces.blockNumber, BigInt(toBlock)), or(...traceFilters.map((filter) => traceFilter(filter)), ...transferFilters.map((filter) => transferFilter(filter)))))
+            .orderBy(asc(ponderSyncSchema.traces.blockNumber), asc(ponderSyncSchema.traces.traceIndex))
             .limit(limit);
         let endClock = startClock();
         const [blocksRows, transactionsRows, transactionReceiptsRows, logsRows, tracesRows,] = await Promise.all([
-            shouldQueryBlocks ? blocksQuery : [],
-            shouldQueryTransactions ? transactionsQuery : [],
-            shouldQueryTransactionReceipts ? transactionReceiptsQuery : [],
-            shouldQueryLogs ? logsQuery : [],
-            shouldQueryTraces ? tracesQuery : [],
+            shouldQueryBlocks
+                ? blocksQuery.then((res) => {
+                    common.metrics.ponder_database_method_duration.observe({ method: "getEventBlockData_blocks" }, endClock());
+                    return res;
+                })
+                : [],
+            shouldQueryTransactions
+                ? transactionsQuery.then((res) => {
+                    common.metrics.ponder_database_method_duration.observe({ method: "getEventBlockData_transactions" }, endClock());
+                    return res;
+                })
+                : [],
+            shouldQueryTransactionReceipts
+                ? transactionReceiptsQuery.then((res) => {
+                    common.metrics.ponder_database_method_duration.observe({ method: "getEventBlockData_transaction_receipts" }, endClock());
+                    return res;
+                })
+                : [],
+            shouldQueryLogs
+                ? logsQuery.then((res) => {
+                    common.metrics.ponder_database_method_duration.observe({ method: "getEventBlockData_logs" }, endClock());
+                    return res;
+                })
+                : [],
+            shouldQueryTraces
+                ? tracesQuery.then((res) => {
+                    common.metrics.ponder_database_method_duration.observe({ method: "getEventBlockData_traces" }, endClock());
+                    return res;
+                })
+                : [],
         ]);
         const supremum = Math.min(blocksRows.length < limit
             ? Number.POSITIVE_INFINITY
@@ -605,91 +631,94 @@ export const createSyncStore = ({ common, database, }) => ({
             cursor = supremum - 1;
         }
         return { blockData, cursor };
-    },
+    }),
     insertRpcRequestResults: async ({ requests, chainId }) => {
         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 database
-            .syncQB("insert_rpc_request_results")
-            .insert(PONDER_SYNC.rpcRequestResults)
-            .values(values)
-            .onConflictDoUpdate({
-            target: [
-                PONDER_SYNC.rpcRequestResults.requestHash,
-                PONDER_SYNC.rpcRequestResults.chainId,
-            ],
-            set: {
-                result: sql `EXCLUDED.result`,
-            },
+        return database.wrap({ method: "insertRpcRequestResults", includeTraceLogs: true }, async () => {
+            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 database.qb.sync
+                .insert(ponderSyncSchema.rpcRequestResults)
+                .values(values)
+                .onConflictDoUpdate({
+                target: [
+                    ponderSyncSchema.rpcRequestResults.requestHash,
+                    ponderSyncSchema.rpcRequestResults.chainId,
+                ],
+                set: {
+                    result: sql `EXCLUDED.result`,
+                },
+            });
         });
     },
     getRpcRequestResults: async ({ requests, chainId }) => {
         if (requests.length === 0)
             return [];
-        const requestHashes = requests.map((request) => crypto
-            .createHash("md5")
-            .update(toLowerCase(JSON.stringify(orderObject(request))))
-            .digest("hex"));
-        const result = await database
-            .syncQB("select_rpc_request_results")
-            .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)))
-            .execute();
-        const results = new Map();
-        for (const row of result) {
-            results.set(row.request_hash, row.result);
-        }
-        return requestHashes.map((requestHash) => results.get(requestHash));
+        return database.wrap({ method: "getRpcRequestResults", includeTraceLogs: true }, async () => {
+            const requestHashes = requests.map((request) => crypto
+                .createHash("md5")
+                .update(toLowerCase(JSON.stringify(orderObject(request))))
+                .digest("hex"));
+            const result = await database.qb.sync
+                .select({
+                request_hash: ponderSyncSchema.rpcRequestResults.requestHash,
+                result: ponderSyncSchema.rpcRequestResults.result,
+            })
+                .from(ponderSyncSchema.rpcRequestResults)
+                .where(and(eq(ponderSyncSchema.rpcRequestResults.chainId, BigInt(chainId)), inArray(ponderSyncSchema.rpcRequestResults.requestHash, requestHashes)))
+                .execute();
+            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 }) => {
         if (blocks.length === 0)
             return;
-        const numbers = blocks.map(({ number }) => BigInt(hexToNumber(number)));
-        await database
-            .syncQB("delete_rpc_request_results")
-            .delete(PONDER_SYNC.rpcRequestResults)
-            .where(and(eq(PONDER_SYNC.rpcRequestResults.chainId, BigInt(chainId)), inArray(PONDER_SYNC.rpcRequestResults.blockNumber, numbers)))
-            .execute();
+        return database.wrap({ method: "pruneRpcRequestResults", includeTraceLogs: true }, async () => {
+            const numbers = blocks.map(({ number }) => BigInt(hexToNumber(number)));
+            await database.qb.sync
+                .delete(ponderSyncSchema.rpcRequestResults)
+                .where(and(eq(ponderSyncSchema.rpcRequestResults.chainId, BigInt(chainId)), inArray(ponderSyncSchema.rpcRequestResults.blockNumber, numbers)))
+                .execute();
+        });
     },
-    pruneByChain: async ({ chainId }) => database.syncQB().transaction(async (tx) => {
-        await tx("delete_logs")
-            .delete(PONDER_SYNC.logs)
-            .where(eq(PONDER_SYNC.logs.chainId, BigInt(chainId)))
+    pruneByChain: async ({ chainId }) => database.wrap({ method: "pruneByChain", includeTraceLogs: true }, () => database.qb.sync.transaction(async (tx) => {
+        await tx
+            .delete(ponderSyncSchema.logs)
+            .where(eq(ponderSyncSchema.logs.chainId, BigInt(chainId)))
             .execute();
-        await tx("delete_blocks")
-            .delete(PONDER_SYNC.blocks)
-            .where(eq(PONDER_SYNC.blocks.chainId, BigInt(chainId)))
+        await tx
+            .delete(ponderSyncSchema.blocks)
+            .where(eq(ponderSyncSchema.blocks.chainId, BigInt(chainId)))
             .execute();
-        await tx("delete_traces")
-            .delete(PONDER_SYNC.traces)
-            .where(eq(PONDER_SYNC.traces.chainId, BigInt(chainId)))
+        await tx
+            .delete(ponderSyncSchema.traces)
+            .where(eq(ponderSyncSchema.traces.chainId, BigInt(chainId)))
             .execute();
-        await tx("delete_transactions")
-            .delete(PONDER_SYNC.transactions)
-            .where(eq(PONDER_SYNC.transactions.chainId, BigInt(chainId)))
+        await tx
+            .delete(ponderSyncSchema.transactions)
+            .where(eq(ponderSyncSchema.transactions.chainId, BigInt(chainId)))
             .execute();
-        await tx("delete_transaction_receipts")
-            .delete(PONDER_SYNC.transactionReceipts)
-            .where(eq(PONDER_SYNC.transactionReceipts.chainId, BigInt(chainId)))
+        await tx
+            .delete(ponderSyncSchema.transactionReceipts)
+            .where(eq(ponderSyncSchema.transactionReceipts.chainId, BigInt(chainId)))
             .execute();
-        await tx("delete_factory_addresses")
-            .delete(PONDER_SYNC.factoryAddresses)
-            .where(eq(PONDER_SYNC.factoryAddresses.chainId, BigInt(chainId)))
+        await tx
+            .delete(ponderSyncSchema.factoryAddresses)
+            .where(eq(ponderSyncSchema.factoryAddresses.chainId, BigInt(chainId)))
             .execute();
-    }),
+    })),
 });
 const addressFilter = (address, column) => {
     // `factory` filtering is handled in-memory
@@ -712,18 +741,18 @@ export const logFilter = (filter) => {
             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));
+            conditions.push(inArray(ponderSyncSchema.logs[`topic${idx}`], topic));
         }
         else {
-            conditions.push(eq(PONDER_SYNC.logs[`topic${idx}`], topic));
+            conditions.push(eq(ponderSyncSchema.logs[`topic${idx}`], topic));
         }
     }
-    conditions.push(addressFilter(filter.address, PONDER_SYNC.logs.address));
+    conditions.push(addressFilter(filter.address, ponderSyncSchema.logs.address));
     if (filter.fromBlock !== undefined) {
-        conditions.push(gte(PONDER_SYNC.logs.blockNumber, BigInt(filter.fromBlock)));
+        conditions.push(gte(ponderSyncSchema.logs.blockNumber, BigInt(filter.fromBlock)));
     }
     if (filter.toBlock !== undefined) {
-        conditions.push(lte(PONDER_SYNC.logs.blockNumber, BigInt(filter.toBlock)));
+        conditions.push(lte(ponderSyncSchema.logs.blockNumber, BigInt(filter.toBlock)));
     }
     return and(...conditions);
 };
@@ -731,49 +760,49 @@ 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)));
+        conditions.push(gte(ponderSyncSchema.blocks.number, BigInt(filter.fromBlock)));
     }
     if (filter.toBlock !== undefined) {
-        conditions.push(lte(PONDER_SYNC.blocks.number, BigInt(filter.toBlock)));
+        conditions.push(lte(ponderSyncSchema.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));
+    conditions.push(addressFilter(filter.fromAddress, ponderSyncSchema.transactions.from));
+    conditions.push(addressFilter(filter.toAddress, ponderSyncSchema.transactions.to));
     if (filter.fromBlock !== undefined) {
-        conditions.push(gte(PONDER_SYNC.transactions.blockNumber, BigInt(filter.fromBlock)));
+        conditions.push(gte(ponderSyncSchema.transactions.blockNumber, BigInt(filter.fromBlock)));
     }
     if (filter.toBlock !== undefined) {
-        conditions.push(lte(PONDER_SYNC.transactions.blockNumber, BigInt(filter.toBlock)));
+        conditions.push(lte(ponderSyncSchema.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));
+    conditions.push(addressFilter(filter.fromAddress, ponderSyncSchema.traces.from));
+    conditions.push(addressFilter(filter.toAddress, ponderSyncSchema.traces.to));
     if (filter.includeReverted === false) {
-        conditions.push(isNull(PONDER_SYNC.traces.error));
+        conditions.push(isNull(ponderSyncSchema.traces.error));
     }
     if (filter.fromBlock !== undefined) {
-        conditions.push(gte(PONDER_SYNC.traces.blockNumber, BigInt(filter.fromBlock)));
+        conditions.push(gte(ponderSyncSchema.traces.blockNumber, BigInt(filter.fromBlock)));
     }
     if (filter.toBlock !== undefined) {
-        conditions.push(lte(PONDER_SYNC.traces.blockNumber, BigInt(filter.toBlock)));
+        conditions.push(lte(ponderSyncSchema.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));
+    conditions.push(addressFilter(filter.fromAddress, ponderSyncSchema.traces.from));
+    conditions.push(addressFilter(filter.toAddress, ponderSyncSchema.traces.to));
     if (filter.includeReverted === false) {
-        conditions.push(isNull(PONDER_SYNC.traces.error));
+        conditions.push(isNull(ponderSyncSchema.traces.error));
     }
     if (filter.callType !== undefined) {
-        conditions.push(eq(PONDER_SYNC.traces.type, filter.callType));
+        conditions.push(eq(ponderSyncSchema.traces.type, filter.callType));
     }
     if (filter.functionSelector !== undefined) {
         if (Array.isArray(filter.functionSelector)) {
@@ -784,10 +813,10 @@ export const traceFilter = (filter) => {
         }
     }
     if (filter.fromBlock !== undefined) {
-        conditions.push(gte(PONDER_SYNC.traces.blockNumber, BigInt(filter.fromBlock)));
+        conditions.push(gte(ponderSyncSchema.traces.blockNumber, BigInt(filter.fromBlock)));
     }
     if (filter.toBlock !== undefined) {
-        conditions.push(lte(PONDER_SYNC.traces.blockNumber, BigInt(filter.toBlock)));
+        conditions.push(lte(ponderSyncSchema.traces.blockNumber, BigInt(filter.toBlock)));
     }
     return and(...conditions);
 };