ponder 0.18.0 → 0.18.1

package/src/runtime/filter.ts

@@ -260,14 +260,8 @@ export const isAddressMatched = ({
   childAddresses: Map<Address, number>;
 }) => {
   if (address === undefined) return false;
-  if (
-    childAddresses.has(toLowerCase(address)) &&
-    childAddresses.get(toLowerCase(address))! <= blockNumber
-  ) {
-    return true;
-  }
-
-  return false;
+  const childBlockNumber = childAddresses.get(toLowerCase(address));
+  return childBlockNumber !== undefined && childBlockNumber <= blockNumber;
 };
 
 const isValueMatched = <T extends string>(
@@ -280,18 +274,18 @@ const isValueMatched = <T extends string>(
   // missing value
   if (eventValue === undefined) return false;
 
+  // Note: `filterValue` is lowercase, so an exact match avoids allocating
+  // a lowercase copy of `eventValue`.
+  if (filterValue === eventValue) return true;
+
+  const value = toLowerCase(eventValue);
+
   // array
-  if (
-    Array.isArray(filterValue) &&
-    filterValue.some((v) => v === toLowerCase(eventValue))
-  ) {
-    return true;
-  }
+  if (Array.isArray(filterValue))
+    return (filterValue as string[]).includes(value);
 
   // single
-  if (filterValue === toLowerCase(eventValue)) return true;
-
-  return false;
+  return filterValue === value;
 };
 
 /**

package/src/sync-realtime/bloom.ts

@@ -1,5 +1,5 @@
-import { type Hex, hexToBytes, hexToNumber, keccak256 } from "viem";
-import type { LogFilter, SyncBlock } from "@/internal/types.js";
+import { type Hex, keccak256 } from "viem";
+import type { LogFilter } from "@/internal/types.js";
 import {
   getFilterFromBlock,
   getFilterToBlock,
@@ -11,21 +11,105 @@ export const zeroLogsBloom =
 
 const BLOOM_SIZE_BYTES = 256;
 
-export const isInBloom = (_bloom: Hex, input: Hex): boolean => {
-  const bloom = hexToBytes(_bloom);
-  const hash = hexToBytes(keccak256(input));
-
-  for (const i of [0, 2, 4]) {
-    const bit = (hash[i + 1]! + (hash[i]! << 8)) & 0x7ff;
-    if (
-      (bloom[BLOOM_SIZE_BYTES - 1 - Math.floor(bit / 8)]! &
-        (1 << (bit % 8))) ===
-      0
-    )
-      return false;
+export type BloomBits = {
+  byte0: number;
+  mask0: number;
+  byte1: number;
+  mask1: number;
+  byte2: number;
+  mask2: number;
+};
+
+/**
+ * A `LogFilter` with each address and topic converted to `BloomBits`.
+ *
+ * `undefined` matches every bloom. An array matches if any item is in the bloom.
+ */
+export type LogFilterBloom = {
+  fromBlock: number;
+  toBlock: number;
+  address: BloomBits[] | undefined;
+  topics: (BloomBits[] | undefined)[];
+  factory:
+    | { address: BloomBits[] | undefined; eventSelector: BloomBits }
+    | undefined;
+};
+
+export const getBloomBits = (input: Hex): BloomBits => {
+  const hash = keccak256(input, "bytes");
+  const bytes = [0, 0, 0];
+  const masks = [0, 0, 0];
+
+  for (let i = 0; i < 3; i++) {
+    const bit = (hash[i * 2 + 1]! + (hash[i * 2]! << 8)) & 0x7ff;
+    bytes[i] = BLOOM_SIZE_BYTES - 1 - Math.floor(bit / 8);
+    masks[i] = 1 << (bit % 8);
+  }
+
+  return {
+    byte0: bytes[0]!,
+    mask0: masks[0]!,
+    byte1: bytes[1]!,
+    mask1: masks[1]!,
+    byte2: bytes[2]!,
+    mask2: masks[2]!,
+  };
+};
+
+export const isBloomBitsInBloom = (
+  bloom: Uint8Array,
+  bits: BloomBits,
+): boolean =>
+  (bloom[bits.byte0]! & bits.mask0) !== 0 &&
+  (bloom[bits.byte1]! & bits.mask1) !== 0 &&
+  (bloom[bits.byte2]! & bits.mask2) !== 0;
+
+export const isInBloom = (bloom: Uint8Array, input: Hex): boolean =>
+  isBloomBitsInBloom(bloom, getBloomBits(input));
+
+const isAnyInBloom = (
+  bloom: Uint8Array,
+  bits: BloomBits[] | undefined,
+): boolean =>
+  bits === undefined || bits.some((b) => isBloomBitsInBloom(bloom, b));
+
+const toBloomBits = (
+  input: Hex | Hex[] | null | undefined,
+): BloomBits[] | undefined => {
+  if (input === null || input === undefined) return undefined;
+  if (Array.isArray(input)) return input.map(getBloomBits);
+  return [getBloomBits(input)];
+};
+
+/**
+ * Convert `filter` to a `LogFilterBloom`. Call once for each filter,
+ * so that the inputs are not hashed again for each block.
+ */
+export const getLogFilterBloom = (filter: LogFilter): LogFilterBloom => {
+  let address: BloomBits[] | undefined;
+  let factory: LogFilterBloom["factory"];
+
+  if (isAddressFactory(filter.address)) {
+    address = undefined;
+    factory = {
+      address: toBloomBits(filter.address.address),
+      eventSelector: getBloomBits(filter.address.eventSelector),
+    };
+  } else if (Array.isArray(filter.address) && filter.address.length === 0) {
+    address = undefined;
+  } else {
+    address = toBloomBits(filter.address);
   }
 
-  return true;
+  return {
+    fromBlock: getFilterFromBlock(filter),
+    toBlock: getFilterToBlock(filter),
+    address,
+    topics: [filter.topic0, filter.topic1, filter.topic2, filter.topic3].map(
+      toBloomBits,
+    ),
+    factory,
+  };
 };
 
 /**
@@ -38,65 +122,30 @@ export const isInBloom = (_bloom: Hex, input: Hex): boolean => {
  * Note: False positives are possible.
  */
 export function isFilterInBloom({
-  block,
+  blockNumber,
+  bloom,
   filter,
 }: {
-  block: Pick<SyncBlock, "number" | "logsBloom">;
-  filter: LogFilter;
+  blockNumber: number;
+  bloom: Uint8Array;
+  filter: LogFilterBloom;
 }): boolean {
   // Return `false` for out of range blocks
-  if (
-    hexToNumber(block.number) < getFilterFromBlock(filter) ||
-    hexToNumber(block.number) > getFilterToBlock(filter)
-  ) {
+  if (blockNumber < filter.fromBlock || blockNumber > filter.toBlock) {
     return false;
   }
 
-  const isTopicsInBloom = [
-    filter.topic0,
-    filter.topic1,
-    filter.topic2,
-    filter.topic3,
-  ].every((topic) => {
-    if (topic === null || topic === undefined) {
-      return true;
-    } else if (Array.isArray(topic)) {
-      return topic.some((t) => isInBloom(block.logsBloom, t));
-    } else {
-      return isInBloom(block.logsBloom, topic);
-    }
-  });
-
-  let isAddressInBloom: boolean;
-
-  if (filter.address === undefined) isAddressInBloom = true;
-  else if (isAddressFactory(filter.address)) {
-    // Return true if the `Factory` is matched.
-    if (
-      (filter.address.address === undefined ||
-        (Array.isArray(filter.address.address)
-          ? filter.address.address.some((address) =>
-              isInBloom(block.logsBloom, address),
-            )
-          : isInBloom(block.logsBloom, filter.address.address))) &&
-      isInBloom(block.logsBloom, filter.address.eventSelector)
-    ) {
-      return true;
-    }
-
-    isAddressInBloom = true;
-  } else if (Array.isArray(filter.address)) {
-    if (filter.address.length === 0) {
-      isAddressInBloom = true;
-    } else {
-      isAddressInBloom = filter.address.some((address) =>
-        isInBloom(block.logsBloom, address),
-      );
-    }
-  } else {
-    // single address case
-    isAddressInBloom = isInBloom(block.logsBloom, filter.address);
+  // Return true if the `Factory` is matched.
+  if (
+    filter.factory !== undefined &&
+    isAnyInBloom(bloom, filter.factory.address) &&
+    isBloomBitsInBloom(bloom, filter.factory.eventSelector)
+  ) {
+    return true;
   }
 
-  return isAddressInBloom && isTopicsInBloom;
+  return (
+    isAnyInBloom(bloom, filter.address) &&
+    filter.topics.every((topic) => isAnyInBloom(bloom, topic))
+  );
 }

package/src/sync-realtime/index.ts

@@ -1,6 +1,8 @@
 import {
   type Address,
   type Hash,
+  type Hex,
+  hexToBytes,
   hexToNumber,
   numberToHex,
   zeroHash,
@@ -60,7 +62,12 @@ import { isAsyncExecutionChain } from "@/utils/finality.js";
 import { createLock } from "@/utils/mutex.js";
 import { range } from "@/utils/range.js";
 import { startClock } from "@/utils/timer.js";
-import { isFilterInBloom, isInBloom, zeroLogsBloom } from "./bloom.js";
+import {
+  getLogFilterBloom,
+  isFilterInBloom,
+  isInBloom,
+  zeroLogsBloom,
+} from "./bloom.js";
 
 export type RealtimeSync = {
   /**
@@ -176,6 +183,8 @@ export const createRealtimeSync = (
     }
   }
 
+  const logFilterBlooms = logFilters.map(getLogFilterBloom);
+
   const getLatestUnfinalizedBlock = () => {
     if (unfinalizedBlocks.length === 0) {
       return finalizedBlock;
@@ -214,12 +223,18 @@ export const createRealtimeSync = (
     // "eth_getLogs" calls can be skipped if no filters match `newHeadBlock.logsBloom`.
     // Async-execution chains cannot reliably use blooms to filter or validate logs.
     const isAsyncExecution = isAsyncExecutionChain(args.chain.id);
-    const shouldRequestLogs = isAsyncExecution
-      ? logFilters.length > 0
-      : maybeBlockHeader.logsBloom === zeroLogsBloom ||
-        logFilters.some((filter) =>
-          isFilterInBloom({ block: maybeBlockHeader, filter }),
-        );
+    let shouldRequestLogs: boolean;
+    if (isAsyncExecution) {
+      shouldRequestLogs = logFilters.length > 0;
+    } else if (maybeBlockHeader.logsBloom === zeroLogsBloom) {
+      shouldRequestLogs = true;
+    } else {
+      const blockNumber = hexToNumber(maybeBlockHeader.number);
+      const bloom = hexToBytes(maybeBlockHeader.logsBloom);
+      shouldRequestLogs = logFilterBlooms.some((filter) =>
+        isFilterInBloom({ blockNumber, bloom, filter }),
+      );
+    }
 
     let logs: SyncLog[] = [];
     if (shouldRequestLogs) {
@@ -259,57 +274,6 @@ export const createRealtimeSync = (
         isAsyncExecutionChain(args.chain.id),
       );
 
-      if (isAsyncExecutionChain(args.chain.id) === false) {
-        // Note: Exact `logsBloom` validations were considered too strict to add to `validateLogsAndBlock`.
-        let isInvalidLogsBloom = false;
-        for (const log of logs) {
-          if (isInBloom(block.logsBloom, log.address) === false) {
-            isInvalidLogsBloom = true;
-          }
-
-          if (
-            log.topics[0] &&
-            isInBloom(block.logsBloom, log.topics[0]) === false
-          ) {
-            isInvalidLogsBloom = true;
-          }
-
-          if (
-            log.topics[1] &&
-            isInBloom(block.logsBloom, log.topics[1]) === false
-          ) {
-            isInvalidLogsBloom = true;
-          }
-
-          if (
-            log.topics[2] &&
-            isInBloom(block.logsBloom, log.topics[2]) === false
-          ) {
-            isInvalidLogsBloom = true;
-          }
-
-          if (
-            log.topics[3] &&
-            isInBloom(block.logsBloom, log.topics[3]) === false
-          ) {
-            isInvalidLogsBloom = true;
-          }
-
-          if (isInvalidLogsBloom) {
-            args.common.logger.warn({
-              msg: "Detected inconsistent RPC responses. Log not found in block.logsBloom.",
-              action: "fetch_block_data",
-              chain: args.chain.name,
-              chain_id: args.chain.id,
-              number: hexToNumber(block.number),
-              hash: block.hash,
-              logIndex: hexToNumber(log.logIndex),
-            });
-            break;
-          }
-        }
-      }
-
       for (const log of logs) {
         if (log.transactionHash === zeroHash) {
           args.common.logger.warn({
@@ -387,6 +351,7 @@ export const createRealtimeSync = (
 
     // Record `blockChildAddresses` that contain factory child addresses
     const blockChildAddresses: BlockWithEventData["childAddresses"] = new Map();
+    const factoryLogs = new Set<SyncLog>();
 
     const childAddressDecodeFailureIds = new Set<string>();
     let childAddressDecodeFailureCount = 0;
@@ -395,6 +360,7 @@ export const createRealtimeSync = (
     for (const factory of factories) {
       for (const log of logs) {
         if (isLogFactoryMatched({ factory, log })) {
+          factoryLogs.add(log);
           let address: Address;
           try {
             address = getChildAddress({ log, factory });
@@ -462,6 +428,69 @@ export const createRealtimeSync = (
       return isMatched;
     });
 
+    if (isAsyncExecution === false && block !== undefined) {
+      // Note: Exact `logsBloom` validations were considered too strict to add to `validateLogsAndBlock`.
+      const logsBloom = hexToBytes(block.logsBloom);
+      const checkedInputs = new Set<Hex>();
+      let isInvalidLogsBloom = false;
+      for (const log of [...factoryLogs, ...logs]) {
+        if (
+          checkedInputs.has(log.address) === false &&
+          isInBloom(logsBloom, log.address) === false
+        ) {
+          isInvalidLogsBloom = true;
+        }
+
+        if (
+          log.topics[0] &&
+          checkedInputs.has(log.topics[0]) === false &&
+          isInBloom(logsBloom, log.topics[0]) === false
+        ) {
+          isInvalidLogsBloom = true;
+        }
+
+        if (
+          log.topics[1] &&
+          checkedInputs.has(log.topics[1]) === false &&
+          isInBloom(logsBloom, log.topics[1]) === false
+        ) {
+          isInvalidLogsBloom = true;
+        }
+
+        if (
+          log.topics[2] &&
+          checkedInputs.has(log.topics[2]) === false &&
+          isInBloom(logsBloom, log.topics[2]) === false
+        ) {
+          isInvalidLogsBloom = true;
+        }
+
+        if (
+          log.topics[3] &&
+          checkedInputs.has(log.topics[3]) === false &&
+          isInBloom(logsBloom, log.topics[3]) === false
+        ) {
+          isInvalidLogsBloom = true;
+        }
+
+        if (isInvalidLogsBloom) {
+          args.common.logger.warn({
+            msg: "Detected inconsistent RPC responses. Log not found in block.logsBloom.",
+            action: "fetch_block_data",
+            chain: args.chain.name,
+            chain_id: args.chain.id,
+            number: hexToNumber(block.number),
+            hash: block.hash,
+            logIndex: hexToNumber(log.logIndex),
+          });
+          break;
+        }
+
+        checkedInputs.add(log.address);
+        for (const topic of log.topics) checkedInputs.add(topic);
+      }
+    }
+
     // Initial weak trace filtering before full filtering with factory addresses in handleBlock
     traces = traces.filter((trace) => {
       let isMatched = false;

package/src/utils/copy.ts

@@ -5,75 +5,94 @@ import util from "node:util";
  */
 export const COPY_ON_WRITE = Symbol.for("ponder:copyOnWrite");
 
-const copyOnWriteCopies = new WeakMap<object, object>();
+/**
+ * Target of a copy-on-write proxy.
+ *
+ * Note: The handler is shared by all proxies, so the state of each proxy
+ * is stored in its target.
+ */
+class CopyOnWriteTarget {
+  obj: object;
+  copiedObject: object | undefined;
+
+  constructor(obj: object) {
+    this.obj = obj;
+    this.copiedObject = undefined;
+  }
 
-function inspectCopyOnWrite(this: object) {
-  return copyOnWriteCopies.get(this) ?? (this as any)[COPY_ON_WRITE] ?? this;
+  // Note: `this` is the proxy when called by `util.inspect`.
+  [util.inspect.custom]() {
+    // @ts-expect-error
+    return this[COPY_ON_WRITE] ?? this.copiedObject ?? this.obj;
+  }
 }
 
+const getCopiedObject = (target: CopyOnWriteTarget) => {
+  if (target.copiedObject === undefined) {
+    target.copiedObject = structuredClone(target.obj);
+  }
+  return target.copiedObject;
+};
+
+const copyOnWriteHandler: ProxyHandler<CopyOnWriteTarget> = {
+  get(target, prop, receiver) {
+    if (prop === COPY_ON_WRITE) {
+      return target.copiedObject ?? target.obj;
+    }
+    let result = Reflect.get(target.copiedObject ?? target.obj, prop, receiver);
+
+    if (
+      typeof result === "object" &&
+      result !== null &&
+      target.copiedObject === undefined
+    ) {
+      result = Reflect.get(getCopiedObject(target), prop, receiver);
+    }
+
+    return result;
+  },
+  set(target, prop, newValue, receiver) {
+    return Reflect.set(getCopiedObject(target), prop, newValue, receiver);
+  },
+  deleteProperty(target, prop) {
+    return Reflect.deleteProperty(getCopiedObject(target), prop);
+  },
+  defineProperty(target, prop, descriptor) {
+    return Reflect.defineProperty(getCopiedObject(target), prop, descriptor);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target.copiedObject ?? target.obj);
+  },
+  has(target, prop) {
+    return Reflect.has(target.copiedObject ?? target.obj, prop);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    return Reflect.getOwnPropertyDescriptor(
+      target.copiedObject ?? target.obj,
+      prop,
+    );
+  },
+  getPrototypeOf(target) {
+    return Reflect.getPrototypeOf(target.copiedObject ?? target.obj);
+  },
+};
+
 /**
- * Create a copy-on-write proxy for an object.
+ * Create a copy-on-write proxy for a plain object.
+ *
+ * @dev Arrays and other exotic objects are not supported. The proxy target
+ * is a `CopyOnWriteTarget`, not `obj`, so the proxy invariants break for
+ * non-configurable properties such as `Array.length`:
+ * `Object.keys()` and spread throw a `TypeError`, and `Array.isArray()`
+ * returns `false`.
  */
-export const copyOnWrite = <T extends object>(obj: T): T => {
-  let copiedObject: T | undefined;
-
-  Object.defineProperty(obj, util.inspect.custom, {
-    value: inspectCopyOnWrite,
-    configurable: true,
-  });
-
-  const proxy = new Proxy<T>(obj, {
-    get(target, prop, receiver) {
-      if (prop === COPY_ON_WRITE) {
-        return copiedObject ?? target;
-      }
-      let result = Reflect.get(copiedObject ?? target, prop, receiver);
-
-      if (
-        typeof result === "object" &&
-        result !== null &&
-        copiedObject === undefined
-      ) {
-        copiedObject = structuredClone(target);
-        copyOnWriteCopies.set(proxy, copiedObject);
-        result = Reflect.get(copiedObject, prop, receiver);
-      }
-
-      return result;
-    },
-    set(target, prop, newValue, receiver) {
-      if (copiedObject === undefined) {
-        copiedObject = structuredClone(target);
-        copyOnWriteCopies.set(proxy, copiedObject);
-      }
-      return Reflect.set(copiedObject, prop, newValue, receiver);
-    },
-    deleteProperty(target, prop) {
-      if (copiedObject === undefined) {
-        copiedObject = structuredClone(target);
-        copyOnWriteCopies.set(proxy, copiedObject);
-      }
-      return Reflect.deleteProperty(copiedObject, prop);
-    },
-    defineProperty(target, prop, descriptor) {
-      if (copiedObject === undefined) {
-        copiedObject = structuredClone(target);
-        copyOnWriteCopies.set(proxy, copiedObject);
-      }
-      return Reflect.defineProperty(copiedObject, prop, descriptor);
-    },
-    ownKeys(target) {
-      return Reflect.ownKeys(copiedObject ?? target);
-    },
-    has(target, prop) {
-      return Reflect.has(copiedObject ?? target, prop);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      return Reflect.getOwnPropertyDescriptor(copiedObject ?? target, prop);
-    },
-  });
-
-  return proxy;
+export const copyOnWrite = <T extends { [key: string]: unknown }>(
+  obj: T,
+): T => {
+  return new Proxy(
+    new CopyOnWriteTarget(obj),
+    copyOnWriteHandler,
+  ) as unknown as T;
 };
 
 /**

package/src/utils/decodeEventLog.ts

@@ -12,6 +12,31 @@ import {
 } from "./decodeAbiParameters.js";
 import { toLowerCase } from "./lowercase.js";
 
+type DecodeEventLogInputs = {
+  isUnnamed: boolean;
+  indexedInputs: (readonly [AbiParameter, number])[];
+  nonIndexedInputs: AbiParameter[];
+};
+
+/** Inputs of each `abiItem`, so that they aren't recomputed for every log. */
+const inputsCache = new WeakMap<AbiEvent, DecodeEventLogInputs>();
+
+const getInputs = (abiItem: AbiEvent): DecodeEventLogInputs => {
+  let result = inputsCache.get(abiItem);
+  if (result === undefined) {
+    const { inputs } = abiItem;
+    result = {
+      isUnnamed: inputs?.some((x) => !("name" in x && x.name)),
+      indexedInputs: inputs
+        .map((x, i) => [x, i] as const)
+        .filter(([x]) => "indexed" in x && x.indexed),
+      nonIndexedInputs: inputs.filter((x) => !("indexed" in x && x.indexed)),
+    };
+    inputsCache.set(abiItem, result);
+  }
+  return result;
+};
+
 /**
  * Decode an event log.
  *
@@ -27,14 +52,11 @@ export function decodeEventLog({
   data: Hex;
 }): any {
   const { inputs } = abiItem;
-  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+  const { isUnnamed, indexedInputs, nonIndexedInputs } = getInputs(abiItem);
 
   const args: any = isUnnamed ? [] : {};
 
   // Decode topics (indexed args).
-  const indexedInputs = inputs
-    .map((x, i) => [x, i] as const)
-    .filter(([x]) => "indexed" in x && x.indexed);
   for (let i = 0; i < indexedInputs.length; i++) {
     const [param, argIndex] = indexedInputs[i]!;
     const topic = topics[i + 1];
@@ -52,7 +74,6 @@ export function decodeEventLog({
   }
 
   // Decode data (non-indexed args).
-  const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
   if (nonIndexedInputs.length > 0) {
     if (data && data !== "0x") {
       const out = [] as DecodeAbiParametersReturnType<typeof nonIndexedInputs>;
@@ -82,7 +103,8 @@ export function decodeEventLog({
     }
   }
 
-  return Object.values(args).length > 0 ? args : undefined;
+  // Note: Every input sets a value in `args`.
+  return inputs.length > 0 ? args : undefined;
 }
 
 const ARRAY_REGEX = /^(.*)\[(\d+)?\]$/;