ponder 0.14.13 → 0.15.0

package/dist/esm/build/config.js

@@ -2,12 +2,12 @@ import { BuildError } from '../internal/errors.js';
 import { _eth_getBlockByNumber } from '../rpc/actions.js';
 import { createRpc } from '../rpc/index.js';
 import { defaultBlockFilterInclude, defaultLogFilterInclude, defaultTraceFilterInclude, defaultTransactionFilterInclude, defaultTransactionReceiptInclude, defaultTransferFilterInclude, } from '../runtime/filter.js';
-import { buildAbiEvents, buildAbiFunctions, buildTopics } from '../utils/abi.js';
+import { buildTopics, toSafeName } from '../utils/abi.js';
 import { hyperliquidEvm, chains as viemChains } from '../utils/chains.js';
 import { dedupe } from '../utils/dedupe.js';
 import { getFinalityBlockCount } from '../utils/finality.js';
 import { toLowerCase } from '../utils/lowercase.js';
-import { BlockNotFoundError, hexToNumber } from "viem";
+import { BlockNotFoundError, hexToNumber, toEventSelector, toFunctionSelector, } from "viem";
 import { buildLogFactory } from "./factory.js";
 const flattenSources = (config) => {
     return Object.entries(config).flatMap(([name, source]) => {
@@ -31,7 +31,7 @@ const flattenSources = (config) => {
         }
     });
 };
-export async function buildIndexingFunctions({ common, config, rawIndexingFunctions, configBuild: { chains, rpcs }, }) {
+export async function buildIndexingFunctions({ common, config, indexingFunctions, configBuild: { chains, rpcs }, }) {
     const context = { logger: common.logger.child({ action: "build" }) };
     const logs = [];
     const perChainLatestBlockNumber = new Map();
@@ -94,9 +94,11 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
         sourceNames.add(source);
     }
     // Validate and build indexing functions
-    let indexingFunctionCount = 0;
-    const indexingFunctions = {};
-    for (const { name: eventName, fn } of rawIndexingFunctions) {
+    if (indexingFunctions.length === 0) {
+        throw new Error("Validation failed: Found 0 registered indexing functions.");
+    }
+    const eventNames = new Set();
+    for (const { name: eventName } of indexingFunctions) {
         const eventNameComponents = eventName.includes(".")
             ? eventName.split(".")
             : eventName.split(":");
@@ -120,9 +122,10 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
         else {
             throw new Error(`Validation failed: Invalid event '${eventName}', expected format '{sourceName}:{eventName}' or '{sourceName}.{functionName}'.`);
         }
-        if (eventName in indexingFunctions) {
+        if (eventNames.has(eventName)) {
             throw new Error(`Validation failed: Multiple indexing functions registered for event '${eventName}'.`);
         }
+        eventNames.add(eventName);
         // Validate that the indexing function uses a sourceName that is present in the config.
         const matchedSourceName = Object.keys({
             ...(config.contracts ?? {}),
@@ -134,11 +137,6 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
                 .map((n) => `'${n}'`)
                 .join(", ")}].`);
         }
-        indexingFunctions[eventName] = fn;
-        indexingFunctionCount += 1;
-    }
-    if (indexingFunctionCount === 0) {
-        logs.push({ level: "warn", msg: "No registered indexing functions" });
     }
     // common validation for all sources
     for (const source of [
@@ -191,12 +189,102 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
             }
         }
     }
-    const contractSources = (await Promise.all(flattenSources(config.contracts ?? {}).map(async (source) => {
+    const perChainEventCallbacks = new Map();
+    const perChainSetupCallbacks = new Map();
+    const perChainContracts = new Map();
+    for (const chain of chains) {
+        perChainEventCallbacks.set(chain.id, []);
+        perChainSetupCallbacks.set(chain.id, []);
+        perChainContracts.set(chain.id, {});
+    }
+    for (const source of flattenSources(config.contracts ?? {})) {
         const chain = chains.find((n) => n.name === source.chain);
-        // Get indexing function that were registered for this contract
+        const fromBlock = await resolveBlockNumber(source.startBlock, chain);
+        const toBlock = await resolveBlockNumber(source.endBlock, chain);
+        if (indexingFunctions.some((f) => f.name === `${source.name}:setup`)) {
+            perChainSetupCallbacks.get(chain.id).push({
+                name: `${source.name}:setup`,
+                fn: indexingFunctions.find((f) => f.name === `${source.name}:setup`)
+                    .fn,
+                chain,
+                block: fromBlock,
+            });
+        }
+        let address;
+        const resolvedAddress = source?.address;
+        if (typeof resolvedAddress === "object" &&
+            Array.isArray(resolvedAddress) === false) {
+            const factoryAddress = resolvedAddress;
+            const factoryFromBlock = (await resolveBlockNumber(factoryAddress.startBlock, chain)) ??
+                fromBlock;
+            const factoryToBlock = (await resolveBlockNumber(factoryAddress.endBlock, chain)) ?? toBlock;
+            // Note that this can throw.
+            const logFactory = buildLogFactory({
+                chainId: chain.id,
+                ...factoryAddress,
+                fromBlock: factoryFromBlock,
+                toBlock: factoryToBlock,
+            });
+            perChainContracts.get(chain.id)[source.name] = {
+                abi: source.abi,
+                address: undefined,
+                startBlock: fromBlock,
+                endBlock: toBlock,
+            };
+            address = logFactory;
+        }
+        else {
+            if (resolvedAddress !== undefined) {
+                for (const address of Array.isArray(resolvedAddress)
+                    ? resolvedAddress
+                    : [resolvedAddress]) {
+                    if (!address.startsWith("0x"))
+                        throw new Error(`Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(0, 2)}', expected '0x'.`);
+                    if (address.length !== 42)
+                        throw new Error(`Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`);
+                }
+            }
+            const validatedAddress = Array.isArray(resolvedAddress)
+                ? dedupe(resolvedAddress).map((r) => toLowerCase(r))
+                : resolvedAddress !== undefined
+                    ? toLowerCase(resolvedAddress)
+                    : undefined;
+            perChainContracts.get(chain.id)[source.name] = {
+                abi: source.abi,
+                address: validatedAddress,
+                startBlock: fromBlock,
+                endBlock: toBlock,
+            };
+            address = validatedAddress;
+        }
+        const filteredEventSelectors = new Map();
+        if (source.filter) {
+            const eventFilters = Array.isArray(source.filter)
+                ? source.filter
+                : [source.filter];
+            for (const filter of eventFilters) {
+                const abiEvent = source.abi.find((item) => item.type === "event" &&
+                    toSafeName({ abi: source.abi, item }) === filter.event);
+                if (!abiEvent) {
+                    throw new Error(`Validation failed: Invalid filter for contract '${source.name}'. Got event name '${filter.event}', expected one of [${source.abi
+                        .filter((item) => item.type === "event")
+                        .map((item) => `'${toSafeName({ abi: source.abi, item })}'`)
+                        .join(", ")}].`);
+                }
+            }
+            const topics = buildTopics(source.abi, eventFilters);
+            for (const { topic0, topic1, topic2, topic3 } of topics) {
+                const abiItem = source.abi.find((item) => item.type === "event" && toEventSelector(item) === topic0);
+                const indexingFunction = indexingFunctions.find((f) => f.name === `${source.name}:${abiItem.name}`);
+                if (indexingFunction === undefined) {
+                    throw new Error(`Validation failed: Event selector '${toSafeName({ abi: source.abi, item: abiItem })}' is used in a filter but does not have a corresponding indexing function.`);
+                }
+                filteredEventSelectors.set(topic0, { topic0, topic1, topic2, topic3 });
+            }
+        }
         const registeredLogEvents = [];
         const registeredCallTraceEvents = [];
-        for (const eventName of Object.keys(indexingFunctions)) {
+        for (const { name: eventName } of indexingFunctions) {
             // log event
             if (eventName.includes(":")) {
                 const [logContractName, logEventName] = eventName.split(":");
@@ -204,228 +292,124 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
                     registeredLogEvents.push(logEventName);
                 }
             }
-            //  trace event
+            // trace event
             if (eventName.includes(".")) {
                 const [functionContractName, functionName] = eventName.split(".");
+                if (source.includeCallTraces !== true) {
+                    continue;
+                }
                 if (functionContractName === source.name) {
                     registeredCallTraceEvents.push(functionName);
                 }
             }
         }
-        // Note: This can probably throw for invalid ABIs. Consider adding explicit ABI validation before this line.
-        const abiEvents = buildAbiEvents({ abi: source.abi });
-        const abiFunctions = buildAbiFunctions({ abi: source.abi });
-        const registeredEventSelectors = [];
-        // Validate that the registered log events exist in the abi
-        for (const logEvent of registeredLogEvents) {
-            const abiEvent = abiEvents.bySafeName[logEvent];
+        for (const logEventName of registeredLogEvents) {
+            const abiEvent = source.abi.find((item) => item.type === "event" &&
+                toSafeName({ abi: source.abi, item }) === logEventName);
             if (abiEvent === undefined) {
-                throw new Error(`Validation failed: Event name for event '${logEvent}' not found in the contract ABI. Got '${logEvent}', expected one of [${Object.keys(abiEvents.bySafeName)
-                    .map((eventName) => `'${eventName}'`)
+                throw new Error(`Validation failed: Event name for event '${logEventName}' not found in the contract ABI. Got '${logEventName}', expected one of [${source.abi
+                    .filter((item) => item.type === "event")
+                    .map((item) => `'${toSafeName({ abi: source.abi, item })}'`)
                     .join(", ")}].`);
             }
-            registeredEventSelectors.push(abiEvent.selector);
-        }
-        const registeredFunctionSelectors = [];
-        for (const _function of registeredCallTraceEvents) {
-            const abiFunction = abiFunctions.bySafeName[_function];
-            if (abiFunction === undefined) {
-                throw new Error(`Validation failed: Function name for function '${_function}' not found in the contract ABI. Got '${_function}', expected one of [${Object.keys(abiFunctions.bySafeName)
-                    .map((eventName) => `'${eventName}'`)
-                    .join(", ")}].`);
+            const eventName = `${source.name}:${logEventName}`;
+            const indexingFunction = indexingFunctions.find((f) => f.name === eventName);
+            let topic1;
+            let topic2;
+            let topic3;
+            const eventSelector = toEventSelector(abiEvent);
+            if (filteredEventSelectors.has(eventSelector)) {
+                topic1 = filteredEventSelectors.get(eventSelector).topic1;
+                topic2 = filteredEventSelectors.get(eventSelector).topic2;
+                topic3 = filteredEventSelectors.get(eventSelector).topic3;
             }
-            registeredFunctionSelectors.push(abiFunction.selector);
-        }
-        const topicsArray = [];
-        if (source.filter !== undefined) {
-            const eventFilters = Array.isArray(source.filter)
-                ? source.filter
-                : [source.filter];
-            for (const filter of eventFilters) {
-                const abiEvent = abiEvents.bySafeName[filter.event];
-                if (!abiEvent) {
-                    throw new Error(`Validation failed: Invalid filter for contract '${source.name}'. Got event name '${filter.event}', expected one of [${Object.keys(abiEvents.bySafeName)
-                        .map((n) => `'${n}'`)
-                        .join(", ")}].`);
-                }
-            }
-            topicsArray.push(...buildTopics(source.abi, eventFilters));
-            // event selectors that have a filter
-            const filteredEventSelectors = topicsArray.map((t) => t.topic0);
-            // event selectors that are registered but don't have a filter
-            const excludedRegisteredEventSelectors = registeredEventSelectors.filter((s) => filteredEventSelectors.includes(s) === false);
-            for (const selector of filteredEventSelectors) {
-                if (registeredEventSelectors.includes(selector) === false) {
-                    throw new Error(`Validation failed: Event selector '${abiEvents.bySelector[selector]?.safeName}' is used in a filter but does not have a corresponding indexing function.`);
-                }
-            }
-            if (excludedRegisteredEventSelectors.length > 0) {
-                topicsArray.push({
-                    topic0: excludedRegisteredEventSelectors,
-                    topic1: null,
-                    topic2: null,
-                    topic3: null,
-                });
+            else {
+                topic1 = null;
+                topic2 = null;
+                topic3 = null;
             }
-        }
-        else {
-            topicsArray.push({
-                topic0: registeredEventSelectors,
-                topic1: null,
-                topic2: null,
-                topic3: null,
-            });
-        }
-        const fromBlock = await resolveBlockNumber(source.startBlock, chain);
-        const toBlock = await resolveBlockNumber(source.endBlock, chain);
-        const contractMetadata = {
-            type: "contract",
-            abi: source.abi,
-            abiEvents,
-            abiFunctions,
-            name: source.name,
-            chain,
-        };
-        const resolvedAddress = source?.address;
-        if (typeof resolvedAddress === "object" &&
-            !Array.isArray(resolvedAddress)) {
-            const factoryFromBlock = (await resolveBlockNumber(resolvedAddress.startBlock, chain)) ??
-                fromBlock;
-            const factoryToBlock = (await resolveBlockNumber(resolvedAddress.endBlock, chain)) ??
-                toBlock;
-            // Note that this can throw.
-            const logFactory = buildLogFactory({
+            const filter = {
+                type: "log",
                 chainId: chain.id,
-                ...resolvedAddress,
-                fromBlock: factoryFromBlock,
-                toBlock: factoryToBlock,
-            });
-            const logSources = topicsArray.map((topics) => ({
-                ...contractMetadata,
-                filter: {
-                    type: "log",
-                    chainId: chain.id,
-                    address: logFactory,
-                    topic0: topics.topic0,
-                    topic1: topics.topic1,
-                    topic2: topics.topic2,
-                    topic3: topics.topic3,
-                    fromBlock,
-                    toBlock,
-                    hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                    include: defaultLogFilterInclude.concat(source.includeTransactionReceipts
-                        ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                        : []),
+                sourceId: source.name,
+                address,
+                topic0: eventSelector,
+                topic1,
+                topic2,
+                topic3,
+                fromBlock,
+                toBlock,
+                hasTransactionReceipt: source.includeTransactionReceipts ?? false,
+                include: defaultLogFilterInclude.concat(source.includeTransactionReceipts
+                    ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
+                    : []),
+            };
+            const eventCallback = {
+                filter,
+                name: eventName,
+                fn: indexingFunction.fn,
+                chain,
+                type: "contract",
+                abiItem: abiEvent,
+                metadata: {
+                    safeName: logEventName,
+                    abi: source.abi,
                 },
-            }));
-            if (source.includeCallTraces) {
-                return [
-                    ...logSources,
-                    {
-                        ...contractMetadata,
-                        filter: {
-                            type: "trace",
-                            chainId: chain.id,
-                            fromAddress: undefined,
-                            toAddress: logFactory,
-                            callType: "CALL",
-                            functionSelector: registeredFunctionSelectors,
-                            includeReverted: false,
-                            fromBlock,
-                            toBlock,
-                            hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                            include: defaultTraceFilterInclude.concat(source.includeTransactionReceipts
-                                ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                                : []),
-                        },
-                    },
-                ];
-            }
-            return logSources;
+            };
+            perChainEventCallbacks.get(chain.id).push(eventCallback);
         }
-        else if (resolvedAddress !== undefined) {
-            for (const address of Array.isArray(resolvedAddress)
-                ? resolvedAddress
-                : [resolvedAddress]) {
-                if (!address.startsWith("0x"))
-                    throw new Error(`Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(0, 2)}', expected '0x'.`);
-                if (address.length !== 42)
-                    throw new Error(`Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`);
+        for (const functionEventName of registeredCallTraceEvents) {
+            const abiFunction = source.abi.find((item) => item.type === "function" &&
+                toSafeName({ abi: source.abi, item }) === functionEventName);
+            if (abiFunction === undefined) {
+                throw new Error(`Validation failed: Function name for function '${functionEventName}' not found in the contract ABI. Got '${functionEventName}', expected one of [${source.abi
+                    .filter((item) => item.type === "function")
+                    .map((item) => `'${toSafeName({ abi: source.abi, item })}'`)
+                    .join(", ")}].`);
             }
-        }
-        const validatedAddress = Array.isArray(resolvedAddress)
-            ? dedupe(resolvedAddress).map((r) => toLowerCase(r))
-            : resolvedAddress !== undefined
-                ? toLowerCase(resolvedAddress)
-                : undefined;
-        const logSources = topicsArray.map((topics) => ({
-            ...contractMetadata,
-            filter: {
-                type: "log",
+            const eventName = `${source.name}.${functionEventName}`;
+            const indexingFunction = indexingFunctions.find((f) => f.name === eventName);
+            const filter = {
+                type: "trace",
                 chainId: chain.id,
-                address: validatedAddress,
-                topic0: topics.topic0,
-                topic1: topics.topic1,
-                topic2: topics.topic2,
-                topic3: topics.topic3,
+                sourceId: source.name,
+                fromAddress: undefined,
+                toAddress: address,
+                callType: "CALL",
+                functionSelector: toFunctionSelector(abiFunction),
+                includeReverted: false,
                 fromBlock,
                 toBlock,
                 hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                include: defaultLogFilterInclude.concat(source.includeTransactionReceipts
+                include: defaultTraceFilterInclude.concat(source.includeTransactionReceipts
                     ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
                     : []),
-            },
-        }));
-        if (source.includeCallTraces) {
-            return [
-                ...logSources,
-                {
-                    ...contractMetadata,
-                    filter: {
-                        type: "trace",
-                        chainId: chain.id,
-                        fromAddress: undefined,
-                        toAddress: Array.isArray(validatedAddress)
-                            ? validatedAddress
-                            : validatedAddress === undefined
-                                ? undefined
-                                : [validatedAddress],
-                        callType: "CALL",
-                        functionSelector: registeredFunctionSelectors,
-                        includeReverted: false,
-                        fromBlock,
-                        toBlock,
-                        hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                        include: defaultTraceFilterInclude.concat(source.includeTransactionReceipts
-                            ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                            : []),
-                    },
+            };
+            const eventCallback = {
+                filter,
+                name: eventName,
+                fn: indexingFunction.fn,
+                chain,
+                type: "contract",
+                abiItem: abiFunction,
+                metadata: {
+                    safeName: functionEventName,
+                    abi: source.abi,
                 },
-            ];
-        }
-        else
-            return logSources;
-    })))
-        .flat() // Remove sources with no registered indexing functions
-        .filter((source) => {
-        const hasNoRegisteredIndexingFunctions = source.filter.type === "trace"
-            ? Array.isArray(source.filter.functionSelector) &&
-                source.filter.functionSelector.length === 0
-            : Array.isArray(source.filter.topic0) &&
-                source.filter.topic0?.length === 0;
-        if (hasNoRegisteredIndexingFunctions) {
+            };
+            perChainEventCallbacks.get(chain.id).push(eventCallback);
+        }
+        if (registeredLogEvents.length === 0 &&
+            registeredCallTraceEvents.length === 0) {
             logs.push({
                 level: "warn",
                 msg: "No registered indexing functions",
-                chain: source.chain.name,
-                chain_id: source.chain.id,
                 name: source.name,
-                type: source.filter.type,
+                type: "contract",
             });
         }
-        return hasNoRegisteredIndexingFunctions === false;
-    });
-    const accountSources = (await Promise.all(flattenSources(config.accounts ?? {}).map(async (source) => {
+    }
+    for (const source of flattenSources(config.accounts ?? {})) {
         const chain = chains.find((n) => n.name === source.chain);
         const fromBlock = await resolveBlockNumber(source.startBlock, chain);
         const toBlock = await resolveBlockNumber(source.endBlock, chain);
@@ -433,12 +417,12 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
         if (resolvedAddress === undefined) {
             throw new Error(`Validation failed: Account '${source.name}' must specify an 'address'.`);
         }
+        let address;
         if (typeof resolvedAddress === "object" &&
             !Array.isArray(resolvedAddress)) {
             const factoryFromBlock = (await resolveBlockNumber(resolvedAddress.startBlock, chain)) ??
                 fromBlock;
-            const factoryToBlock = (await resolveBlockNumber(resolvedAddress.endBlock, chain)) ??
-                toBlock;
+            const factoryToBlock = (await resolveBlockNumber(resolvedAddress.endBlock, chain)) ?? toBlock;
             // Note that this can throw.
             const logFactory = buildLogFactory({
                 chainId: chain.id,
@@ -446,184 +430,111 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
                 fromBlock: factoryFromBlock,
                 toBlock: factoryToBlock,
             });
-            return [
-                {
-                    type: "account",
-                    name: source.name,
-                    chain,
-                    filter: {
-                        type: "transaction",
-                        chainId: chain.id,
-                        fromAddress: undefined,
-                        toAddress: logFactory,
-                        includeReverted: false,
-                        fromBlock,
-                        toBlock,
-                        hasTransactionReceipt: true,
-                        include: defaultTransactionFilterInclude,
-                    },
-                },
-                {
-                    type: "account",
-                    name: source.name,
-                    chain,
-                    filter: {
-                        type: "transaction",
-                        chainId: chain.id,
-                        fromAddress: logFactory,
-                        toAddress: undefined,
-                        includeReverted: false,
-                        fromBlock,
-                        toBlock,
-                        hasTransactionReceipt: true,
-                        include: defaultTransactionFilterInclude,
-                    },
-                },
-                {
-                    type: "account",
-                    name: source.name,
-                    chain,
-                    filter: {
-                        type: "transfer",
-                        chainId: chain.id,
-                        fromAddress: undefined,
-                        toAddress: logFactory,
-                        includeReverted: false,
-                        fromBlock,
-                        toBlock,
-                        hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                        include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
-                            ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                            : []),
-                    },
-                },
-                {
-                    type: "account",
-                    name: source.name,
-                    chain,
-                    filter: {
-                        type: "transfer",
-                        chainId: chain.id,
-                        fromAddress: logFactory,
-                        toAddress: undefined,
-                        includeReverted: false,
-                        fromBlock,
-                        toBlock,
-                        hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                        include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
-                            ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                            : []),
-                    },
-                },
-            ];
-        }
-        for (const address of Array.isArray(resolvedAddress)
-            ? resolvedAddress
-            : [resolvedAddress]) {
-            if (!address.startsWith("0x"))
-                throw new Error(`Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(0, 2)}', expected '0x'.`);
-            if (address.length !== 42)
-                throw new Error(`Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`);
-        }
-        const validatedAddress = Array.isArray(resolvedAddress)
-            ? dedupe(resolvedAddress).map((r) => toLowerCase(r))
-            : resolvedAddress !== undefined
-                ? toLowerCase(resolvedAddress)
-                : undefined;
-        return [
+            address = logFactory;
+        }
+        else {
+            for (const address of Array.isArray(resolvedAddress)
+                ? resolvedAddress
+                : [resolvedAddress]) {
+                if (!address.startsWith("0x"))
+                    throw new Error(`Validation failed: Invalid prefix for address '${address}'. Got '${address.slice(0, 2)}', expected '0x'.`);
+                if (address.length !== 42)
+                    throw new Error(`Validation failed: Invalid length for address '${address}'. Got ${address.length}, expected 42 characters.`);
+            }
+            const validatedAddress = Array.isArray(resolvedAddress)
+                ? dedupe(resolvedAddress).map((r) => toLowerCase(r))
+                : resolvedAddress !== undefined
+                    ? toLowerCase(resolvedAddress)
+                    : undefined;
+            address = validatedAddress;
+        }
+        const filters = [
             {
-                type: "account",
-                name: source.name,
-                chain,
-                filter: {
-                    type: "transaction",
-                    chainId: chain.id,
-                    fromAddress: undefined,
-                    toAddress: validatedAddress,
-                    includeReverted: false,
-                    fromBlock,
-                    toBlock,
-                    hasTransactionReceipt: true,
-                    include: defaultTransactionFilterInclude,
-                },
+                type: "transaction",
+                chainId: chain.id,
+                sourceId: source.name,
+                fromAddress: undefined,
+                toAddress: address,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                hasTransactionReceipt: true,
+                include: defaultTransactionFilterInclude,
             },
             {
-                type: "account",
-                name: source.name,
-                chain,
-                filter: {
-                    type: "transaction",
-                    chainId: chain.id,
-                    fromAddress: validatedAddress,
-                    toAddress: undefined,
-                    includeReverted: false,
-                    fromBlock,
-                    toBlock,
-                    hasTransactionReceipt: true,
-                    include: defaultTransactionFilterInclude,
-                },
+                type: "transaction",
+                chainId: chain.id,
+                sourceId: source.name,
+                fromAddress: address,
+                toAddress: undefined,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                hasTransactionReceipt: true,
+                include: defaultTransactionFilterInclude,
             },
             {
-                type: "account",
-                name: source.name,
-                chain,
-                filter: {
-                    type: "transfer",
-                    chainId: chain.id,
-                    fromAddress: undefined,
-                    toAddress: validatedAddress,
-                    includeReverted: false,
-                    fromBlock,
-                    toBlock,
-                    hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                    include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
-                        ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                        : []),
-                },
+                type: "transfer",
+                chainId: chain.id,
+                sourceId: source.name,
+                fromAddress: undefined,
+                toAddress: address,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                hasTransactionReceipt: source.includeTransactionReceipts ?? false,
+                include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
+                    ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
+                    : []),
             },
             {
-                type: "account",
-                name: source.name,
-                chain,
-                filter: {
-                    type: "transfer",
-                    chainId: chain.id,
-                    fromAddress: validatedAddress,
-                    toAddress: undefined,
-                    includeReverted: false,
-                    fromBlock,
-                    toBlock,
-                    hasTransactionReceipt: source.includeTransactionReceipts ?? false,
-                    include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
-                        ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
-                        : []),
-                },
+                type: "transfer",
+                chainId: chain.id,
+                sourceId: source.name,
+                fromAddress: address,
+                toAddress: undefined,
+                includeReverted: false,
+                fromBlock,
+                toBlock,
+                hasTransactionReceipt: source.includeTransactionReceipts ?? false,
+                include: defaultTransferFilterInclude.concat(source.includeTransactionReceipts
+                    ? defaultTransactionReceiptInclude.map((value) => `transactionReceipt.${value}`)
+                    : []),
             },
         ];
-    })))
-        .flat()
-        .filter((source) => {
-        const eventName = source.filter.type === "transaction"
-            ? source.filter.fromAddress === undefined
-                ? `${source.name}:transaction:to`
-                : `${source.name}:transaction:from`
-            : source.filter.fromAddress === undefined
-                ? `${source.name}:transfer:to`
-                : `${source.name}:transfer:from`;
-        const hasRegisteredIndexingFunction = indexingFunctions[eventName] !== undefined;
-        if (!hasRegisteredIndexingFunction) {
+        let hasRegisteredIndexingFunction = false;
+        for (const filter of filters) {
+            const eventName = filter.type === "transaction"
+                ? filter.fromAddress === undefined
+                    ? `${source.name}:transaction:to`
+                    : `${source.name}:transaction:from`
+                : filter.fromAddress === undefined
+                    ? `${source.name}:transfer:to`
+                    : `${source.name}:transfer:from`;
+            const indexingFunction = indexingFunctions.find((f) => f.name === eventName);
+            if (indexingFunction) {
+                hasRegisteredIndexingFunction = true;
+                const eventCallback = {
+                    filter,
+                    name: eventName,
+                    fn: indexingFunction.fn,
+                    chain,
+                    type: "account",
+                    direction: filter.fromAddress === undefined ? "to" : "from",
+                };
+                perChainEventCallbacks.get(chain.id).push(eventCallback);
+            }
+        }
+        if (hasRegisteredIndexingFunction === false) {
             logs.push({
-                level: "debug",
+                level: "warn",
                 msg: "No registered indexing functions",
-                chain: source.chain.name,
-                chain_id: source.chain.id,
-                name: eventName,
-                type: source.filter.type,
+                name: source.name,
+                type: "account",
             });
         }
-        return hasRegisteredIndexingFunction;
-    });
-    const blockSources = (await Promise.all(flattenSources(config.blocks ?? {}).map(async (source) => {
+    }
+    for (const source of flattenSources(config.blocks ?? {})) {
         const chain = chains.find((n) => n.name === source.chain);
         const intervalMaybeNan = source.interval ?? 1;
         const interval = Number.isNaN(intervalMaybeNan) ? 0 : intervalMaybeNan;
@@ -632,50 +543,57 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
         }
         const fromBlock = await resolveBlockNumber(source.startBlock, chain);
         const toBlock = await resolveBlockNumber(source.endBlock, chain);
-        return {
-            type: "block",
-            name: source.name,
-            chain,
-            filter: {
+        const eventName = `${source.name}:block`;
+        const indexingFunction = indexingFunctions.find((f) => f.name === eventName);
+        if (indexingFunction) {
+            const filter = {
                 type: "block",
                 chainId: chain.id,
+                sourceId: source.name,
                 interval: interval,
                 offset: (fromBlock ?? 0) % interval,
                 fromBlock,
                 toBlock,
                 hasTransactionReceipt: false,
                 include: defaultBlockFilterInclude,
-            },
-        };
-    })))
-        .flat()
-        .filter((source) => {
-        const hasRegisteredIndexingFunction = indexingFunctions[`${source.name}:block`] !== undefined;
-        if (!hasRegisteredIndexingFunction) {
+            };
+            const eventCallback = {
+                filter,
+                name: eventName,
+                fn: indexingFunction.fn,
+                chain,
+                type: "block",
+            };
+            perChainEventCallbacks.get(chain.id).push(eventCallback);
+        }
+        else {
             logs.push({
                 level: "warn",
                 msg: "No registered indexing functions",
-                chain: source.chain.name,
-                chain_id: source.chain.id,
                 name: source.name,
                 type: "block",
             });
         }
-        return hasRegisteredIndexingFunction;
-    });
-    const sources = [...contractSources, ...accountSources, ...blockSources];
+    }
     // Filter out any chains that don't have any sources registered.
     const chainsWithSources = [];
     const rpcsWithSources = [];
     const finalizedBlocksWithSources = [];
+    const eventCallbacksWithSources = [];
+    const setupCallbacksWithSources = [];
+    const contractsWithSources = [];
     for (let i = 0; i < chains.length; i++) {
         const chain = chains[i];
         const rpc = rpcs[i];
-        const hasSources = sources.some((source) => source.chain.name === chain.name);
-        if (hasSources) {
+        const hasIndexingFunctions = perChainEventCallbacks.get(chain.id).length > 0 ||
+            perChainSetupCallbacks.get(chain.id).length > 0;
+        if (hasIndexingFunctions) {
             chainsWithSources.push(chain);
             rpcsWithSources.push(rpc);
             finalizedBlocksWithSources.push(finalizedBlocks[i]);
+            eventCallbacksWithSources.push(perChainEventCallbacks.get(chain.id));
+            setupCallbacksWithSources.push(perChainSetupCallbacks.get(chain.id));
+            contractsWithSources.push(perChainContracts.get(chain.id));
         }
         else {
             logs.push({
@@ -686,15 +604,16 @@ export async function buildIndexingFunctions({ common, config, rawIndexingFuncti
             });
         }
     }
-    if (Object.keys(indexingFunctions).length === 0) {
-        throw new Error("Validation failed: Found 0 registered indexing functions.");
+    if (chainsWithSources.length === 0) {
+        throw new Error("Validation failed: Found 0 chains with registered indexing functions.");
     }
     return {
         chains: chainsWithSources,
         rpcs: rpcsWithSources,
         finalizedBlocks: finalizedBlocksWithSources,
-        sources,
-        indexingFunctions,
+        eventCallbacks: eventCallbacksWithSources,
+        setupCallbacks: setupCallbacksWithSources,
+        contracts: contractsWithSources,
         logs,
     };
 }
@@ -773,21 +692,22 @@ export function buildConfig({ common, config, }) {
     }));
     return { chains, rpcs, logs };
 }
-export async function safeBuildIndexingFunctions({ common, config, rawIndexingFunctions, configBuild, }) {
+export async function safeBuildIndexingFunctions({ common, config, indexingFunctions, configBuild, }) {
     try {
         const result = await buildIndexingFunctions({
             common,
             config,
-            rawIndexingFunctions,
+            indexingFunctions,
             configBuild,
         });
         return {
             status: "success",
-            sources: result.sources,
             chains: result.chains,
             rpcs: result.rpcs,
             finalizedBlocks: result.finalizedBlocks,
-            indexingFunctions: result.indexingFunctions,
+            eventCallbacks: result.eventCallbacks,
+            setupCallbacks: result.setupCallbacks,
+            contracts: result.contracts,
             logs: result.logs,
         };
     }