ponder 0.8.23 → 0.8.25

package/dist/bin/ponder.js

@@ -6102,6 +6102,8 @@ var processSetupEvents = async (indexingService, {
       const source = sources.find(
         (s) => s.type === "contract" && s.name === contractName && s.filter.chainId === network.chainId
       );
+      if (source === void 0)
+        continue;
       if (indexingService.isKilled)
         return { status: "killed" };
       indexingService.eventCount[eventName]++;
@@ -6376,74 +6378,93 @@ var methods = {
 var createIndexingService = extend(create, methods);
 
 // src/sync/fragments.ts
-var getFragmentIds = (filter) => {
+var getFragments = (filter) => {
   switch (filter.type) {
     case "block":
-      return getBlockFilterFragmentId(filter);
+      return getBlockFilterFragment(filter);
     case "transaction":
-      return getTransactionFilterFragmentIds(filter);
+      return getTransactionFilterFragments(filter);
     case "trace":
-      return getTraceFilterFragmentIds(filter);
+      return getTraceFilterFragments(filter);
     case "log":
-      return getLogFilterFragmentIds(filter);
+      return getLogFilterFragments(filter);
     case "transfer":
-      return getTransferFilterFragmentIds(filter);
+      return getTransferFilterFragments(filter);
   }
 };
-var getAddressFragmentIds = (address) => {
+var getAddressFragments = (address) => {
   const fragments = [];
   if (isAddressFactory(address)) {
     for (const fragmentAddress of Array.isArray(address.address) ? address.address : [address.address]) {
-      const id = `${fragmentAddress}_${address.eventSelector}_${address.childAddressLocation}`;
-      fragments.push({ id, adjacent: [id] });
+      const fragment = {
+        address: fragmentAddress,
+        eventSelector: address.eventSelector,
+        childAddressLocation: address.childAddressLocation
+      };
+      fragments.push({
+        fragment,
+        adjacentIds: [
+          `${fragmentAddress}_${address.eventSelector}_${address.childAddressLocation}`
+        ]
+      });
     }
   } else {
     for (const fragmentAddress of Array.isArray(address) ? address : [address ?? null]) {
       fragments.push({
-        id: fragmentAddress,
-        adjacent: fragmentAddress ? [fragmentAddress, null] : [fragmentAddress]
+        fragment: fragmentAddress,
+        adjacentIds: fragmentAddress ? [fragmentAddress, null] : [fragmentAddress]
       });
     }
   }
   return fragments;
 };
-var getBlockFilterFragmentId = ({
+var getBlockFilterFragment = ({
   chainId,
   interval,
   offset
 }) => {
   return [
     {
-      id: `block_${chainId}_${interval}_${offset}`,
-      adjacent: [`block_${chainId}_${interval}_${offset}`]
+      fragment: {
+        type: "block",
+        chainId,
+        interval,
+        offset
+      },
+      adjacentIds: [`block_${chainId}_${interval}_${offset}`]
     }
   ];
 };
-var getTransactionFilterFragmentIds = ({
+var getTransactionFilterFragments = ({
   chainId,
   fromAddress,
   toAddress
 }) => {
   const fragments = [];
-  const fromAddressFragmentIds = getAddressFragmentIds(fromAddress);
-  const toAddressFragmentIds = getAddressFragmentIds(toAddress);
-  for (const fragmentFromAddress of fromAddressFragmentIds) {
-    for (const fragmentToAddress of toAddressFragmentIds) {
-      const id = `transaction_${chainId}_${fragmentFromAddress.id}_${fragmentToAddress.id}`;
-      const adjacent = [];
-      for (const adjacentFromAddress of fragmentFromAddress.adjacent) {
-        for (const adjacentToAddress of fragmentToAddress.adjacent) {
-          adjacent.push(
-            `transaction_${chainId}_${adjacentFromAddress}_${adjacentToAddress}`
+  const fromAddressFragments = getAddressFragments(fromAddress);
+  const toAddressFragments = getAddressFragments(toAddress);
+  for (const fromAddressFragment of fromAddressFragments) {
+    for (const toAddressFragment of toAddressFragments) {
+      const fragment = {
+        type: "transaction",
+        chainId,
+        fromAddress: fromAddressFragment.fragment,
+        toAddress: toAddressFragment.fragment
+      };
+      const adjacentIds = [];
+      for (const fromAddressAdjacentId of fromAddressFragment.adjacentIds) {
+        for (const toAddressAdjacentId of toAddressFragment.adjacentIds) {
+          adjacentIds.push(
+            `transaction_${chainId}_${fromAddressAdjacentId}_${toAddressAdjacentId}`
           );
         }
       }
-      fragments.push({ id, adjacent });
+      fragments.push({ fragment, adjacentIds });
     }
   }
   return fragments;
 };
-var getTraceFilterFragmentIds = ({
+var getTraceFilterFragments = ({
   chainId,
   fromAddress,
   toAddress,
@@ -6452,32 +6473,39 @@ var getTraceFilterFragmentIds = ({
   ...filter
 }) => {
   const fragments = [];
-  const fromAddressFragmentIds = getAddressFragmentIds(fromAddress);
-  const toAddressFragmentIds = getAddressFragmentIds(toAddress);
+  const fromAddressFragments = getAddressFragments(fromAddress);
+  const toAddressFragments = getAddressFragments(toAddress);
   const includeTransactionReceipts = shouldGetTransactionReceipt(filter);
-  for (const fragmentFromAddress of fromAddressFragmentIds) {
-    for (const fragmentToAddress of toAddressFragmentIds) {
+  for (const fromAddressFragment of fromAddressFragments) {
+    for (const toAddressFragment of toAddressFragments) {
       for (const fragmentFunctionSelector of Array.isArray(functionSelector) ? functionSelector : [functionSelector]) {
-        const id = `trace_${chainId}_${fragmentFromAddress.id}_${fragmentToAddress.id}_${fragmentFunctionSelector ?? null}_${includeTransactionReceipts ? 1 : 0}`;
-        const adjacent = [];
-        for (const adjacentFromAddress of fragmentFromAddress.adjacent) {
-          for (const adjacentToAddress of fragmentToAddress.adjacent) {
+        const fragment = {
+          type: "trace",
+          chainId,
+          fromAddress: fromAddressFragment.fragment,
+          toAddress: toAddressFragment.fragment,
+          functionSelector: fragmentFunctionSelector ?? null,
+          includeTransactionReceipts
+        };
+        const adjacentIds = [];
+        for (const fromAddressAdjacentId of fromAddressFragment.adjacentIds) {
+          for (const toAddressAdjacentId of toAddressFragment.adjacentIds) {
             for (const adjacentFunctionSelector of fragmentFunctionSelector ? [fragmentFunctionSelector, null] : [null]) {
               for (const adjacentTxr of includeTransactionReceipts ? [1] : [0, 1]) {
-                adjacent.push(
-                  `trace_${chainId}_${adjacentFromAddress}_${adjacentToAddress}_${adjacentFunctionSelector}_${adjacentTxr}`
+                adjacentIds.push(
+                  `trace_${chainId}_${fromAddressAdjacentId}_${toAddressAdjacentId}_${adjacentFunctionSelector}_${adjacentTxr}`
                 );
               }
             }
           }
         }
-        fragments.push({ id, adjacent });
+        fragments.push({ fragment, adjacentIds });
       }
     }
   }
   return fragments;
 };
-var getLogFilterFragmentIds = ({
+var getLogFilterFragments = ({
   chainId,
   address,
   topic0,
@@ -6487,23 +6515,32 @@ var getLogFilterFragmentIds = ({
   ...filter
 }) => {
   const fragments = [];
-  const addressFragmentIds = getAddressFragmentIds(address);
+  const addressFragments = getAddressFragments(address);
   const includeTransactionReceipts = shouldGetTransactionReceipt(filter);
-  for (const fragmentAddress of addressFragmentIds) {
+  for (const addressFragment of addressFragments) {
     for (const fragmentTopic0 of Array.isArray(topic0) ? topic0 : [topic0]) {
       for (const fragmentTopic1 of Array.isArray(topic1) ? topic1 : [topic1]) {
         for (const fragmentTopic2 of Array.isArray(topic2) ? topic2 : [topic2]) {
           for (const fragmentTopic3 of Array.isArray(topic3) ? topic3 : [topic3]) {
-            const id = `log_${chainId}_${fragmentAddress.id}_${fragmentTopic0 ?? null}_${fragmentTopic1 ?? null}_${fragmentTopic2 ?? null}_${fragmentTopic3 ?? null}_${includeTransactionReceipts ? 1 : 0}`;
-            const adjacent = [];
-            for (const adjacentAddress of fragmentAddress.adjacent) {
+            const fragment = {
+              type: "log",
+              chainId,
+              address: addressFragment.fragment,
+              topic0: fragmentTopic0 ?? null,
+              topic1: fragmentTopic1 ?? null,
+              topic2: fragmentTopic2 ?? null,
+              topic3: fragmentTopic3 ?? null,
+              includeTransactionReceipts
+            };
+            const adjacentIds = [];
+            for (const addressAdjacentId of addressFragment.adjacentIds) {
               for (const adjacentTopic0 of fragmentTopic0 ? [fragmentTopic0, null] : [null]) {
                 for (const adjacentTopic1 of fragmentTopic1 ? [fragmentTopic1, null] : [null]) {
                   for (const adjacentTopic2 of fragmentTopic2 ? [fragmentTopic2, null] : [null]) {
                     for (const adjacentTopic3 of fragmentTopic3 ? [fragmentTopic3, null] : [null]) {
                       for (const adjacentTxr of includeTransactionReceipts ? [1] : [0, 1]) {
-                        adjacent.push(
-                          `log_${chainId}_${adjacentAddress}_${adjacentTopic0}_${adjacentTopic1}_${adjacentTopic2}_${adjacentTopic3}_${adjacentTxr}`
+                        adjacentIds.push(
+                          `log_${chainId}_${addressAdjacentId}_${adjacentTopic0}_${adjacentTopic1}_${adjacentTopic2}_${adjacentTopic3}_${adjacentTxr}`
                         );
                       }
                     }
@@ -6511,7 +6548,7 @@ var getLogFilterFragmentIds = ({
                 }
               }
             }
-            fragments.push({ id, adjacent });
+            fragments.push({ fragment, adjacentIds });
           }
         }
       }
@@ -6519,149 +6556,197 @@ var getLogFilterFragmentIds = ({
   }
   return fragments;
 };
-var getTransferFilterFragmentIds = ({
+var getTransferFilterFragments = ({
   chainId,
   fromAddress,
   toAddress,
   ...filter
 }) => {
   const fragments = [];
-  const fromAddressFragmentIds = getAddressFragmentIds(fromAddress);
-  const toAddressFragmentIds = getAddressFragmentIds(toAddress);
+  const fromAddressFragments = getAddressFragments(fromAddress);
+  const toAddressFragments = getAddressFragments(toAddress);
   const includeTransactionReceipts = shouldGetTransactionReceipt(filter);
-  for (const fragmentFromAddress of fromAddressFragmentIds) {
-    for (const fragmentToAddress of toAddressFragmentIds) {
-      const id = `transfer_${chainId}_${fragmentFromAddress.id}_${fragmentToAddress.id}_${includeTransactionReceipts ? 1 : 0}`;
-      const adjacent = [];
-      for (const adjacentFromAddress of fragmentFromAddress.adjacent) {
-        for (const adjacentToAddress of fragmentToAddress.adjacent) {
+  for (const fromAddressFragment of fromAddressFragments) {
+    for (const toAddressFragment of toAddressFragments) {
+      const fragment = {
+        type: "transfer",
+        chainId,
+        fromAddress: fromAddressFragment.fragment,
+        toAddress: toAddressFragment.fragment,
+        includeTransactionReceipts
+      };
+      const adjacentIds = [];
+      for (const fromAddressAdjacentId of fromAddressFragment.adjacentIds) {
+        for (const toAddressAdjacentId of toAddressFragment.adjacentIds) {
           for (const adjacentTxr of includeTransactionReceipts ? [1] : [0, 1]) {
-            adjacent.push(
-              `transfer_${chainId}_${adjacentFromAddress}_${adjacentToAddress}_${adjacentTxr}`
+            adjacentIds.push(
+              `transfer_${chainId}_${fromAddressAdjacentId}_${toAddressAdjacentId}_${adjacentTxr}`
             );
           }
         }
       }
-      fragments.push({ id, adjacent });
+      fragments.push({ fragment, adjacentIds });
     }
   }
   return fragments;
 };
-
-// src/utils/range.ts
-var range = (start2, stop) => Array.from({ length: stop - start2 }, (_, i) => start2 + i);
-
-// src/utils/interval.ts
-function intervalSum(intervals) {
-  let totalSum = 0;
-  for (const [start2, end] of intervals) {
-    totalSum += end - start2 + 1;
+var fragmentAddressToId = (fragmentAddress) => {
+  if (fragmentAddress === null)
+    return null;
+  if (typeof fragmentAddress === "string")
+    return fragmentAddress;
+  return `${fragmentAddress.address}_${fragmentAddress.eventSelector}_${fragmentAddress.childAddressLocation}`;
+};
+var fragmentToId = (fragment) => {
+  switch (fragment.type) {
+    case "block":
+      return `block_${fragment.chainId}_${fragment.interval}_${fragment.offset}`;
+    case "transaction":
+      return `transaction_${fragment.chainId}_${fragmentAddressToId(fragment.fromAddress)}_${fragmentAddressToId(fragment.toAddress)}`;
+    case "trace":
+      return `trace_${fragment.chainId}_${fragmentAddressToId(fragment.fromAddress)}_${fragmentAddressToId(fragment.toAddress)}_${fragment.functionSelector}_${fragment.includeTransactionReceipts ? 1 : 0}`;
+    case "log":
+      return `log_${fragment.chainId}_${fragmentAddressToId(fragment.address)}_${fragment.topic0}_${fragment.topic1}_${fragment.topic2}_${fragment.topic3}_${fragment.includeTransactionReceipts ? 1 : 0}`;
+    case "transfer":
+      return `transfer_${fragment.chainId}_${fragmentAddressToId(fragment.fromAddress)}_${fragmentAddressToId(fragment.toAddress)}_${fragment.includeTransactionReceipts ? 1 : 0}`;
   }
-  return totalSum;
-}
-function intervalUnion(intervals_) {
-  if (intervals_.length === 0)
-    return [];
-  const intervals = intervals_.map((interval) => [...interval]);
-  intervals.sort((a, b) => a[0] - b[0]);
-  const result = [];
-  let currentInterval = intervals[0];
-  for (let i = 1; i < intervals.length; i++) {
-    const nextInterval = intervals[i];
-    if (currentInterval[1] >= nextInterval[0] - 1) {
-      currentInterval[1] = Math.max(currentInterval[1], nextInterval[1]);
-    } else {
-      result.push(currentInterval);
-      currentInterval = nextInterval;
+};
+var recoverAddress = (baseAddress, fragmentAddresses) => {
+  if (baseAddress === void 0)
+    return void 0;
+  if (typeof baseAddress === "string")
+    return baseAddress;
+  if (Array.isArray(baseAddress))
+    return dedupe(fragmentAddresses);
+  if (typeof baseAddress.address === "string")
+    return baseAddress;
+  const address = {
+    type: "log",
+    chainId: baseAddress.chainId,
+    address: [],
+    eventSelector: baseAddress.eventSelector,
+    childAddressLocation: baseAddress.childAddressLocation
+  };
+  address.address = dedupe(
+    fragmentAddresses.map(
+      ({ address: address2 }) => address2
+    )
+  );
+  return address;
+};
+var recoverSelector = (base, fragments) => {
+  if (base === void 0)
+    return void 0;
+  if (typeof base === "string")
+    return base;
+  return dedupe(fragments);
+};
+var recoverTopic = (base, fragments) => {
+  if (base === null)
+    return null;
+  if (typeof base === "string")
+    return base;
+  return dedupe(fragments);
+};
+var recoverFilter = (baseFilter, fragments) => {
+  switch (baseFilter.type) {
+    case "block": {
+      return baseFilter;
     }
-  }
-  result.push(currentInterval);
-  return result;
-}
-function intervalIntersection(list1, list2) {
-  const result = [];
-  let i = 0;
-  let j = 0;
-  while (i < list1.length && j < list2.length) {
-    const [start1, end1] = list1[i];
-    const [start2, end2] = list2[j];
-    const intersectionStart = Math.max(start1, start2);
-    const intersectionEnd = Math.min(end1, end2);
-    if (intersectionStart <= intersectionEnd) {
-      result.push([intersectionStart, intersectionEnd]);
+    case "transaction": {
+      return {
+        ...baseFilter,
+        fromAddress: recoverAddress(
+          baseFilter.fromAddress,
+          fragments.map(
+            (fragment) => fragment.fromAddress
+          )
+        ),
+        toAddress: recoverAddress(
+          baseFilter.toAddress,
+          fragments.map(
+            (fragment) => fragment.toAddress
+          )
+        )
+      };
     }
-    if (end1 < end2) {
-      i++;
-    } else {
-      j++;
+    case "trace": {
+      return {
+        ...baseFilter,
+        fromAddress: recoverAddress(
+          baseFilter.fromAddress,
+          fragments.map(
+            (fragment) => fragment.fromAddress
+          )
+        ),
+        toAddress: recoverAddress(
+          baseFilter.toAddress,
+          fragments.map(
+            (fragment) => fragment.toAddress
+          )
+        ),
+        functionSelector: recoverSelector(
+          baseFilter.functionSelector,
+          fragments.map(
+            (fragment) => fragment.functionSelector
+          )
+        )
+      };
     }
-  }
-  return intervalUnion(result);
-}
-function intervalIntersectionMany(lists) {
-  if (lists.length === 0)
-    return [];
-  if (lists.length === 1)
-    return lists[0];
-  let result = lists[0];
-  for (let i = 1; i < lists.length; i++) {
-    result = intervalIntersection(result, lists[i]);
-  }
-  return intervalUnion(result);
-}
-function intervalDifference(initial, remove) {
-  const initial_ = initial.map((interval) => [...interval]);
-  const remove_ = remove.map((interval) => [...interval]);
-  const result = [];
-  let i = 0;
-  let j = 0;
-  while (i < initial.length && j < remove.length) {
-    const interval1 = initial_[i];
-    const interval2 = remove_[j];
-    if (interval1[1] < interval2[0]) {
-      result.push(interval1);
-      i++;
-    } else if (interval2[1] < interval1[0]) {
-      j++;
-    } else {
-      if (interval1[0] < interval2[0]) {
-        result.push([interval1[0], interval2[0] - 1]);
-      }
-      if (interval1[1] > interval2[1]) {
-        interval1[0] = interval2[1] + 1;
-        j++;
-      } else {
-        i++;
-      }
+    case "log": {
+      return {
+        ...baseFilter,
+        address: recoverAddress(
+          baseFilter.address,
+          fragments.map(
+            (fragment) => fragment.address
+          )
+        ),
+        topic0: recoverTopic(
+          baseFilter.topic0,
+          fragments.map(
+            (fragment) => fragment.topic0
+          )
+        ),
+        topic1: recoverTopic(
+          baseFilter.topic1,
+          fragments.map(
+            (fragment) => fragment.topic1
+          )
+        ),
+        topic2: recoverTopic(
+          baseFilter.topic2,
+          fragments.map(
+            (fragment) => fragment.topic2
+          )
+        ),
+        topic3: recoverTopic(
+          baseFilter.topic3,
+          fragments.map(
+            (fragment) => fragment.topic3
+          )
+        )
+      };
+    }
+    case "transfer": {
+      return {
+        ...baseFilter,
+        fromAddress: recoverAddress(
+          baseFilter.fromAddress,
+          fragments.map(
+            (fragment) => fragment.fromAddress
+          )
+        ),
+        toAddress: recoverAddress(
+          baseFilter.toAddress,
+          fragments.map(
+            (fragment) => fragment.toAddress
+          )
+        )
+      };
     }
   }
-  while (i < initial_.length) {
-    result.push(initial_[i]);
-    i++;
-  }
-  return result;
-}
-function sortIntervals(intervals) {
-  return intervals.sort((a, b) => a[0] < b[0] ? -1 : 1);
-}
-function getChunks({
-  interval,
-  maxChunkSize
-}) {
-  const _chunks = [];
-  const [startBlock, endBlock] = interval;
-  let fromBlock = startBlock;
-  let toBlock = Math.min(fromBlock + maxChunkSize - 1, endBlock);
-  while (fromBlock <= endBlock) {
-    _chunks.push([fromBlock, toBlock]);
-    fromBlock = toBlock + 1;
-    toBlock = Math.min(fromBlock + maxChunkSize - 1, endBlock);
-  }
-  return _chunks;
-}
-function intervalRange(interval) {
-  return range(interval[0], interval[1] + 1);
-}
+};
 
 // src/sync-store/index.ts
 import { sql as ksql } from "kysely";
@@ -6864,11 +6949,12 @@ var createSyncStore = ({
       const perFragmentIntervals = /* @__PURE__ */ new Map();
       const values = [];
       for (const { filter, interval } of intervals) {
-        for (const fragment of getFragmentIds(filter)) {
-          if (perFragmentIntervals.has(fragment.id) === false) {
-            perFragmentIntervals.set(fragment.id, []);
+        for (const fragment of getFragments(filter)) {
+          const fragmentId = fragmentToId(fragment.fragment);
+          if (perFragmentIntervals.has(fragmentId) === false) {
+            perFragmentIntervals.set(fragmentId, []);
           }
-          perFragmentIntervals.get(fragment.id).push(interval);
+          perFragmentIntervals.get(fragmentId).push(interval);
         }
       }
       for (const [fragmentId, intervals2] of perFragmentIntervals) {
@@ -6894,13 +6980,15 @@ var createSyncStore = ({
     let query2;
     for (let i = 0; i < filters.length; i++) {
       const filter = filters[i];
-      const fragments = getFragmentIds(filter);
-      for (const fragment of fragments) {
+      const fragments = getFragments(filter);
+      for (let j = 0; j < fragments.length; j++) {
+        const fragment = fragments[j];
         const _query = db.selectFrom(
-          db.selectFrom("intervals").select(ksql`unnest(blocks)`.as("blocks")).where("fragment_id", "in", fragment.adjacent).as("unnested")
+          db.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(`'${i}'`).as("filter"),
+          ksql.raw(`'${j}'`).as("fragment")
         ]);
         query2 = query2 === void 0 ? _query : query2.unionAll(_query);
       }
@@ -6909,12 +6997,17 @@ var createSyncStore = ({
     const result = /* @__PURE__ */ new Map();
     for (let i = 0; i < filters.length; i++) {
       const filter = filters[i];
-      const intervals = rows.filter((row) => row.filter === `${i}`).map(
-        (row) => (row.merged_blocks ? JSON.parse(
-          `[${row.merged_blocks.slice(1, -1)}]`
-        ) : []).map((interval) => [interval[0], interval[1] - 1])
-      );
-      result.set(filter, intervalIntersectionMany(intervals));
+      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;
   }),
@@ -8236,6 +8329,126 @@ var convertTrace = (trace) => ({
   subcalls: trace.trace.subcalls
 });
 
+// src/utils/range.ts
+var range = (start2, stop) => Array.from({ length: stop - start2 }, (_, i) => start2 + i);
+
+// src/utils/interval.ts
+function intervalSum(intervals) {
+  let totalSum = 0;
+  for (const [start2, end] of intervals) {
+    totalSum += end - start2 + 1;
+  }
+  return totalSum;
+}
+function intervalUnion(intervals_) {
+  if (intervals_.length === 0)
+    return [];
+  const intervals = intervals_.map((interval) => [...interval]);
+  intervals.sort((a, b) => a[0] - b[0]);
+  const result = [];
+  let currentInterval = intervals[0];
+  for (let i = 1; i < intervals.length; i++) {
+    const nextInterval = intervals[i];
+    if (currentInterval[1] >= nextInterval[0] - 1) {
+      currentInterval[1] = Math.max(currentInterval[1], nextInterval[1]);
+    } else {
+      result.push(currentInterval);
+      currentInterval = nextInterval;
+    }
+  }
+  result.push(currentInterval);
+  return result;
+}
+function intervalIntersection(list1, list2) {
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < list1.length && j < list2.length) {
+    const [start1, end1] = list1[i];
+    const [start2, end2] = list2[j];
+    const intersectionStart = Math.max(start1, start2);
+    const intersectionEnd = Math.min(end1, end2);
+    if (intersectionStart <= intersectionEnd) {
+      result.push([intersectionStart, intersectionEnd]);
+    }
+    if (end1 < end2) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return intervalUnion(result);
+}
+function intervalIntersectionMany(lists) {
+  if (lists.length === 0)
+    return [];
+  if (lists.length === 1)
+    return lists[0];
+  let result = lists[0];
+  for (let i = 1; i < lists.length; i++) {
+    result = intervalIntersection(result, lists[i]);
+  }
+  return intervalUnion(result);
+}
+function intervalDifference(initial, remove) {
+  const initial_ = initial.map((interval) => [...interval]);
+  const remove_ = remove.map((interval) => [...interval]);
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < initial.length && j < remove.length) {
+    const interval1 = initial_[i];
+    const interval2 = remove_[j];
+    if (interval1[1] < interval2[0]) {
+      result.push(interval1);
+      i++;
+    } else if (interval2[1] < interval1[0]) {
+      j++;
+    } else {
+      if (interval1[0] < interval2[0]) {
+        result.push([interval1[0], interval2[0] - 1]);
+      }
+      if (interval1[1] > interval2[1]) {
+        interval1[0] = interval2[1] + 1;
+        j++;
+      } else {
+        i++;
+      }
+    }
+  }
+  while (i < initial_.length) {
+    result.push(initial_[i]);
+    i++;
+  }
+  return result;
+}
+function intervalBounds(intervals) {
+  const start2 = Math.min(...intervals.map((interval) => interval[0]));
+  const end = Math.max(...intervals.map((interval) => interval[1]));
+  return [start2, end];
+}
+function sortIntervals(intervals) {
+  return intervals.sort((a, b) => a[0] < b[0] ? -1 : 1);
+}
+function getChunks({
+  interval,
+  maxChunkSize
+}) {
+  const _chunks = [];
+  const [startBlock, endBlock] = interval;
+  let fromBlock = startBlock;
+  let toBlock = Math.min(fromBlock + maxChunkSize - 1, endBlock);
+  while (fromBlock <= endBlock) {
+    _chunks.push([fromBlock, toBlock]);
+    fromBlock = toBlock + 1;
+    toBlock = Math.min(fromBlock + maxChunkSize - 1, endBlock);
+  }
+  return _chunks;
+}
+function intervalRange(interval) {
+  return range(interval[0], interval[1] + 1);
+}
+
 // src/utils/rpc.ts
 import {
   BlockNotFoundError,
@@ -8823,51 +9036,75 @@ var createHistoricalSync = async (args) => {
   return {
     intervalsCache,
     async sync(_interval) {
-      const syncedIntervals = [];
-      await Promise.all(
-        args.sources.map(async (source) => {
-          const filter = source.filter;
-          if (filter.fromBlock !== void 0 && filter.fromBlock > _interval[1] || filter.toBlock !== void 0 && filter.toBlock < _interval[0]) {
-            return;
-          }
-          const interval = [
-            Math.max(filter.fromBlock ?? 0, _interval[0]),
-            Math.min(filter.toBlock ?? Number.POSITIVE_INFINITY, _interval[1])
-          ];
-          const completedIntervals = intervalsCache.get(filter);
-          const requiredIntervals = intervalDifference(
+      const intervalsToSync = [];
+      for (const { filter } of args.sources) {
+        if (filter.fromBlock !== void 0 && filter.fromBlock > _interval[1] || filter.toBlock !== void 0 && filter.toBlock < _interval[0]) {
+          continue;
+        }
+        const interval = [
+          Math.max(filter.fromBlock ?? 0, _interval[0]),
+          Math.min(filter.toBlock ?? Number.POSITIVE_INFINITY, _interval[1])
+        ];
+        const completedIntervals = intervalsCache.get(filter);
+        const requiredIntervals = [];
+        for (const {
+          fragment,
+          intervals: fragmentIntervals
+        } of completedIntervals) {
+          const requiredFragmentIntervals = intervalDifference(
             [interval],
-            completedIntervals
+            fragmentIntervals
           );
-          if (requiredIntervals.length === 0)
-            return;
+          if (requiredFragmentIntervals.length > 0) {
+            requiredIntervals.push({
+              fragment,
+              intervals: requiredFragmentIntervals
+            });
+          }
+        }
+        if (requiredIntervals.length > 0) {
+          const requiredInterval = intervalBounds(
+            requiredIntervals.flatMap(({ intervals }) => intervals)
+          );
+          const requiredFilter = recoverFilter(
+            filter,
+            requiredIntervals.map(({ fragment }) => fragment)
+          );
+          intervalsToSync.push({
+            filter: requiredFilter,
+            interval: requiredInterval
+          });
+        }
+      }
+      await Promise.all(
+        intervalsToSync.map(async ({ filter, interval }) => {
           const blockPromise = syncBlock(interval[1]);
           try {
-            await Promise.all(
-              requiredIntervals.map(async (interval2) => {
-                switch (filter.type) {
-                  case "log": {
-                    await syncLogFilter(filter, interval2);
-                    break;
-                  }
-                  case "block": {
-                    await syncBlockFilter(filter, interval2);
-                    break;
-                  }
-                  case "transaction": {
-                    await syncTransactionFilter(filter, interval2);
-                    break;
-                  }
-                  case "trace":
-                  case "transfer": {
-                    await syncTraceOrTransferFilter(filter, interval2);
-                    break;
-                  }
-                  default:
-                    never(filter);
-                }
-              })
-            );
+            switch (filter.type) {
+              case "log": {
+                await syncLogFilter(filter, interval);
+                break;
+              }
+              case "block": {
+                await syncBlockFilter(filter, interval);
+                break;
+              }
+              case "transaction": {
+                await syncTransactionFilter(
+                  filter,
+                  interval
+                );
+                break;
+              }
+              case "trace":
+              case "transfer": {
+                await syncTraceOrTransferFilter(
+                  filter,
+                  interval
+                );
+                break;
+              }
+            }
           } catch (_error) {
             const error = _error;
             args.common.logger.error({
@@ -8881,9 +9118,10 @@ var createHistoricalSync = async (args) => {
           if (isKilled)
             return;
           await blockPromise;
-          syncedIntervals.push({ filter, interval });
         })
       );
+      if (isKilled)
+        return;
       const blocks = await Promise.all(blockCache.values());
       await Promise.all([
         args.syncStore.insertBlocks({ blocks, chainId: args.network.chainId }),
@@ -8897,9 +9135,11 @@ var createHistoricalSync = async (args) => {
           chainId: args.network.chainId
         })
       ]);
+      if (isKilled)
+        return;
       if (args.network.disableCache === false) {
         await args.syncStore.insertIntervals({
-          intervals: syncedIntervals,
+          intervals: intervalsToSync,
           chainId: args.network.chainId
         });
       }
@@ -10606,9 +10846,14 @@ var getCachedBlock = ({
       filter.fromBlock ?? 0,
       filter.toBlock ?? Number.POSITIVE_INFINITY
     ];
-    const cachedIntervals = historicalSync.intervalsCache.get(filter);
+    const fragmentIntervals = historicalSync.intervalsCache.get(filter);
     const completedIntervals = sortIntervals(
-      intervalIntersection([requiredInterval], cachedIntervals)
+      intervalIntersection(
+        [requiredInterval],
+        intervalIntersectionMany(
+          fragmentIntervals.map(({ intervals }) => intervals)
+        )
+      )
     );
     if (completedIntervals.length === 0)
       return void 0;
@@ -10664,7 +10909,7 @@ async function* localHistoricalSyncGenerator({
   const requiredIntervals = Array.from(
     historicalSync.intervalsCache.entries()
   ).flatMap(
-    ([filter, interval]) => intervalDifference(
+    ([filter, fragmentIntervals]) => intervalDifference(
       [
         [
           filter.fromBlock ?? 0,
@@ -10674,7 +10919,9 @@ async function* localHistoricalSyncGenerator({
           )
         ]
       ],
-      interval
+      intervalIntersectionMany(
+        fragmentIntervals.map(({ intervals }) => intervals)
+      )
     )
   );
   const required = intervalSum(intervalUnion(requiredIntervals));