ponder-with-flashblocks 0.16.3

package/src/runtime/filter.ts

@@ -0,0 +1,664 @@
+import type {
+  BlockFilter,
+  Factory,
+  Filter,
+  InternalBlock,
+  InternalLog,
+  InternalTrace,
+  InternalTransaction,
+  LogFactory,
+  LogFilter,
+  RequiredBlockColumns,
+  RequiredLogColumns,
+  RequiredTraceColumns,
+  RequiredTransactionColumns,
+  RequiredTransactionReceiptColumns,
+  SyncBlock,
+  SyncBlockHeader,
+  SyncLog,
+  SyncTrace,
+  SyncTransaction,
+  TraceFilter,
+  TransactionFilter,
+  TransferFilter,
+} from "@/internal/types.js";
+import type {
+  Block,
+  Log,
+  Trace,
+  Transaction,
+  TransactionReceipt,
+} from "@/types/eth.js";
+import { toLowerCase } from "@/utils/lowercase.js";
+import { type Address, hexToNumber } from "viem";
+
+/** Returns true if `address` is an address filter. */
+export const isAddressFactory = (
+  address: Address | Address[] | Factory | undefined | null,
+): address is LogFactory => {
+  if (
+    address === undefined ||
+    address === null ||
+    typeof address === "string"
+  ) {
+    return false;
+  }
+  return Array.isArray(address) ? isAddressFactory(address[0]) : true;
+};
+
+export const getChildAddress = ({
+  log,
+  factory,
+}: { log: SyncLog; factory: Factory }): Address => {
+  if (factory.childAddressLocation.startsWith("offset")) {
+    const childAddressOffset = Number(
+      factory.childAddressLocation.substring(6),
+    );
+    const start = 2 + 12 * 2 + childAddressOffset * 2;
+    const length = 20 * 2;
+
+    return `0x${log.data.substring(start, start + length)}`;
+  } else {
+    const start = 2 + 12 * 2;
+    const length = 20 * 2;
+    const topicIndex =
+      factory.childAddressLocation === "topic1"
+        ? 1
+        : factory.childAddressLocation === "topic2"
+          ? 2
+          : 3;
+    return `0x${log.topics[topicIndex]!.substring(start, start + length)}`;
+  }
+};
+
+export const isAddressMatched = ({
+  address,
+  blockNumber,
+  childAddresses,
+}: {
+  address: Address | undefined;
+  blockNumber: number;
+  childAddresses: Map<Address, number>;
+}) => {
+  if (address === undefined) return false;
+  if (
+    childAddresses.has(toLowerCase(address)) &&
+    childAddresses.get(toLowerCase(address))! <= blockNumber
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+const isValueMatched = <T extends string>(
+  filterValue: T | T[] | null | undefined,
+  eventValue: T | undefined,
+): boolean => {
+  // match all
+  if (filterValue === null || filterValue === undefined) return true;
+
+  // missing value
+  if (eventValue === undefined) return false;
+
+  // array
+  if (
+    Array.isArray(filterValue) &&
+    filterValue.some((v) => v === toLowerCase(eventValue))
+  ) {
+    return true;
+  }
+
+  // single
+  if (filterValue === toLowerCase(eventValue)) return true;
+
+  return false;
+};
+
+/**
+ * Returns `true` if `log` matches `factory`
+ */
+export const isLogFactoryMatched = ({
+  factory,
+  log,
+}: { factory: LogFactory; log: InternalLog | SyncLog }): boolean => {
+  if (factory.address !== undefined) {
+    const addresses = Array.isArray(factory.address)
+      ? factory.address
+      : [factory.address];
+
+    if (addresses.every((address) => address !== toLowerCase(log.address))) {
+      return false;
+    }
+  }
+  if (log.topics.length === 0) return false;
+  if (factory.eventSelector !== toLowerCase(log.topics[0]!)) return false;
+  if (
+    factory.fromBlock !== undefined &&
+    (typeof log.blockNumber === "number"
+      ? factory.fromBlock > log.blockNumber
+      : factory.fromBlock > hexToNumber(log.blockNumber))
+  )
+    return false;
+  if (
+    factory.toBlock !== undefined &&
+    (typeof log.blockNumber === "number"
+      ? factory.toBlock < log.blockNumber
+      : factory.toBlock < hexToNumber(log.blockNumber))
+  )
+    return false;
+
+  return true;
+};
+
+/**
+ * Returns `true` if `log` matches `filter`
+ */
+export const isLogFilterMatched = ({
+  filter,
+  log,
+}: {
+  filter: LogFilter;
+  log: InternalLog | SyncLog;
+}): boolean => {
+  // Return `false` for out of range blocks
+  if (
+    Number(log.blockNumber) < (filter.fromBlock ?? 0) ||
+    Number(log.blockNumber) > (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  if (isValueMatched(filter.topic0, log.topics[0]) === false) return false;
+  if (isValueMatched(filter.topic1, log.topics[1]) === false) return false;
+  if (isValueMatched(filter.topic2, log.topics[2]) === false) return false;
+  if (isValueMatched(filter.topic3, log.topics[3]) === false) return false;
+
+  if (
+    isAddressFactory(filter.address) === false &&
+    isValueMatched(
+      filter.address as Address | Address[] | undefined,
+      log.address,
+    ) === false
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Returns `true` if `transaction` matches `filter`
+ */
+export const isTransactionFilterMatched = ({
+  filter,
+  transaction,
+}: {
+  filter: TransactionFilter;
+  transaction: InternalTransaction | SyncTransaction;
+}): boolean => {
+  // Return `false` for out of range blocks
+  if (
+    Number(transaction.blockNumber) < (filter.fromBlock ?? 0) ||
+    Number(transaction.blockNumber) >
+      (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.fromAddress) === false &&
+    isValueMatched(
+      filter.fromAddress as Address | Address[] | undefined,
+      transaction.from,
+    ) === false
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.toAddress) === false &&
+    isValueMatched(
+      filter.toAddress as Address | Address[] | undefined,
+      transaction.to ?? undefined,
+    ) === false
+  ) {
+    return false;
+  }
+
+  // NOTE: `filter.includeReverted` is intentionally ignored
+
+  return true;
+};
+
+/**
+ * Returns `true` if `trace` matches `filter`
+ */
+export const isTraceFilterMatched = ({
+  filter,
+  trace,
+  block,
+}: {
+  filter: TraceFilter;
+  trace: InternalTrace | SyncTrace["trace"];
+  block: Pick<InternalBlock | SyncBlock, "number">;
+}): boolean => {
+  // Return `false` for out of range blocks
+  if (
+    Number(block.number) < (filter.fromBlock ?? 0) ||
+    Number(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.fromAddress) === false &&
+    isValueMatched(
+      filter.fromAddress as Address | Address[] | undefined,
+      trace.from,
+    ) === false
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.toAddress) === false &&
+    isValueMatched(
+      filter.toAddress as Address | Address[] | undefined,
+      trace.to ?? undefined,
+    ) === false
+  ) {
+    return false;
+  }
+
+  if (
+    isValueMatched(filter.functionSelector, trace.input.slice(0, 10)) === false
+  ) {
+    return false;
+  }
+
+  // NOTE: `filter.callType` and `filter.includeReverted` is intentionally ignored
+
+  return true;
+};
+
+/**
+ * Returns `true` if `trace` matches `filter`
+ */
+export const isTransferFilterMatched = ({
+  filter,
+  trace,
+  block,
+}: {
+  filter: TransferFilter;
+  trace: InternalTrace | SyncTrace["trace"];
+  block: Pick<InternalBlock | SyncBlock, "number">;
+}): boolean => {
+  // Return `false` for out of range blocks
+  if (
+    Number(block.number) < (filter.fromBlock ?? 0) ||
+    Number(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  if (
+    trace.value === undefined ||
+    trace.value === null ||
+    BigInt(trace.value) === 0n
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.fromAddress) === false &&
+    isValueMatched(
+      filter.fromAddress as Address | Address[] | undefined,
+      trace.from,
+    ) === false
+  ) {
+    return false;
+  }
+
+  if (
+    isAddressFactory(filter.toAddress) === false &&
+    isValueMatched(
+      filter.toAddress as Address | Address[] | undefined,
+      trace.to ?? undefined,
+    ) === false
+  ) {
+    return false;
+  }
+
+  // NOTE: `filter.includeReverted` is intentionally ignored
+
+  return true;
+};
+
+/**
+ * Returns `true` if `block` matches `filter`
+ */
+export const isBlockFilterMatched = ({
+  filter,
+  block,
+}: {
+  filter: BlockFilter;
+  block: Pick<InternalBlock | SyncBlock | SyncBlockHeader, "number">;
+}): boolean => {
+  // Return `false` for out of range blocks
+  if (
+    Number(block.number) < (filter.fromBlock ?? 0) ||
+    Number(block.number) > (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  return (Number(block.number) - filter.offset) % filter.interval === 0;
+};
+
+export const getFilterFactories = (filter: Filter): Factory[] => {
+  const factories: Factory[] = [];
+  switch (filter.type) {
+    case "log":
+      if (isAddressFactory(filter.address)) {
+        factories.push(filter.address);
+      }
+      break;
+    case "trace":
+    case "transfer":
+    case "transaction": {
+      if (isAddressFactory(filter.fromAddress)) {
+        factories.push(filter.fromAddress);
+      }
+      if (isAddressFactory(filter.toAddress)) {
+        factories.push(filter.toAddress);
+      }
+      break;
+    }
+  }
+  return factories;
+};
+
+export const getFilterFromBlock = (filter: Filter): number => {
+  const blocks: number[] = [filter.fromBlock ?? 0];
+  switch (filter.type) {
+    case "log":
+      if (isAddressFactory(filter.address)) {
+        blocks.push(filter.address.fromBlock ?? 0);
+      }
+      break;
+    case "transaction":
+    case "trace":
+    case "transfer":
+      if (isAddressFactory(filter.fromAddress)) {
+        blocks.push(filter.fromAddress.fromBlock ?? 0);
+      }
+
+      if (isAddressFactory(filter.toAddress)) {
+        blocks.push(filter.toAddress.fromBlock ?? 0);
+      }
+  }
+
+  return Math.min(...blocks);
+};
+
+export const getFilterToBlock = (filter: Filter): number => {
+  const blocks: number[] = [filter.toBlock ?? Number.POSITIVE_INFINITY];
+
+  // Note: factories cannot have toBlock > `filter.toBlock`
+
+  switch (filter.type) {
+    case "log":
+      if (isAddressFactory(filter.address)) {
+        blocks.push(filter.address.toBlock ?? Number.POSITIVE_INFINITY);
+      }
+      break;
+    case "transaction":
+    case "trace":
+    case "transfer":
+      if (isAddressFactory(filter.fromAddress)) {
+        blocks.push(filter.fromAddress.toBlock ?? Number.POSITIVE_INFINITY);
+      }
+
+      if (isAddressFactory(filter.toAddress)) {
+        blocks.push(filter.toAddress.toBlock ?? Number.POSITIVE_INFINITY);
+      }
+  }
+
+  return Math.max(...blocks);
+};
+
+export const isBlockInFilter = (filter: Filter, blockNumber: number) => {
+  // Return `false` for out of range blocks
+  if (
+    blockNumber < (filter.fromBlock ?? 0) ||
+    blockNumber > (filter.toBlock ?? Number.POSITIVE_INFINITY)
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+export const defaultBlockInclude: (keyof Block)[] = [
+  "baseFeePerGas",
+  "difficulty",
+  "extraData",
+  "gasLimit",
+  "gasUsed",
+  "hash",
+  "logsBloom",
+  "miner",
+  "mixHash",
+  "totalDifficulty",
+  "nonce",
+  "number",
+  "parentHash",
+  "receiptsRoot",
+  "sha3Uncles",
+  "size",
+  "stateRoot",
+  "timestamp",
+  "transactionsRoot",
+];
+
+export const requiredBlockInclude: RequiredBlockColumns[] = [
+  "timestamp",
+  "number",
+  "hash",
+];
+
+export const defaultTransactionInclude: (keyof Transaction)[] = [
+  "from",
+  "gas",
+  "hash",
+  "input",
+  "nonce",
+  "r",
+  "s",
+  "to",
+  "transactionIndex",
+  "v",
+  "value",
+  "type",
+  "gasPrice",
+  "accessList",
+  "maxFeePerGas",
+  "maxPriorityFeePerGas",
+];
+
+export const requiredTransactionInclude: RequiredTransactionColumns[] = [
+  "transactionIndex",
+  "from",
+  "to",
+  "hash",
+  "type",
+];
+
+export const defaultTransactionReceiptInclude: (keyof TransactionReceipt)[] = [
+  "contractAddress",
+  "cumulativeGasUsed",
+  "effectiveGasPrice",
+  "from",
+  "gasUsed",
+  "logsBloom",
+  "status",
+  "to",
+  "type",
+];
+
+export const requiredTransactionReceiptInclude: RequiredTransactionReceiptColumns[] =
+  ["status", "from", "to"];
+
+export const defaultTraceInclude: (keyof Trace)[] = [
+  "traceIndex",
+  "type",
+  "from",
+  "to",
+  "gas",
+  "gasUsed",
+  "input",
+  "output",
+  "error",
+  "revertReason",
+  "value",
+  "subcalls",
+];
+
+export const requiredTraceInclude: RequiredTraceColumns[] = [
+  "traceIndex",
+  "type",
+  "from",
+  "to",
+  "input",
+  "output",
+  "error",
+  "value",
+];
+
+export const defaultLogInclude: (keyof Log)[] = [
+  "address",
+  "data",
+  "logIndex",
+  "removed",
+  "topics",
+];
+
+export const requiredLogInclude: RequiredLogColumns[] = defaultLogInclude;
+
+export const defaultBlockFilterInclude: BlockFilter["include"] =
+  defaultBlockInclude.map((value) => `block.${value}` as const);
+
+export const requiredBlockFilterInclude: BlockFilter["include"] =
+  requiredBlockInclude.map((value) => `block.${value}` as const);
+
+export const defaultLogFilterInclude: LogFilter["include"] = [
+  ...defaultLogInclude.map((value) => `log.${value}` as const),
+  ...defaultTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...defaultBlockInclude.map((value) => `block.${value}` as const),
+];
+
+export const requiredLogFilterInclude: LogFilter["include"] = [
+  ...requiredLogInclude.map((value) => `log.${value}` as const),
+  ...requiredTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...requiredBlockInclude.map((value) => `block.${value}` as const),
+];
+
+export const defaultTransactionFilterInclude: TransactionFilter["include"] = [
+  ...defaultTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...defaultTransactionReceiptInclude.map(
+    (value) => `transactionReceipt.${value}` as const,
+  ),
+  ...defaultBlockInclude.map((value) => `block.${value}` as const),
+];
+
+export const requiredTransactionFilterInclude: TransactionFilter["include"] = [
+  ...requiredTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...requiredTransactionReceiptInclude.map(
+    (value) => `transactionReceipt.${value}` as const,
+  ),
+  ...requiredBlockInclude.map((value) => `block.${value}` as const),
+];
+
+export const defaultTraceFilterInclude: TraceFilter["include"] = [
+  ...defaultBlockInclude.map((value) => `block.${value}` as const),
+  ...defaultTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...defaultTraceInclude.map((value) => `trace.${value}` as const),
+];
+
+export const requiredTraceFilterInclude: TraceFilter["include"] = [
+  ...requiredBlockInclude.map((value) => `block.${value}` as const),
+  ...requiredTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...requiredTraceInclude.map((value) => `trace.${value}` as const),
+];
+
+export const defaultTransferFilterInclude: TransferFilter["include"] = [
+  ...defaultBlockInclude.map((value) => `block.${value}` as const),
+  ...defaultTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...defaultTraceInclude.map((value) => `trace.${value}` as const),
+];
+
+export const requiredTransferFilterInclude: TransferFilter["include"] = [
+  ...requiredBlockInclude.map((value) => `block.${value}` as const),
+  ...requiredTransactionInclude.map((value) => `transaction.${value}` as const),
+  ...requiredTraceInclude.map((value) => `trace.${value}` as const),
+];
+
+export const unionFilterIncludeBlock = (filters: Filter[]): (keyof Block)[] => {
+  const includeBlock = new Set<keyof Block>();
+  for (const filter of filters) {
+    for (const include of filter.include) {
+      const [data, column] = include.split(".") as [string, keyof Block];
+      if (data === "block") {
+        includeBlock.add(column);
+      }
+    }
+  }
+  return Array.from(includeBlock);
+};
+
+export const unionFilterIncludeTransaction = (
+  filters: Filter[],
+): (keyof Transaction)[] => {
+  const includeTransaction = new Set<keyof Transaction>();
+  for (const filter of filters) {
+    for (const include of filter.include) {
+      const [data, column] = include.split(".") as [string, keyof Transaction];
+      if (data === "transaction") {
+        includeTransaction.add(column);
+      }
+    }
+  }
+  return Array.from(includeTransaction);
+};
+
+export const unionFilterIncludeTransactionReceipt = (
+  filters: Filter[],
+): (keyof TransactionReceipt)[] => {
+  const includeTransactionReceipt = new Set<keyof TransactionReceipt>();
+  for (const filter of filters) {
+    for (const include of filter.include) {
+      const [data, column] = include.split(".") as [
+        string,
+        keyof TransactionReceipt,
+      ];
+      if (data === "transactionReceipt") {
+        includeTransactionReceipt.add(column);
+      }
+    }
+  }
+  return Array.from(includeTransactionReceipt);
+};
+
+export const unionFilterIncludeTrace = (filters: Filter[]): (keyof Trace)[] => {
+  const includeTrace = new Set<keyof Trace>();
+  for (const filter of filters) {
+    for (const include of filter.include) {
+      const [data, column] = include.split(".") as [string, keyof Trace];
+      if (data === "trace") {
+        includeTrace.add(column);
+      }
+    }
+  }
+  return Array.from(includeTrace);
+};