@across-protocol/sdk 3.2.14 → 3.2.16

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -171,8 +171,16 @@ export class BundleDataClient {
     this.bundleTimestampCache[key] = timestamps;
   }
 
-  private getArweaveClientKey(blockRangesForChains: number[][]): string {
-    return `bundles-${blockRangesForChains}`;
+  static getArweaveClientKey(blockRangesForChains: number[][]): string {
+    // As a unique key for this bundle, use the bundle mainnet end block, which should
+    // never be duplicated between bundles as long as thebundle block range
+    // always progresses forwards, which I think is a safe assumption. Other chains might pause
+    // but mainnet should never pause.
+    return blockRangesForChains[0][1].toString();
+  }
+
+  private getArweaveBundleDataClientKey(blockRangesForChains: number[][]): string {
+    return `bundles-${BundleDataClient.getArweaveClientKey(blockRangesForChains)}`;
   }
 
   private async loadPersistedDataFromArweave(
@@ -183,7 +191,7 @@ export class BundleDataClient {
     }
     const start = performance.now();
     const persistedData = await this.clients.arweaveClient.getByTopic(
-      this.getArweaveClientKey(blockRangesForChains),
+      this.getArweaveBundleDataClientKey(blockRangesForChains),
       BundleDataSS
     );
     // If there is no data or the data is empty, return undefined because we couldn't
@@ -579,7 +587,7 @@ export class BundleDataClient {
   }
 
   private async loadArweaveData(blockRangesForChains: number[][]): Promise<LoadDataReturnValue> {
-    const arweaveKey = this.getArweaveClientKey(blockRangesForChains);
+    const arweaveKey = this.getArweaveBundleDataClientKey(blockRangesForChains);
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     if (!this.arweaveDataCache[arweaveKey]) {
       this.arweaveDataCache[arweaveKey] = this.loadPersistedDataFromArweave(blockRangesForChains);

package/src/clients/BundleDataClient/utils/SuperstructUtils.ts

@@ -10,6 +10,7 @@ import {
   pattern,
   boolean,
   defaulted,
+  type,
 } from "superstruct";
 import { BigNumber } from "../../../utils";
 
@@ -122,8 +123,7 @@ const nestedV3BundleFillsSS = record(
   )
 );
 
-export const BundleDataSS = object({
-  bundleBlockRanges: array(array(number())),
+export const BundleDataSS = type({
   bundleDepositsV3: nestedV3DepositRecordSS,
   expiredDepositsToRefundV3: nestedV3DepositRecordSS,
   unexecutableSlowFills: nestedV3DepositRecordWithLpFeePctSS,

package/src/providers/rateLimitedProvider.ts

@@ -51,6 +51,7 @@ export class RateLimitedProvider extends ethers.providers.StaticJsonRpcProvider
         method,
         params,
         chainId: this.network.chainId,
+        datadog: true,
       };
 
       // In this path we log an rpc response sample.

package/src/utils/Profiler.ts

@@ -0,0 +1,194 @@
+import { performance } from "node:perf_hooks";
+import { Logger } from "winston";
+import crypto from "crypto";
+import { DefaultLogLevels } from "./LogUtils";
+
+type Detail = {
+  message?: string;
+  [key: string]: unknown;
+};
+
+const defaultMeta = { datadog: true };
+
+export type PerformanceData = {
+  task: string; // The name of the task being measured.
+  duration: number; // Duration in milliseconds.
+  message: string; // A descriptive message about the task.
+  at: string; // Identifier indicating where the profiling is happening.
+  data?: Record<string, unknown>; // Additional detail data.
+};
+
+type ProfilerOptions = {
+  logger: Logger;
+  at: string;
+  logLevel?: DefaultLogLevels;
+} & Record<string, unknown>;
+
+export class Profiler {
+  private marks: Map<string, { time: number; detail?: Record<string, unknown> }>;
+  private at: string;
+  private detail: Detail;
+  private logger: Logger;
+  private logLevel: DefaultLogLevels;
+
+  /**
+   * Initializes a new instance of the Profiler class.
+   * @param logger The logger instance for logging performance data.
+   * @param at A string identifier for where the profiler is used.
+   * @param detail Optional additional detail data.
+   */
+  constructor({ logger, at, logLevel, ...detail }: ProfilerOptions) {
+    this.marks = new Map();
+    this.logger = logger;
+    this.at = at;
+    this.logLevel = logLevel ?? "debug";
+    this.detail = detail;
+  }
+
+  log(logLevel: DefaultLogLevels, data: Parameters<Logger["log"]>[1]): void {
+    this.logger.log(logLevel, {
+      at: this.at,
+      ...defaultMeta,
+      ...data,
+    });
+  }
+
+  logMeasure(data: Omit<PerformanceData, "at">, logLevel: DefaultLogLevels = this.logLevel): void {
+    this.log(logLevel, {
+      ...data,
+    });
+  }
+
+  /**
+   * Starts a profiling session for a task.
+   * @param task The name of the task being measured.
+   * @param detail Optional detail data to merge.
+   * @returns An object containing the start time and a stop function.
+   */
+  start(task: string, detail?: Detail): { startTime: number; stop: (_detail?: Detail) => number | undefined } {
+    const start = crypto.randomUUID();
+    const startTime = this.mark(start, detail);
+    return {
+      startTime,
+      stop: (_detail?: Detail) => this.measure(task, { from: start, ...(detail ?? {}), ...(_detail ?? {}) }),
+    };
+  }
+
+  /**
+   * Records a mark with a label and optional detail.
+   * @param label The label for the mark.
+   * @param detail Optional detail data to merge.
+   * @returns The current timestamp in milliseconds.
+   */
+  mark(label: string, detail?: Detail): number {
+    const currentTime = performance.now();
+
+    // Merge additional data
+    this.detail = { ...(this.detail ?? {}), ...(detail ?? {}) };
+
+    // Store the mark
+    this.marks.set(label, { time: currentTime, detail });
+    return currentTime;
+  }
+
+  /**
+   * Measures the duration between two marks and logs the performance data.
+   * @param task The name of the task for this measurement.
+   * @param params An object containing:
+   *  - `from`: The label of the starting mark.
+   *  - `to` (optional): The label of the ending mark.
+   *  - Additional detail data to merge.
+   * @returns The duration in milliseconds, or undefined if the start mark is not found.
+   */
+  measure(
+    task: string,
+    params: {
+      from: string;
+      to?: string;
+    } & Detail
+  ): number | undefined {
+    const { from, to, ...detail } = params;
+    const startMark = this.marks.get(from);
+    const endMark = to ? this.marks.get(to) : undefined;
+
+    if (!startMark) {
+      this.log("warn", {
+        message: `Cannot find start mark for label "${from}".`,
+        ...this.detail,
+      });
+      return;
+    }
+    const endTime = endMark?.time ?? performance.now();
+
+    const duration = endTime - startMark.time;
+
+    // Merge detail
+    const { message, ...combinedDetail } = { ...(this.detail ?? {}), ...(detail ?? {}) };
+    const defaultMessage = `Profiler Log: ${task}`;
+
+    this.logMeasure({
+      task,
+      duration,
+      message: message ?? defaultMessage,
+      data: combinedDetail,
+    });
+
+    return duration;
+  }
+
+  /**
+   * Measures the performance of an asynchronous operation represented by a promise.
+   * @param pr The promise representing the asynchronous operation to measure.
+   * @param task The name of the task for this measurement.
+   * @param detail Optional detail data to merge.
+   * @returns A promise that resolves with the result of the asynchronous operation.
+   */
+  async measureAsync<T>(pr: Promise<T>, task: string, detail?: Detail): Promise<T> {
+    const startTime = performance.now();
+
+    try {
+      const result = await pr;
+      return result;
+    } finally {
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+      const { message, ...combinedDetail } = { ...detail };
+      const defaultMessage = `Profiler Log: ${task}`;
+
+      this.logMeasure({
+        task,
+        duration,
+        message: message ?? defaultMessage,
+        data: combinedDetail,
+      });
+    }
+  }
+
+  /**
+   * Measures the performance of a synchronous function by wrapping it.
+   * @param fn The synchronous function to measure.
+   * @param task The name of the task for this measurement.
+   * @param detail Optional detail data to merge.
+   * @returns The result of the synchronous function.
+   */
+  measureSync<T>(fn: () => T, task: string, detail?: Detail): T {
+    const startTime = performance.now();
+
+    try {
+      const result = fn();
+      return result;
+    } finally {
+      const endTime = performance.now();
+      const duration = endTime - startTime;
+      const { message, ...combinedDetail } = { ...detail };
+      const defaultMessage = `Profiler Log: ${task}`;
+
+      this.logMeasure({
+        task,
+        duration,
+        message: message ?? defaultMessage,
+        data: combinedDetail,
+      });
+    }
+  }
+}