ponder 0.9.5-debug.1 → 0.9.5

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

@@ -1,727 +0,0 @@
-import { NonRetryableError } from '../internal/errors.js';
-import { isAddressFactory, shouldGetTransactionReceipt, } from '../sync/filter.js';
-import { fragmentToId, getFragments } from '../sync/fragments.js';
-import { sql as ksql } from "kysely";
-import { checksumAddress, hexToBigInt, } from "viem";
-import { encodeBlock, encodeLog, encodeTrace, encodeTransaction, encodeTransactionReceipt, } from "./encoding.js";
-const logFactorySQL = (qb, factory) => qb
-    .select((() => {
-    if (factory.childAddressLocation.startsWith("offset")) {
-        const childAddressOffset = Number(factory.childAddressLocation.substring(6));
-        const start = 2 + 12 * 2 + childAddressOffset * 2 + 1;
-        const length = 20 * 2;
-        return ksql `'0x' || substring(data from ${start}::int for ${length}::int)`;
-    }
-    else {
-        const start = 2 + 12 * 2 + 1;
-        const length = 20 * 2;
-        return ksql `'0x' || substring(${ksql.ref(factory.childAddressLocation)} from ${start}::integer for ${length}::integer)`;
-    }
-})().as("childAddress"))
-    .distinct()
-    .$call((qb) => {
-    if (Array.isArray(factory.address)) {
-        return qb.where("address", "in", factory.address);
-    }
-    return qb.where("address", "=", factory.address);
-})
-    .where("topic0", "=", factory.eventSelector)
-    .where("chainId", "=", factory.chainId);
-export const createSyncStore = ({ common, database, }) => ({
-    insertIntervals: async ({ intervals, chainId }) => {
-        if (intervals.length === 0)
-            return;
-        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 = fragmentToId(fragment.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({
-                    fragment_id: fragmentId,
-                    chain_id: chainId,
-                    blocks: ksql.raw(`nummultirange(${numranges})`),
-                });
-            }
-            await database.qb.sync
-                .insertInto("intervals")
-                .values(values)
-                .onConflict((oc) => oc.column("fragment_id").doUpdateSet({
-                blocks: ksql `intervals.blocks + excluded.blocks`,
-            }))
-                .execute();
-        });
-    },
-    getIntervals: async ({ filters }) => database.wrap({ method: "getIntervals", includeTraceLogs: true }, async () => {
-        let query;
-        for (let i = 0; i < filters.length; i++) {
-            const filter = filters[i];
-            const fragments = getFragments(filter);
-            for (let j = 0; j < fragments.length; j++) {
-                const fragment = fragments[j];
-                const _query = database.qb.sync
-                    .selectFrom(database.qb.sync
-                    .selectFrom("intervals")
-                    .select(ksql `unnest(blocks)`.as("blocks"))
-                    .where("fragment_id", "in", fragment.adjacentIds)
-                    .as("unnested"))
-                    .select([
-                    ksql `range_agg(unnested.blocks)`.as("merged_blocks"),
-                    ksql.raw(`'${i}'`).as("filter"),
-                    ksql.raw(`'${j}'`).as("fragment"),
-                ]);
-                // @ts-ignore
-                query = query === undefined ? _query : query.unionAll(_query);
-            }
-        }
-        const rows = await query.execute();
-        const result = new Map();
-        // NOTE: `interval[1]` must be rounded down in order to offset the previous
-        // rounding.
-        for (let i = 0; i < filters.length; i++) {
-            const filter = filters[i];
-            const fragments = getFragments(filter);
-            result.set(filter, []);
-            for (let j = 0; j < fragments.length; j++) {
-                const fragment = fragments[j];
-                const intervals = rows
-                    .filter((row) => row.filter === `${i}`)
-                    .filter((row) => row.fragment === `${j}`)
-                    .map((row) => (row.merged_blocks
-                    ? JSON.parse(`[${row.merged_blocks.slice(1, -1)}]`)
-                    : []).map((interval) => [interval[0], interval[1] - 1]))[0];
-                result
-                    .get(filter)
-                    .push({ fragment: fragment.fragment, intervals });
-            }
-        }
-        return result;
-    }),
-    getChildAddresses: ({ filter, limit }) => database.wrap({ method: "getChildAddresses", includeTraceLogs: true }, async () => {
-        return await database.qb.sync
-            .selectFrom("logs")
-            .$call((qb) => logFactorySQL(qb, filter))
-            .$if(limit !== undefined, (qb) => qb.limit(limit))
-            .execute()
-            .then((addresses) => addresses.map(({ childAddress }) => childAddress));
-    }),
-    filterChildAddresses: ({ filter, addresses }) => database.wrap({ method: "filterChildAddresses", includeTraceLogs: true }, async () => {
-        const result = await database.qb.sync
-            .with("addresses(address)", () => ksql `( values ${ksql.join(addresses.map((a) => ksql `( ${ksql.val(a)} )`))} )`)
-            .with("childAddresses", (db) => db.selectFrom("logs").$call((qb) => logFactorySQL(qb, filter)))
-            .selectFrom("addresses")
-            .where("addresses.address", "in", ksql `(SELECT "childAddress" FROM "childAddresses")`)
-            .selectAll()
-            .execute();
-        return new Set([...result.map(({ address }) => address)]);
-    }),
-    insertLogs: async ({ logs, shouldUpdateCheckpoint, chainId }) => {
-        if (logs.length === 0)
-            return;
-        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].log, 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
-                    .insertInto("logs")
-                    .values(logs
-                    .slice(i, i + batchSize)
-                    .map(({ log, block }) => encodeLog({ log, block, chainId })))
-                    .onConflict((oc) => oc.column("id").$call((qb) => shouldUpdateCheckpoint
-                    ? qb.doUpdateSet((eb) => ({
-                        checkpoint: eb.ref("excluded.checkpoint"),
-                    }))
-                    : qb.doNothing()))
-                    .execute();
-            }
-        });
-    },
-    insertBlocks: async ({ blocks, chainId }) => {
-        if (blocks.length === 0)
-            return;
-        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
-                    .insertInto("blocks")
-                    .values(blocks
-                    .slice(i, i + batchSize)
-                    .map((block) => encodeBlock({ block, chainId })))
-                    .onConflict((oc) => oc.column("hash").doNothing())
-                    .execute();
-            }
-        });
-    },
-    hasBlock: async ({ hash }) => database.wrap({ method: "hasBlock", includeTraceLogs: true }, async () => {
-        return await database.qb.sync
-            .selectFrom("blocks")
-            .select("hash")
-            .where("hash", "=", hash)
-            .executeTakeFirst()
-            .then((result) => result !== undefined);
-    }),
-    insertTransactions: async ({ transactions, chainId }) => {
-        if (transactions.length === 0)
-            return;
-        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].transaction,
-                    block: transactions[0].block,
-                    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
-                    .insertInto("transactions")
-                    .values(transactions
-                    .slice(i, i + batchSize)
-                    .map(({ transaction, block }) => encodeTransaction({ transaction, block, chainId })))
-                    .onConflict((oc) => oc.column("hash").doUpdateSet((eb) => ({
-                    checkpoint: eb.ref("excluded.checkpoint"),
-                })))
-                    .execute();
-            }
-        });
-    },
-    hasTransaction: async ({ hash }) => database.wrap({ method: "hasTransaction", includeTraceLogs: true }, async () => {
-        return await database.qb.sync
-            .selectFrom("transactions")
-            .select("hash")
-            .where("hash", "=", hash)
-            .executeTakeFirst()
-            .then((result) => result !== undefined);
-    }),
-    insertTransactionReceipts: async ({ transactionReceipts, chainId }) => {
-        if (transactionReceipts.length === 0)
-            return;
-        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
-                    .insertInto("transactionReceipts")
-                    .values(transactionReceipts
-                    .slice(i, i + batchSize)
-                    .map((transactionReceipt) => encodeTransactionReceipt({
-                    transactionReceipt,
-                    chainId,
-                })))
-                    .onConflict((oc) => oc.column("transactionHash").doNothing())
-                    .execute();
-            }
-        });
-    },
-    hasTransactionReceipt: async ({ hash }) => database.wrap({ method: "hasTransactionReceipt", includeTraceLogs: true }, async () => {
-        return await database.qb.sync
-            .selectFrom("transactionReceipts")
-            .select("transactionHash")
-            .where("transactionHash", "=", hash)
-            .executeTakeFirst()
-            .then((result) => result !== undefined);
-    }),
-    insertTraces: async ({ traces, chainId }) => {
-        if (traces.length === 0)
-            return;
-        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.trace,
-                    block: traces[0].block,
-                    transaction: traces[0].transaction,
-                    chainId,
-                })).length);
-            for (let i = 0; i < traces.length; i += batchSize) {
-                await database.qb.sync
-                    .insertInto("traces")
-                    .values(traces
-                    .slice(i, i + batchSize)
-                    .map(({ trace, block, transaction }) => encodeTrace({
-                    trace: trace.trace,
-                    block,
-                    transaction,
-                    chainId,
-                })))
-                    .onConflict((oc) => oc.column("id").doNothing())
-                    .execute();
-            }
-        });
-    },
-    getEvents: async ({ filters, from, to, limit }) => database.wrap({ method: "getEvents", includeTraceLogs: true }, async () => {
-        let query;
-        for (let i = 0; i < filters.length; i++) {
-            const filter = filters[i];
-            const _query = filter.type === "log"
-                ? logSQL(filter, database.qb.sync, i)
-                : filter.type === "block"
-                    ? blockSQL(filter, database.qb.sync, i)
-                    : filter.type === "transaction"
-                        ? transactionSQL(filter, database.qb.sync, i)
-                        : filter.type === "transfer"
-                            ? transferSQL(filter, database.qb.sync, i)
-                            : traceSQL(filter, database.qb.sync, i);
-            // @ts-ignore
-            query = query === undefined ? _query : query.unionAll(_query);
-        }
-        const rows = await database.qb.sync
-            .with("event", () => query)
-            .selectFrom("event")
-            .select([
-            "event.filterIndex as event_filterIndex",
-            "event.checkpoint as event_checkpoint",
-        ])
-            .innerJoin("blocks", "blocks.hash", "event.blockHash")
-            .select([
-            "blocks.baseFeePerGas as block_baseFeePerGas",
-            "blocks.difficulty as block_difficulty",
-            "blocks.extraData as block_extraData",
-            "blocks.gasLimit as block_gasLimit",
-            "blocks.gasUsed as block_gasUsed",
-            "blocks.hash as block_hash",
-            "blocks.logsBloom as block_logsBloom",
-            "blocks.miner as block_miner",
-            "blocks.mixHash as block_mixHash",
-            "blocks.nonce as block_nonce",
-            "blocks.number as block_number",
-            "blocks.parentHash as block_parentHash",
-            "blocks.receiptsRoot as block_receiptsRoot",
-            "blocks.sha3Uncles as block_sha3Uncles",
-            "blocks.size as block_size",
-            "blocks.stateRoot as block_stateRoot",
-            "blocks.timestamp as block_timestamp",
-            "blocks.totalDifficulty as block_totalDifficulty",
-            "blocks.transactionsRoot as block_transactionsRoot",
-        ])
-            .leftJoin("logs", "logs.id", "event.logId")
-            .select([
-            "logs.address as log_address",
-            "logs.chainId as log_chainId",
-            "logs.data as log_data",
-            "logs.id as log_id",
-            "logs.logIndex as log_logIndex",
-            "logs.topic0 as log_topic0",
-            "logs.topic1 as log_topic1",
-            "logs.topic2 as log_topic2",
-            "logs.topic3 as log_topic3",
-        ])
-            .leftJoin("transactions", "transactions.hash", "event.transactionHash")
-            .select([
-            "transactions.accessList as tx_accessList",
-            "transactions.from as tx_from",
-            "transactions.gas as tx_gas",
-            "transactions.gasPrice as tx_gasPrice",
-            "transactions.hash as tx_hash",
-            "transactions.input as tx_input",
-            "transactions.maxFeePerGas as tx_maxFeePerGas",
-            "transactions.maxPriorityFeePerGas as tx_maxPriorityFeePerGas",
-            "transactions.nonce as tx_nonce",
-            "transactions.r as tx_r",
-            "transactions.s as tx_s",
-            "transactions.to as tx_to",
-            "transactions.transactionIndex as tx_transactionIndex",
-            "transactions.type as tx_type",
-            "transactions.value as tx_value",
-            "transactions.v as tx_v",
-        ])
-            .leftJoin("traces", "traces.id", "event.traceId")
-            .select([
-            "traces.id as trace_id",
-            "traces.type as trace_callType",
-            "traces.from as trace_from",
-            "traces.to as trace_to",
-            "traces.gas as trace_gas",
-            "traces.gasUsed as trace_gasUsed",
-            "traces.input as trace_input",
-            "traces.output as trace_output",
-            "traces.error as trace_error",
-            "traces.revertReason as trace_revertReason",
-            "traces.value as trace_value",
-            "traces.index as trace_index",
-            "traces.subcalls as trace_subcalls",
-        ])
-            .leftJoin("transactionReceipts", "transactionReceipts.transactionHash", "event.transactionHash")
-            .select([
-            "transactionReceipts.contractAddress as txr_contractAddress",
-            "transactionReceipts.cumulativeGasUsed as txr_cumulativeGasUsed",
-            "transactionReceipts.effectiveGasPrice as txr_effectiveGasPrice",
-            "transactionReceipts.from as txr_from",
-            "transactionReceipts.gasUsed as txr_gasUsed",
-            "transactionReceipts.logsBloom as txr_logsBloom",
-            "transactionReceipts.status as txr_status",
-            "transactionReceipts.to as txr_to",
-            "transactionReceipts.type as txr_type",
-        ])
-            .where("event.checkpoint", ">", from)
-            .where("event.checkpoint", "<=", to)
-            .orderBy("event.checkpoint", "asc")
-            .orderBy("event.filterIndex", "asc")
-            .$if(limit !== undefined, (qb) => qb.limit(limit))
-            .execute()
-            .catch((error) => {
-            if (error.message.includes("statement timeout")) {
-                throw new NonRetryableError(error.message);
-            }
-            else {
-                throw error;
-            }
-        });
-        const events = rows.map((_row) => {
-            // Without this cast, the block_ and tx_ fields are all nullable
-            // which makes this very annoying. Should probably add a runtime check
-            // that those fields are indeed present before continuing here.
-            const row = _row;
-            const filter = filters[row.event_filterIndex];
-            const hasLog = row.log_id !== null;
-            const hasTransaction = row.tx_hash !== null;
-            const hasTrace = row.trace_id !== null;
-            const hasTransactionReceipt = shouldGetTransactionReceipt(filter) && row.txr_from !== null;
-            return {
-                chainId: filter.chainId,
-                sourceIndex: Number(row.event_filterIndex),
-                checkpoint: row.event_checkpoint,
-                block: {
-                    baseFeePerGas: row.block_baseFeePerGas !== null
-                        ? BigInt(row.block_baseFeePerGas)
-                        : null,
-                    difficulty: BigInt(row.block_difficulty),
-                    extraData: row.block_extraData,
-                    gasLimit: BigInt(row.block_gasLimit),
-                    gasUsed: BigInt(row.block_gasUsed),
-                    hash: row.block_hash,
-                    logsBloom: row.block_logsBloom,
-                    miner: checksumAddress(row.block_miner),
-                    mixHash: row.block_mixHash,
-                    nonce: row.block_nonce,
-                    number: BigInt(row.block_number),
-                    parentHash: row.block_parentHash,
-                    receiptsRoot: row.block_receiptsRoot,
-                    sha3Uncles: row.block_sha3Uncles,
-                    size: BigInt(row.block_size),
-                    stateRoot: row.block_stateRoot,
-                    timestamp: BigInt(row.block_timestamp),
-                    totalDifficulty: row.block_totalDifficulty !== null
-                        ? BigInt(row.block_totalDifficulty)
-                        : null,
-                    transactionsRoot: row.block_transactionsRoot,
-                },
-                log: hasLog
-                    ? {
-                        address: checksumAddress(row.log_address),
-                        data: row.log_data,
-                        id: row.log_id,
-                        logIndex: Number(row.log_logIndex),
-                        removed: false,
-                        topics: [
-                            row.log_topic0,
-                            row.log_topic1,
-                            row.log_topic2,
-                            row.log_topic3,
-                        ].filter((t) => t !== null),
-                    }
-                    : undefined,
-                transaction: hasTransaction
-                    ? {
-                        from: checksumAddress(row.tx_from),
-                        gas: BigInt(row.tx_gas),
-                        hash: row.tx_hash,
-                        input: row.tx_input,
-                        nonce: Number(row.tx_nonce),
-                        r: row.tx_r,
-                        s: row.tx_s,
-                        to: row.tx_to ? checksumAddress(row.tx_to) : row.tx_to,
-                        transactionIndex: Number(row.tx_transactionIndex),
-                        value: BigInt(row.tx_value),
-                        v: row.tx_v !== null ? BigInt(row.tx_v) : null,
-                        ...(row.tx_type === "0x0"
-                            ? {
-                                type: "legacy",
-                                gasPrice: BigInt(row.tx_gasPrice),
-                            }
-                            : row.tx_type === "0x1"
-                                ? {
-                                    type: "eip2930",
-                                    gasPrice: BigInt(row.tx_gasPrice),
-                                    accessList: JSON.parse(row.tx_accessList),
-                                }
-                                : row.tx_type === "0x2"
-                                    ? {
-                                        type: "eip1559",
-                                        maxFeePerGas: BigInt(row.tx_maxFeePerGas),
-                                        maxPriorityFeePerGas: BigInt(row.tx_maxPriorityFeePerGas),
-                                    }
-                                    : row.tx_type === "0x7e"
-                                        ? {
-                                            type: "deposit",
-                                            maxFeePerGas: row.tx_maxFeePerGas !== null
-                                                ? BigInt(row.tx_maxFeePerGas)
-                                                : undefined,
-                                            maxPriorityFeePerGas: row.tx_maxPriorityFeePerGas !== null
-                                                ? BigInt(row.tx_maxPriorityFeePerGas)
-                                                : undefined,
-                                        }
-                                        : {
-                                            type: row.tx_type,
-                                        }),
-                    }
-                    : undefined,
-                trace: hasTrace
-                    ? {
-                        id: row.trace_id,
-                        type: row.trace_callType,
-                        from: checksumAddress(row.trace_from),
-                        to: checksumAddress(row.trace_to),
-                        gas: BigInt(row.trace_gas),
-                        gasUsed: BigInt(row.trace_gasUsed),
-                        input: row.trace_input,
-                        output: row.trace_output,
-                        value: BigInt(row.trace_value),
-                        traceIndex: Number(row.trace_index),
-                        subcalls: Number(row.trace_subcalls),
-                    }
-                    : undefined,
-                transactionReceipt: hasTransactionReceipt
-                    ? {
-                        contractAddress: row.txr_contractAddress
-                            ? checksumAddress(row.txr_contractAddress)
-                            : null,
-                        cumulativeGasUsed: BigInt(row.txr_cumulativeGasUsed),
-                        effectiveGasPrice: BigInt(row.txr_effectiveGasPrice),
-                        from: checksumAddress(row.txr_from),
-                        gasUsed: BigInt(row.txr_gasUsed),
-                        logsBloom: row.txr_logsBloom,
-                        status: row.txr_status === "0x1"
-                            ? "success"
-                            : row.txr_status === "0x0"
-                                ? "reverted"
-                                : row.txr_status,
-                        to: row.txr_to ? checksumAddress(row.txr_to) : null,
-                        type: row.txr_type === "0x0"
-                            ? "legacy"
-                            : row.txr_type === "0x1"
-                                ? "eip2930"
-                                : row.tx_type === "0x2"
-                                    ? "eip1559"
-                                    : row.tx_type === "0x7e"
-                                        ? "deposit"
-                                        : row.tx_type,
-                    }
-                    : undefined,
-            };
-        });
-        let cursor;
-        if (events.length !== limit) {
-            cursor = to;
-        }
-        else {
-            cursor = events[events.length - 1].checkpoint;
-        }
-        return { events, cursor };
-    }),
-    insertRpcRequestResult: async ({ request, blockNumber, chainId, result }) => database.wrap({ method: "insertRpcRequestResult", includeTraceLogs: true }, async () => {
-        await database.qb.sync
-            .insertInto("rpc_request_results")
-            .values({
-            request,
-            block_number: blockNumber,
-            chain_id: chainId,
-            result,
-        })
-            .onConflict((oc) => oc.columns(["request_hash", "chain_id"]).doUpdateSet({ result }))
-            .execute();
-    }),
-    getRpcRequestResult: async ({ request, chainId }) => database.wrap({ method: "getRpcRequestResult", includeTraceLogs: true }, async () => {
-        const result = await database.qb.sync
-            .selectFrom("rpc_request_results")
-            .select("result")
-            .where("request_hash", "=", ksql `MD5(${request})`)
-            .where("chain_id", "=", chainId)
-            .executeTakeFirst();
-        return result?.result;
-    }),
-    pruneRpcRequestResult: async ({ blocks, chainId }) => database.wrap({ method: "pruneRpcRequestResult", includeTraceLogs: true }, async () => {
-        if (blocks.length === 0)
-            return;
-        const numbers = blocks.map(({ number }) => hexToBigInt(number).toString());
-        await database.qb.sync
-            .deleteFrom("rpc_request_results")
-            .where("chain_id", "=", chainId)
-            .where("block_number", "in", numbers)
-            .execute();
-    }),
-    pruneByChain: async ({ chainId }) => database.wrap({ method: "pruneByChain", includeTraceLogs: true }, () => database.qb.sync.transaction().execute(async (tx) => {
-        await tx.deleteFrom("logs").where("chainId", "=", chainId).execute();
-        await tx.deleteFrom("blocks").where("chainId", "=", chainId).execute();
-        await tx
-            .deleteFrom("rpc_request_results")
-            .where("chain_id", "=", chainId)
-            .execute();
-        await tx.deleteFrom("traces").where("chainId", "=", chainId).execute();
-        await tx
-            .deleteFrom("transactions")
-            .where("chainId", "=", chainId)
-            .execute();
-        await tx
-            .deleteFrom("transactionReceipts")
-            .where("chainId", "=", chainId)
-            .execute();
-    })),
-});
-const addressSQL = (qb, db, address, column) => {
-    if (typeof address === "string")
-        return qb.where(column, "=", address);
-    if (isAddressFactory(address)) {
-        return qb.where(column, "in", db.selectFrom("logs").$call((qb) => logFactorySQL(qb, address)));
-    }
-    if (Array.isArray(address))
-        return qb.where(column, "in", address);
-    return qb;
-};
-const logSQL = (filter, db, index) => db
-    .selectFrom("logs")
-    .select([
-    ksql.raw(`'${index}'`).as("filterIndex"),
-    "checkpoint",
-    "chainId",
-    "blockHash",
-    "transactionHash",
-    "id as logId",
-    ksql `null`.as("traceId"),
-])
-    .where("chainId", "=", filter.chainId)
-    .$call((qb) => {
-    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)) {
-            qb = qb.where((eb) => eb.or(topic.map((t) => eb(`logs.topic${idx}`, "=", t))));
-        }
-        else {
-            qb = qb.where(`logs.topic${idx}`, "=", topic);
-        }
-    }
-    return qb;
-})
-    .$call((qb) => addressSQL(qb, db, filter.address, "address"))
-    .$if(filter.fromBlock !== undefined, (qb) => qb.where("blockNumber", ">=", filter.fromBlock.toString()))
-    .$if(filter.toBlock !== undefined, (qb) => qb.where("blockNumber", "<=", filter.toBlock.toString()));
-const blockSQL = (filter, db, index) => db
-    .selectFrom("blocks")
-    .select([
-    ksql.raw(`'${index}'`).as("filterIndex"),
-    "checkpoint",
-    "chainId",
-    "hash as blockHash",
-    ksql `null`.as("transactionHash"),
-    ksql `null`.as("logId"),
-    ksql `null`.as("traceId"),
-])
-    .where("chainId", "=", filter.chainId)
-    .$if(filter !== undefined && filter.interval !== undefined, (qb) => qb.where(ksql `(number - ${filter.offset}) % ${filter.interval} = 0`))
-    .$if(filter.fromBlock !== undefined, (qb) => qb.where("number", ">=", filter.fromBlock.toString()))
-    .$if(filter.toBlock !== undefined, (qb) => qb.where("number", "<=", filter.toBlock.toString()));
-const transactionSQL = (filter, db, index) => db
-    .selectFrom("transactions")
-    .select([
-    ksql.raw(`'${index}'`).as("filterIndex"),
-    "checkpoint",
-    "chainId",
-    "blockHash",
-    "hash as transactionHash",
-    ksql `null`.as("logId"),
-    ksql `null`.as("traceId"),
-])
-    .where("chainId", "=", filter.chainId)
-    .$call((qb) => addressSQL(qb, db, filter.fromAddress, "from"))
-    .$call((qb) => addressSQL(qb, db, filter.toAddress, "to"))
-    .$if(filter.includeReverted === false, (qb) => qb.where(db
-    .selectFrom("transactionReceipts")
-    .select("status")
-    .where("transactionReceipts.transactionHash", "=", ksql.ref("transactions.hash")), "=", "0x1"))
-    .$if(filter.fromBlock !== undefined, (qb) => qb.where("blockNumber", ">=", filter.fromBlock.toString()))
-    .$if(filter.toBlock !== undefined, (qb) => qb.where("blockNumber", "<=", filter.toBlock.toString()));
-const transferSQL = (filter, db, index) => db
-    .selectFrom("traces")
-    .select([
-    ksql.raw(`'${index}'`).as("filterIndex"),
-    "checkpoint",
-    "chainId",
-    "blockHash",
-    "transactionHash",
-    ksql `null`.as("logId"),
-    "id as traceId",
-])
-    .where("chainId", "=", filter.chainId)
-    .$call((qb) => addressSQL(qb, db, filter.fromAddress, "from"))
-    .$call((qb) => addressSQL(qb, db, filter.toAddress, "to"))
-    .where("value", ">", "0")
-    .$if(filter.includeReverted === false, (qb) => qb.where("isReverted", "=", 0))
-    .$if(filter.fromBlock !== undefined, (qb) => qb.where("blockNumber", ">=", filter.fromBlock.toString()))
-    .$if(filter.toBlock !== undefined, (qb) => qb.where("blockNumber", "<=", filter.toBlock.toString()));
-const traceSQL = (filter, db, index) => db
-    .selectFrom("traces")
-    .select([
-    ksql.raw(`'${index}'`).as("filterIndex"),
-    "checkpoint",
-    "chainId",
-    "blockHash",
-    "transactionHash",
-    ksql `null`.as("logId"),
-    "id as traceId",
-])
-    .where("chainId", "=", filter.chainId)
-    .$call((qb) => addressSQL(qb, db, filter.fromAddress, "from"))
-    .$call((qb) => addressSQL(qb, db, filter.toAddress, "to"))
-    .$if(filter.includeReverted === false, (qb) => qb.where("isReverted", "=", 0))
-    .$if(filter.callType !== undefined, (qb) => qb.where("type", "=", filter.callType))
-    .$if(filter.functionSelector !== undefined, (qb) => {
-    if (Array.isArray(filter.functionSelector)) {
-        return qb.where("functionSelector", "in", filter.functionSelector);
-    }
-    else {
-        return qb.where("functionSelector", "=", filter.functionSelector);
-    }
-})
-    .$if(filter.fromBlock !== undefined, (qb) => qb.where("blockNumber", ">=", filter.fromBlock.toString()))
-    .$if(filter.toBlock !== undefined, (qb) => qb.where("blockNumber", "<=", filter.toBlock.toString()));
-//# sourceMappingURL=index.js.map