@across-protocol/sdk 3.1.18 → 3.1.19

package/dist/types/utils/NetworkUtils.d.ts

@@ -64,4 +64,10 @@ export declare function chainIsCCTPEnabled(chainId: number): boolean;
  * @returns True if chainId requires manual L1 -> L2 finalization, otherwise false.
  */
 export declare function chainRequiresL1ToL2Finalization(chainId: number): boolean;
+/**
+ * Returns the origin of a URL.
+ * @param url A URL.
+ * @returns The origin of the URL, or "UNKNOWN" if the URL is invalid.
+ */
+export declare function getOriginFromURL(url: string): string;
 //# sourceMappingURL=NetworkUtils.d.ts.map

package/dist/types/utils/NetworkUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE"}
+{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMpD"}

package/dist/types/utils/ObjectUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/ObjectUtils.ts"],"names":[],"mappings":"AAKA,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAyBjE;AAGD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,GAAG,CASL;AACD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACrC,GAAG,CAOL;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,GAAG,CAM1F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAEvG"}
+{"version":3,"file":"ObjectUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/ObjectUtils.ts"],"names":[],"mappings":"AAMA,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAyBjE;AAGD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,GAAG,CASL;AACD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACrC,GAAG,CAOL;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,GAAG,CAM1F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAEvG"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "3.1.18",
+  "version": "3.1.19",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -58,6 +58,7 @@
     "@size-limit/preset-small-lib": "^7.0.8",
     "@typechain/ethers-v5": "^11.1.1",
     "@typechain/hardhat": "^6.1.6",
+    "@types/async": "^3.2.24",
     "@types/chai": "^4.3.6",
     "@types/dotenv": "^8.2.0",
     "@types/lodash": "^4.14.199",
@@ -104,12 +105,15 @@
     "@eth-optimism/sdk": "^3.3.1",
     "@pinata/sdk": "^2.1.0",
     "@types/mocha": "^10.0.1",
+    "@uma/logger": "^1.3.0",
     "@uma/sdk": "^0.34.1",
     "arweave": "^1.14.4",
+    "async": "^3.2.5",
     "axios": "^0.27.2",
     "big-number": "^2.0.0",
     "decimal.js": "^10.3.1",
     "ethers": "^5.7.2",
+    "lodash": "^4.17.21",
     "lodash.get": "^4.4.2",
     "superstruct": "^0.15.4",
     "tslib": "^2.6.2"

package/src/index.ts

@@ -13,3 +13,4 @@ export * as typeguards from "./typeguards";
 export * as clients from "./clients";
 export * as typechain from "./typechain";
 export * as caching from "./caching";
+export * as providers from "./providers";

package/src/providers/cachedProvider.ts

@@ -0,0 +1,155 @@
+import { random } from "lodash";
+import { CachingMechanismInterface } from "../interfaces";
+import { BLOCK_NUMBER_TTL, PROVIDER_CACHE_TTL, PROVIDER_CACHE_TTL_MODIFIER as ttl_modifier } from "./constants";
+import { RateLimitedProvider } from "./rateLimitedProvider";
+import { CacheType } from "./utils";
+
+export class CacheProvider extends RateLimitedProvider {
+  public readonly getBlockByNumberPrefix: string;
+  public readonly getLogsCachePrefix: string;
+  public readonly callCachePrefix: string;
+  public readonly baseTTL: number;
+
+  constructor(
+    providerCacheNamespace: string,
+    readonly redisClient?: CachingMechanismInterface,
+    // Note: if not provided, this is set to POSITIVE_INFINITY, meaning no cache entries are set with the standard TTL.
+    readonly standardTtlBlockDistance = Number.POSITIVE_INFINITY,
+    // Note: if not provided, this is set to POSITIVE_INFINITY, meaning no cache entries are set with no TTL.
+    readonly noTtlBlockDistance = Number.POSITIVE_INFINITY,
+    readonly providerCacheTtl = PROVIDER_CACHE_TTL,
+    ...jsonRpcConstructorParams: ConstructorParameters<typeof RateLimitedProvider>
+  ) {
+    super(...jsonRpcConstructorParams);
+
+    const { chainId } = this.network;
+
+    // Pre-compute as much of the redis key as possible.
+    const cachePrefix = `${providerCacheNamespace},${new URL(this.connection.url).hostname},${chainId}`;
+    this.getBlockByNumberPrefix = `${cachePrefix}:getBlockByNumber,`;
+    this.getLogsCachePrefix = `${cachePrefix}:eth_getLogs,`;
+    this.callCachePrefix = `${cachePrefix}:eth_call,`;
+
+    const _ttlVar = providerCacheTtl;
+    const _ttl = Number(_ttlVar);
+    if (isNaN(_ttl) || _ttl <= 0) {
+      throw new Error(`PROVIDER_CACHE_TTL (${_ttlVar}) must be numeric and > 0`);
+    }
+    this.baseTTL = _ttl;
+  }
+  override async send(method: string, params: Array<unknown>): Promise<unknown> {
+    const cacheType = this.redisClient ? await this.cacheType(method, params) : CacheType.NONE;
+
+    if (cacheType !== CacheType.NONE) {
+      const redisKey = this.buildRedisKey(method, params);
+
+      // Attempt to pull the result from the cache.
+      const redisResult = await this.redisClient?.get<string>(redisKey);
+
+      // If cache has the result, parse the json and return it.
+      if (redisResult) {
+        return JSON.parse(redisResult);
+      }
+
+      // Cache does not have the result. Query it directly and cache.
+      const result = await super.send(method, params);
+
+      // Note: use swtich to ensure all enum cases are handled.
+      switch (cacheType) {
+        case CacheType.WITH_TTL:
+          {
+            // Apply a random margin to spread expiry over a larger time window.
+            const ttl = this.baseTTL + Math.ceil(random(-ttl_modifier, ttl_modifier, true) * this.baseTTL);
+            await this.redisClient?.set(redisKey, JSON.stringify(result), ttl);
+          }
+          break;
+        case CacheType.NO_TTL:
+          await this.redisClient?.set(redisKey, JSON.stringify(result), Number.POSITIVE_INFINITY);
+          break;
+        default:
+          throw new Error(`Unexpected Cache type: ${cacheType}`);
+      }
+
+      // Return the cached result.
+      return result;
+    }
+
+    return await super.send(method, params);
+  }
+
+  private buildRedisKey(method: string, params: Array<unknown>) {
+    // Only handles eth_getLogs and eth_call right now.
+    switch (method) {
+      case "eth_getBlockByNumber":
+        return this.getBlockByNumberPrefix + JSON.stringify(params);
+      case "eth_getLogs":
+        return this.getLogsCachePrefix + JSON.stringify(params);
+      case "eth_call":
+        return this.callCachePrefix + JSON.stringify(params);
+      default:
+        throw new Error(`CacheProvider::buildRedisKey: invalid JSON-RPC method ${method}`);
+    }
+  }
+
+  private cacheType(method: string, params: Array<unknown>): Promise<CacheType> {
+    // Today, we only cache eth_getLogs and eth_call.
+    if (method === "eth_getLogs") {
+      const [{ fromBlock, toBlock }] = params as { toBlock: number; fromBlock: number }[];
+
+      // Handle odd cases where the ordering is flipped, etc.
+      // toBlock/fromBlock is in hex, so it must be parsed before being compared to the first unsafe block.
+      const fromBlockNumber = parseInt(String(fromBlock), 16);
+      const toBlockNumber = parseInt(String(toBlock), 16);
+
+      // Handle cases where the input block numbers are not hex values ("latest", "pending", etc).
+      // This would result in the result of the above being NaN.
+      if (Number.isNaN(fromBlockNumber) || Number.isNaN(toBlockNumber)) {
+        return Promise.resolve(CacheType.NONE);
+      }
+
+      if (toBlockNumber < fromBlockNumber) {
+        throw new Error("CacheProvider::shouldCache toBlock cannot be smaller than fromBlock.");
+      }
+
+      return this.cacheTypeForBlock(toBlock);
+    } else if ("eth_call" === method || "eth_getBlockByNumber" === method) {
+      // Pull out the block tag from params. Its position in params is dependent on the method.
+      // We are only interested in numeric block tags, which would be hex-encoded strings.
+      const idx = method === "eth_getBlockByNumber" ? 0 : 1;
+      const blockNumber = parseInt(String(params[idx]), 16);
+
+      // If the block number isn't present or is a text string, this will be NaN and we return false.
+      if (Number.isNaN(blockNumber)) {
+        return Promise.resolve(CacheType.NONE);
+      }
+
+      // If the block is old enough to cache, cache the call.
+      return this.cacheTypeForBlock(blockNumber);
+    } else {
+      return Promise.resolve(CacheType.NONE);
+    }
+  }
+
+  private async cacheTypeForBlock(blockNumber: number): Promise<CacheType> {
+    // Note: this method is an internal method provided by the BaseProvider. It allows the caller to specify a maxAge of
+    // the block that is allowed. This means if a block has been retrieved within the last n seconds, no provider
+    // query will be made.
+    const currentBlockNumber = await super._getInternalBlockNumber(BLOCK_NUMBER_TTL * 1000);
+
+    // Determine the distance that the block is from HEAD.
+    const headDistance = currentBlockNumber - blockNumber;
+
+    // If the distance from head is large enough, set with no TTL.
+    if (headDistance > this.noTtlBlockDistance) {
+      return CacheType.NO_TTL;
+    }
+
+    // If the distance is <= noTtlBlockDistance, but > standardTtlBlockDistance, use standard TTL.
+    if (headDistance > this.standardTtlBlockDistance) {
+      return CacheType.WITH_TTL;
+    }
+
+    // Too close to HEAD, no cache.
+    return CacheType.NONE;
+  }
+}

package/src/providers/constants.ts

@@ -0,0 +1,11 @@
+// This is how many seconds stale the block number can be for us to use it for evaluating the reorg distance in the cache provider.
+export const BLOCK_NUMBER_TTL = 60;
+
+// This is the TTL for the provider cache.
+export const PROVIDER_CACHE_TTL = 3600;
+export const PROVIDER_CACHE_TTL_MODIFIER = 0.15;
+
+/**
+ * A default timeout for requests of 60 seconds.
+ */
+export const defaultTimeout = 60 * 1000;

package/src/providers/index.ts

@@ -0,0 +1,5 @@
+export * from "./rateLimitedProvider";
+export * from "./cachedProvider";
+export * from "./retryProvider";
+export * from "./constants";
+export * from "./utils";

package/src/providers/rateLimitedProvider.ts

@@ -0,0 +1,94 @@
+// StaticJsonRpcProvider is used in place of JsonRpcProvider to avoid redundant eth_chainId queries prior to each
+// request. This is safe to use when the back-end provider is guaranteed not to change.
+// See https://docs.ethers.io/v5/api/providers/jsonrpc-provider/#StaticJsonRpcProvider
+
+import { QueueObject, queue } from "async";
+import { ethers } from "ethers";
+import { RateLimitTask } from "./utils";
+import { getOriginFromURL } from "../utils/NetworkUtils";
+import { Logger } from "winston";
+import { Logger as umaLogger } from "@uma/logger";
+
+// This provider is a very small addition to the StaticJsonRpcProvider that ensures that no more than `maxConcurrency`
+// requests are ever in flight. It uses the async/queue library to manage this.
+export class RateLimitedProvider extends ethers.providers.StaticJsonRpcProvider {
+  // The queue object that manages the tasks.
+  private queue: QueueObject<RateLimitTask>;
+
+  // Takes the same arguments as the JsonRpcProvider, but it has an additional maxConcurrency value at the beginning
+  // of the list.
+  constructor(
+    maxConcurrency: number,
+    readonly pctRpcCallsLogged: number,
+    readonly logger: Logger = umaLogger,
+    ...cacheConstructorParams: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>
+  ) {
+    super(...cacheConstructorParams);
+
+    // This sets up the queue. Each task is executed by calling the superclass's send method, which fires off the
+    // request. This queue sends out requests concurrently, but stops once the concurrency limit is reached. The
+    // maxConcurrency is configured here.
+    this.queue = queue(async ({ sendArgs, resolve, reject }: RateLimitTask, callback: () => void) => {
+      await this.wrapSendWithLog(...sendArgs)
+        .then(resolve)
+        .catch(reject);
+      // we need this for the queue to know that the task is done
+      // @see: https://caolan.github.io/async/v3/global.html
+      callback();
+    }, maxConcurrency);
+  }
+
+  async wrapSendWithLog(method: string, params: Array<unknown>) {
+    if (this.pctRpcCallsLogged <= 0 || Math.random() > this.pctRpcCallsLogged / 100) {
+      // Non sample path: no logging or timing, just issue the request.
+      return super.send(method, params);
+    } else {
+      const loggerArgs = {
+        at: "ProviderUtils",
+        message: "Provider response sample",
+        provider: getOriginFromURL(this.connection.url),
+        method,
+        params,
+        chainId: this.network.chainId,
+      };
+
+      // In this path we log an rpc response sample.
+      // Note: use performance.now() to ensure a purely monotonic clock.
+      const startTime = performance.now();
+      try {
+        const result = await super.send(method, params);
+        const elapsedTimeS = (performance.now() - startTime) / 1000;
+        this.logger.debug({
+          ...loggerArgs,
+          success: true,
+          timeElapsed: elapsedTimeS,
+        });
+        return result;
+      } catch (error) {
+        // Log errors as well.
+        // For now, to keep logs light, don't log the error itself, just propogate and let it be handled higher up.
+        const elapsedTimeS = (performance.now() - startTime) / 1000;
+        this.logger.debug({
+          ...loggerArgs,
+          success: false,
+          timeElapsed: elapsedTimeS,
+        });
+        throw error;
+      }
+    }
+  }
+
+  override send(method: string, params: Array<unknown>): Promise<unknown> {
+    // This simply creates a promise and adds the arguments and resolve and reject handlers to the task.
+    return new Promise<unknown>((resolve, reject) => {
+      const task: RateLimitTask = {
+        sendArgs: [method, params],
+        resolve,
+        reject,
+      };
+      // We didn't previously wait for this push so we can emulate
+      // the same behavior with the `void` keyword.
+      void this.queue.push(task);
+    });
+  }
+}

package/src/providers/retryProvider.ts

@@ -0,0 +1,262 @@
+import { ethers, logger } from "ethers";
+import { CachingMechanismInterface } from "../interfaces";
+import { delay, isDefined, isPromiseFulfilled, isPromiseRejected } from "../utils";
+import { getOriginFromURL } from "../utils/NetworkUtils";
+import { CacheProvider } from "./cachedProvider";
+import { compareRpcResults, createSendErrorWithMessage, formatProviderError } from "./utils";
+import { AugmentedLogger } from "@uma/logger";
+import { PROVIDER_CACHE_TTL } from "./constants";
+
+export class RetryProvider extends ethers.providers.StaticJsonRpcProvider {
+  readonly providers: ethers.providers.StaticJsonRpcProvider[];
+  constructor(
+    params: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>[],
+    chainId: number,
+    readonly nodeQuorumThreshold: number,
+    readonly retries: number,
+    readonly delay: number,
+    readonly maxConcurrency: number,
+    providerCacheNamespace: string,
+    pctRpcCallsLogged: number,
+    redisClient?: CachingMechanismInterface,
+    standardTtlBlockDistance?: number,
+    noTtlBlockDistance?: number,
+    providerCacheTtl = PROVIDER_CACHE_TTL,
+    logger?: AugmentedLogger
+  ) {
+    // Initialize the super just with the chainId, which stops it from trying to immediately send out a .send before
+    // this derived class is initialized.
+    super(undefined, chainId);
+    this.providers = params.map(
+      (inputs) =>
+        new CacheProvider(
+          providerCacheNamespace,
+          redisClient,
+          standardTtlBlockDistance,
+          noTtlBlockDistance,
+          providerCacheTtl,
+          maxConcurrency,
+          pctRpcCallsLogged,
+          logger,
+          ...inputs
+        )
+    );
+    if (this.nodeQuorumThreshold < 1 || !Number.isInteger(this.nodeQuorumThreshold)) {
+      throw new Error(
+        `nodeQuorum,Threshold cannot be < 1 and must be an integer. Currently set to ${this.nodeQuorumThreshold}`
+      );
+    }
+    if (this.retries < 0 || !Number.isInteger(this.retries)) {
+      throw new Error(`retries cannot be < 0 and must be an integer. Currently set to ${this.retries}`);
+    }
+    if (this.delay < 0) {
+      throw new Error(`delay cannot be < 0. Currently set to ${this.delay}`);
+    }
+    if (this.nodeQuorumThreshold > this.providers.length) {
+      throw new Error(
+        `nodeQuorumThreshold (${this.nodeQuorumThreshold}) must be <= the number of providers (${this.providers.length})`
+      );
+    }
+  }
+
+  override async send(method: string, params: Array<unknown>): Promise<unknown> {
+    const quorumThreshold = this._getQuorum(method, params);
+    const requiredProviders = this.providers.slice(0, quorumThreshold);
+    const fallbackProviders = this.providers.slice(quorumThreshold);
+    const errors: [ethers.providers.StaticJsonRpcProvider, string][] = [];
+
+    // This function is used to try to send with a provider and if it fails pop an element off the fallback list to try
+    // with that one. Once the fallback provider list is empty, the method throws. Because the fallback providers are
+    // removed, we ensure that no provider is used more than once because we care about quorum, making sure all
+    // considered responses come from unique providers.
+    const tryWithFallback = (
+      provider: ethers.providers.StaticJsonRpcProvider
+    ): Promise<[ethers.providers.StaticJsonRpcProvider, unknown]> => {
+      return this._trySend(provider, method, params)
+        .then((result): [ethers.providers.StaticJsonRpcProvider, unknown] => [provider, result])
+        .catch((err) => {
+          // Append the provider and error to the error array.
+          errors.push([provider, err?.stack || err?.toString()]);
+
+          // If there are no new fallback providers to use, terminate the recursion by throwing an error.
+          // Otherwise, we can try to call another provider.
+          if (fallbackProviders.length === 0) {
+            throw err;
+          }
+
+          // This line does two things:
+          // 1. Removes a fallback provider from the array so it cannot be used as a fallback for another required
+          // provider.
+          // 2. Recursively calls this method with that provider so it goes through the same try logic as the previous one.
+          return tryWithFallback(fallbackProviders.shift()!);
+        });
+    };
+
+    const results = await Promise.allSettled(requiredProviders.map(tryWithFallback));
+
+    if (!results.every(isPromiseFulfilled)) {
+      // Format the error so that it's very clear which providers failed and succeeded.
+      const errorTexts = errors.map(([provider, errorText]) => formatProviderError(provider, errorText));
+      const successfulProviderUrls = results.filter(isPromiseFulfilled).map((result) => result.value[0].connection.url);
+      throw createSendErrorWithMessage(
+        `Not enough providers succeeded. Errors:\n${errorTexts.join("\n")}\n` +
+          `Successful Providers:\n${successfulProviderUrls.join("\n")}`,
+        results.find(isPromiseRejected)?.reason
+      );
+    }
+
+    const values = results.map((result) => result.value);
+
+    // Start at element 1 and begin comparing.
+    // If _all_ values are equal, we have hit quorum, so return.
+    if (values.slice(1).every(([, output]) => compareRpcResults(method, values[0][1], output))) {
+      return values[0][1];
+    }
+
+    const throwQuorumError = () => {
+      const errorTexts = errors.map(([provider, errorText]) => formatProviderError(provider, errorText));
+      const successfulProviderUrls = values.map(([provider]) => provider.connection.url);
+      throw new Error(
+        "Not enough providers agreed to meet quorum.\n" +
+          "Providers that errored:\n" +
+          `${errorTexts.join("\n")}\n` +
+          "Providers that succeeded, but some failed to match:\n" +
+          successfulProviderUrls.join("\n")
+      );
+    };
+
+    // Exit early if there are no fallback providers left.
+    if (fallbackProviders.length === 0) {
+      throwQuorumError();
+    }
+
+    // Try each fallback provider in parallel.
+    const fallbackResults = await Promise.allSettled(
+      fallbackProviders.map((provider) =>
+        this._trySend(provider, method, params)
+          .then((result): [ethers.providers.StaticJsonRpcProvider, unknown] => [provider, result])
+          .catch((err) => {
+            errors.push([provider, err?.stack || err?.toString()]);
+            throw new Error("No fallbacks during quorum search");
+          })
+      )
+    );
+
+    // This filters only the fallbacks that succeeded.
+    const fallbackValues = fallbackResults.filter(isPromiseFulfilled).map((promise) => promise.value);
+
+    // Group the results by the count of that result.
+    const counts = [...values, ...fallbackValues].reduce(
+      (acc, curr) => {
+        const [, result] = curr;
+
+        // Find the first result that matches the return value.
+        const existingMatch = acc.find(([existingResult]) => compareRpcResults(method, existingResult, result));
+
+        // Increment the count if a match is found, else add a new element to the match array with a count of 1.
+        if (existingMatch) {
+          existingMatch[1]++;
+        } else {
+          acc.push([result, 1]);
+        }
+
+        // Return the same acc object because it was modified in place.
+        return acc;
+      },
+      [[undefined, 0]] as [unknown, number][] // Initialize with [undefined, 0] as the first element so something is always returned.
+    );
+
+    // Sort so the result with the highest count is first.
+    counts.sort(([, a], [, b]) => b - a);
+
+    // Extract the result by grabbing the first element.
+    const [quorumResult, count] = counts[0];
+
+    // If this count is less than we need for quorum, throw the quorum error.
+    if (count < quorumThreshold) {
+      throwQuorumError();
+    }
+
+    // If we've achieved quorum, then we should still log the providers that mismatched with the quorum result.
+    const mismatchedProviders = Object.fromEntries(
+      [...values, ...fallbackValues]
+        .filter(([, result]) => !compareRpcResults(method, result, quorumResult))
+        .map(([provider, result]) => [provider.connection.url, result])
+    );
+    const quorumProviders = [...values, ...fallbackValues]
+      .filter(([, result]) => compareRpcResults(method, result, quorumResult))
+      .map(([provider]) => provider.connection.url);
+    if (Object.keys(mismatchedProviders).length > 0 || errors.length > 0) {
+      logger.warn({
+        at: "ProviderUtils",
+        message: "Some providers mismatched with the quorum result or failed 🚸",
+        notificationPath: "across-warn",
+        method,
+        params,
+        quorumProviders,
+        mismatchedProviders,
+        erroringProviders: errors.map(([provider, errorText]) => formatProviderError(provider, errorText)),
+      });
+    }
+
+    return quorumResult;
+  }
+
+  _validateResponse(method: string, _: Array<unknown>, response: unknown): boolean {
+    // Basic validation logic to start.
+    // Note: eth_getTransactionReceipt is ignored here because null responses are expected in the case that ethers is
+    // polling for the transaction receipt and receiving null until it does.
+    return isDefined(response) || method === "eth_getTransactionReceipt";
+  }
+
+  async _sendAndValidate(
+    provider: ethers.providers.StaticJsonRpcProvider,
+    method: string,
+    params: Array<unknown>
+  ): Promise<unknown> {
+    const response = await provider.send(method, params);
+    if (!this._validateResponse(method, params, response)) {
+      // Not a warning to avoid spam since this could trigger a lot.
+      logger.debug({
+        at: "ProviderUtils",
+        message: "Provider returned invalid response",
+        provider: getOriginFromURL(provider.connection.url),
+        method,
+        params,
+        response,
+      });
+      throw new Error("Response failed validation");
+    }
+    return response;
+  }
+
+  _trySend(provider: ethers.providers.StaticJsonRpcProvider, method: string, params: Array<unknown>): Promise<unknown> {
+    let promise = this._sendAndValidate(provider, method, params);
+    for (let i = 0; i < this.retries; i++) {
+      promise = promise.catch(() => delay(this.delay).then(() => this._sendAndValidate(provider, method, params)));
+    }
+    return promise;
+  }
+
+  _getQuorum(method: string, params: Array<unknown>): number {
+    // Only use quorum if this is a historical query that doesn't depend on the current block number.
+
+    // All logs queries should use quorum.
+    if (method === "eth_getLogs") {
+      return this.nodeQuorumThreshold;
+    }
+
+    // getBlockByNumber should only use the quorum if it's not asking for the latest block.
+    if (method === "eth_getBlockByNumber" && params[0] !== "latest") {
+      return this.nodeQuorumThreshold;
+    }
+
+    // eth_call should only use quorum for queries at a specific past block.
+    if (method === "eth_call" && params[1] !== "latest") {
+      return this.nodeQuorumThreshold;
+    }
+
+    // All other calls should use quorum 1 to avoid errors due to sync differences.
+    return 1;
+  }
+}