@across-protocol/sdk 3.0.0

package/src/utils/ArrayUtils.ts

@@ -0,0 +1,170 @@
+/**
+ * Deduplicates an array by filtering it via a Set.
+ * @notice Should not be used for deduplicating arrays of complex types.
+ * @param array The array to deduplicate.
+ * @returns A new array, filtered for uniqueness.
+ */
+export function dedupArray<T>(array: T[]): T[] {
+  return Array.from(new Set(array));
+}
+
+/**
+ * Splits an arbitrary array into a series of chunks.
+ * @param array The array to chunk.
+ * @param chunkSize The maximum size of any chunk within the array.
+ * @returns A new array of chunked members.
+ */
+export function chunk<T>(array: T[], chunkSize: number): T[][] {
+  const chunks: T[][] = [];
+
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+
+  return chunks;
+}
+
+/**
+ * Returns the last index of an array that matches the given predicate.
+ * @note Emulates Array.prototype.findLastIndex
+ * @param array The array to search.
+ * @param predicate The predicate function to apply to each element.
+ * @returns The last index of the array that matches the predicate, or -1 if no element matches.
+ */
+export function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Returns the last element of an array that matches the given predicate.
+ * @note Emulates Array.prototype.findLast
+ * @param array The array to search.
+ * @param predicate The predicate function to apply to each element.
+ * @returns The last element of the array that matches the predicate, or undefined if no element matches.
+ */
+export function findLast<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined {
+  const index = findLastIndex(array, predicate);
+  return index >= 0 ? array[index] : undefined;
+}
+
+/**
+ * Performs an asynchronous filter operation on an array. This function behaves like Array.prototype.filter, but
+ * accepts an asynchronous predicate function.
+ * @param array The array to filter.
+ * @param predicate The asynchronous predicate function to apply to each element.
+ * @returns A promise that resolves to an array of elements that match the predicate.
+ */
+export async function filterAsync<T>(
+  array: T[],
+  predicate: (value: T, index: number, obj: T[]) => Promise<boolean>
+): Promise<T[]> {
+  const results = await Promise.all(array.map(predicate));
+  return array.filter((_, index) => results[index]);
+}
+
+/**
+ * Performs an asynchronous map operation on an array. This function behaves like Array.prototype.map, but accepts an
+ * asynchronous mapper function.
+ * @param array The array to map.
+ * @param mapper The asynchronous mapper function to apply to each element.
+ * @returns A promise that resolves to an array of mapped elements.
+ */
+export function mapAsync<T, U>(array: T[], mapper: (value: T, index: number, obj: T[]) => Promise<U>): Promise<U[]> {
+  return Promise.all(array.map(mapper));
+}
+
+/**
+ * Performs an asynchronous reduce operation on an array. This function behaves like Array.prototype.reduce, but
+ * accepts an asynchronous reducer function.
+ * @param array The array to reduce.
+ * @param reducer The asynchronous reducer function to apply to each element.
+ * @param initialValue The initial value of the accumulator.
+ * @returns A promise that resolves to the final value of the accumulator.
+ */
+export async function reduceAsync<T, U>(
+  array: T[],
+  reducer: (accumulator: U, currentValue: T, currentIndex: number, obj: T[]) => Promise<U>,
+  initialValue: U
+): Promise<U> {
+  let accumulator = initialValue;
+  for (let i = 0; i < array.length; i++) {
+    accumulator = await reducer(accumulator, array[i], i, array);
+  }
+  return accumulator;
+}
+
+/**
+ * Performs an asynchronous forEach operation on an array. This function behaves like Array.prototype.forEach, but
+ * accepts an asynchronous callback function.
+ * @param array The array to iterate over.
+ * @param callback The asynchronous callback function to apply to each element.
+ * @returns A promise that resolves to void.
+ */
+export async function forEachAsync<T>(
+  array: T[],
+  callback: (value: T, index: number, obj: T[]) => Promise<void>
+): Promise<void> {
+  await mapAsync(array, callback);
+}
+
+/**
+ * Performs an asynchronous some operation on an array. This function behaves like Array.prototype.some, but accepts
+ * an asynchronous predicate function.
+ * @param array The array to search.
+ * @param predicate The asynchronous predicate function to apply to each element.
+ * @returns A promise that resolves to true if any element matches the predicate, or false if no element matches.
+ */
+export async function someAsync<T>(
+  array: T[],
+  predicate: (value: T, index: number, obj: T[]) => Promise<boolean>
+): Promise<boolean> {
+  const results = await mapAsync(array, predicate);
+  return results.some((value) => value);
+}
+
+/**
+ * Performs an asynchronous every operation on an array. This function behaves like Array.prototype.every, but accepts
+ * an asynchronous predicate function.
+ * @param array The array to test.
+ * @param predicate The asynchronous predicate function to apply to each element.
+ * @returns A promise that resolves to true if all elements match the predicate, or false if any element does not match.
+ * @note This function uses De Morgan's law to convert the predicate to a negated predicate, and then uses someAsync.
+ *       This is done because it is more efficient to short-circuit on the first false value than the first true value.
+ */
+export async function everyAsync<T>(
+  array: T[],
+  predicate: (value: T, index: number, obj: T[]) => Promise<boolean>
+): Promise<boolean> {
+  return !(await someAsync(array, async (value, index, obj) => !(await predicate(value, index, obj))));
+}
+
+/**
+ * Performs an asynchronous includes operation on an array. This function behaves like Array.prototype.includes, but
+ * accepts an asynchronous predicate function.
+ * @param array The array to search.
+ * @param predicate The asynchronous predicate function to apply to each element.
+ * @returns A promise that resolves to true if any element matches the predicate, or false if no element matches.
+ * @note This function uses someAsync.
+ */
+export function includesAsync<T>(
+  array: T[],
+  predicate: (value: T, index: number, obj: T[]) => Promise<boolean>
+): Promise<boolean> {
+  return someAsync(array, predicate);
+}
+
+/**
+ * A generic type guard for arrays of a specific type.
+ * @param array The array to test.
+ * @param predicate The type guard predicate function to apply to each element.
+ * @returns True if the array is an array of the specified type, or false otherwise.
+ * @note This function uses Array.prototype.every.
+ */
+export function isArrayOf<T>(array: unknown, predicate: (value: unknown) => value is T): array is T[] {
+  return Array.isArray(array) && array.every(predicate);
+}

package/src/utils/BigNumberUtils.ts

@@ -0,0 +1,58 @@
+/**
+ * @file Responsible for providing utility functions for working with BigNumbers.
+ * @module utils/BigNumberUtils
+ * @author Across Protocol
+ */
+
+import { ethers, BigNumber } from "ethers";
+
+export type BigNumberish = ethers.BigNumberish;
+export type BN = ethers.BigNumber;
+
+export const { Zero: bnZero, One: bnOne, MaxUint256: bnUint256Max } = ethers.constants;
+
+export const bnUint32Max = BigNumber.from("0xffffffff");
+
+/**
+ * Converts a stringified number into a BigNumber with 18 decimal places.
+ * @param num The number to parse.
+ * @returns The parsed BigNumber.
+ */
+export function toWei(num: BigNumberish): BN {
+  return ethers.utils.parseEther(num.toString());
+}
+
+/**
+ * Converts a stringified number into a BigNumber with 9 decimal places.
+ * @param num The number to parse.
+ * @returns The parsed BigNumber.
+ */
+export function toGWei(num: BigNumberish): BN {
+  return ethers.utils.parseUnits(num.toString(), 9);
+}
+
+/**
+ * Converts a stringified number into a BigNumber.
+ * If the string version of the num contains a `.` then it is a number which needs to be parsed to a string int.
+ * @param num The number to parse.
+ * @param rounding The rounding method to use if the number has a decimal point. Defaults to "floor" or rounding down. Valid values are "floor", "round", and "ceil".
+ * @returns The parsed BigNumber.
+ * @note This is a temporary function until we can backport support for decimal points to @across-protocol/sdk.
+ */
+export const toBN = (num: BigNumberish, rounding: "floor" | "round" | "ceil" = "floor"): BN => {
+  // If the string version of the num contains a `.` then it is a number which needs to be parsed to a string int.
+  if (num.toString().includes(".")) {
+    // Destructure the integer and decimal parts of the number.
+    const [integer, decimal] = num.toString().split(".");
+    // We can determine if we need to round in a losseless way. First we need to check
+    // if the number just has a decimal point with no decimal places. If it does, we
+    // can just return the integer. However, if it has a decimal point with decimal
+    // places, then we can automatically round up if ceil is specified or if round is
+    // specified and the first decimal is greater than or equal to 5.
+    const roundUp = decimal.length > 0 && (rounding === "ceil" || (rounding === "round" && parseInt(decimal[0]) >= 5));
+    // If we need to round up, we can just add 1 to the integer.
+    return BigNumber.from(integer).add(roundUp ? 1 : 0);
+  }
+  // Otherwise, it is a string int and we can parse it directly.
+  return BigNumber.from(num.toString());
+};

package/src/utils/BlockExplorerUtils.ts

@@ -0,0 +1,91 @@
+import { ethers } from "ethers";
+import { PUBLIC_NETWORKS } from "../constants";
+import { createShortHexString } from "./FormattingUtils";
+import { isDefined } from "./TypeGuards";
+
+/**
+ * Creates a block explorer link for a transaction or address on a given network.
+ * @param txHashOrAddress The transaction hash or address to link to.
+ * @param chainId The chainId to link to.
+ * @returns The block explorer link. This link will be formatted in markdown.
+ */
+export function blockExplorerLink(txHashOrAddress: string, chainId: number | string): string {
+  return _createBlockExplorerLinkMarkdown(txHashOrAddress, Number(chainId)) ?? "<>";
+}
+
+/**
+ * Resolves a domain to an block explorer link for a given network.
+ * @param networkId The network to link to.
+ * @returns The block explorer link. If the networkId is not supported, undefined will be returned.
+ */
+export function resolveBlockExplorerDomain(networkId: number): string | undefined {
+  return PUBLIC_NETWORKS[networkId]?.blockExplorer;
+}
+
+/**
+ * Constructs a URL for a given list of domain parts.
+ * @param domain The domain to construct a URL for.
+ * @param parts The relative path of parts to append to the domain. These parts will be joined with a "/".
+ * @returns The constructed URL.
+ * @see resolveBlockExplorerDomain
+ * @example constructURL("https://example.com", ["path", "to", "resource"]) => "https://example.com/path/to/resource"
+ * @example constructURL("https://example.com", ["path", "to", "resource", ""]) => "https://example.com/path/to/resource"
+ * @example constructURL("https://example.com", ["path", "to//", "resource",]) => "https://example.com/path/to/resource"
+ */
+function constructURL(domain: string, parts: string[]): string {
+  // Further split the parts by "/" to handle any parts that contain multiple "/".
+  parts = parts.flatMap((p) => p.split("/"));
+  // Remove any empty parts.
+  parts = parts.filter((p) => p !== "");
+  // Join the parts with a "/".
+  const path = parts.join("/");
+  // Remove any trailing "/".
+  return `${domain}/${path}`.replace(/\/+$/, "");
+}
+
+/**
+ * Generates a valid block explorer link for a given transaction hash or address.
+ * @param hex The transaction hash or address to link to.
+ * @param chainId The chainId to link to.
+ * @returns A formatted markdown block explorer link to the given transaction hash or address on the given chainId.
+ */
+function _createBlockExplorerLinkMarkdown(hex: string, chainId = 1): string | null {
+  // Attempt to resolve the block explorer domain for the given chainId.
+  const explorerDomain = resolveBlockExplorerDomain(chainId);
+  // If the chainId is not supported, return an unsupported link.
+  if (!isDefined(explorerDomain)) {
+    return `<unsupported chain/hash ${chainId}:${hex}>}`;
+  }
+  // Ensure that the first two characters are "0x". If they are not, append them.
+  if (hex.substring(0, 2) !== "0x") {
+    hex = `0x${hex}`;
+  }
+  // Ensure that the hex string is a valid hexadecimal string.
+  if (!ethers.utils.isHexString(hex)) {
+    return null;
+  }
+  // Resolve the short URL string.
+  const shortURLString = createShortHexString(hex);
+  // Iterate over the two possible hex lengths.
+  for (const [length, route] of [
+    [66, "tx"],
+    [42, "address"],
+  ] as [number, string][]) {
+    // If the hex string is the correct length, return the link.
+    if (hex.length === length) {
+      return `<${constructURL(explorerDomain, [route, hex])}|${shortURLString}>`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Generates a list of blockExplorer links for a given list of transaction hashes or addresses.
+ * @param txHashesOrAddresses The list of transaction hashes or addresses to link to.
+ * @param chainId The chainId to link to.
+ * @returns A list of formatted markdown block explorer links to the given transaction hashes or addresses on the given chainId.
+ * @see blockExplorerLink
+ */
+export function blockExplorerLinks(txHashesOrAddresses: string[], chainId: number | string): string {
+  return txHashesOrAddresses.map((hash) => `${blockExplorerLink(hash, chainId)}\n`).join("");
+}

package/src/utils/BlockUtils.ts

@@ -0,0 +1,265 @@
+import assert from "assert";
+import type { Block, Provider } from "@ethersproject/abstract-provider";
+import { clamp, sortedIndexBy } from "lodash";
+import { getNetworkName } from "./NetworkUtils";
+import { isDefined } from "./TypeGuards";
+import { getCurrentTime } from "./TimeUtils";
+import { CachingMechanismInterface } from "../interfaces";
+import { shouldCache } from "./CachingUtils";
+import { DEFAULT_CACHING_SAFE_LAG } from "../constants";
+
+type Opts = {
+  highBlock?: number;
+  highBlockOffset?: number;
+  blockRange?: number;
+};
+
+type BlockTimeAverage = {
+  average: number;
+  blockRange: number;
+  timestamp: number;
+};
+
+// Archive requests typically commence at 128 blocks past the head of the chain.
+// Round down to 120 blocks to avoid slipping into archive territory.
+const defaultBlockRange = 120;
+
+// Default offset to the high block number. This is subtracted from the block number of the high block
+// when it is queried from the network, rather than having been specified by the caller. This is useful
+// since the supplied Provider instance may be backed by multiple RPC providers, which can lead to some
+// providers running slower than others and taking time to synchronise on the latest block.
+const defaultHighBlockOffset = 10;
+
+// Retain computations for 15 minutes.
+const cacheTTL = 60 * 15;
+const now = getCurrentTime(); // Seed the cache with initial values.
+const blockTimes: { [chainId: number]: BlockTimeAverage } = {
+  1: { average: 12.5, timestamp: now, blockRange: 1 },
+  10: { average: 2, timestamp: now, blockRange: 1 },
+  8453: { average: 2, timestamp: now, blockRange: 1 },
+  34443: { average: 2, timestamp: now, blockRange: 1 },
+  59144: { average: 3, timestamp: now, blockRange: 1 },
+};
+
+/**
+ * @description Compute the average block time over a block range.
+ * @returns Average number of seconds per block.
+ */
+export async function averageBlockTime(
+  provider: Provider,
+  { highBlock, highBlockOffset, blockRange }: Opts = {}
+): Promise<Pick<BlockTimeAverage, "average" | "blockRange">> {
+  // Does not block for StaticJsonRpcProvider.
+  const chainId = (await provider.getNetwork()).chainId;
+
+  const cache = blockTimes[chainId];
+  const now = getCurrentTime();
+  if (isDefined(cache) && now < cache.timestamp + cacheTTL) {
+    return { average: cache.average, blockRange: cache.blockRange };
+  }
+
+  // If the caller was not specific about highBlock, resolve it via the RPC provider. Subtract an offset
+  // to account for various RPC provider sync issues that might occur when querting the latest block.
+  if (!isDefined(highBlock)) {
+    highBlock = await provider.getBlockNumber();
+    highBlock -= highBlockOffset ?? defaultHighBlockOffset;
+  }
+  blockRange ??= defaultBlockRange;
+
+  const earliestBlockNumber = highBlock - blockRange;
+  const [firstBlock, lastBlock] = await Promise.all([
+    provider.getBlock(earliestBlockNumber),
+    provider.getBlock(highBlock),
+  ]);
+  [firstBlock, lastBlock].forEach((block: Block | undefined) => {
+    if (!isDefined(block?.timestamp)) {
+      const network = getNetworkName(chainId);
+      const blockNumber = block === firstBlock ? earliestBlockNumber : highBlock;
+      throw new Error(`BlockFinder: Failed to fetch block ${blockNumber} on ${network}`);
+    }
+  });
+
+  const average = (lastBlock.timestamp - firstBlock.timestamp) / blockRange;
+  blockTimes[chainId] = { timestamp: now, average, blockRange };
+
+  return { average, blockRange };
+}
+
+async function estimateBlocksElapsed(seconds: number, cushionPercentage = 0.0, provider: Provider): Promise<number> {
+  const cushionMultiplier = cushionPercentage + 1.0;
+  const { average } = await averageBlockTime(provider);
+  return Math.floor((seconds * cushionMultiplier) / average);
+}
+
+export type BlockFinderHints = {
+  lowBlock?: number;
+  highBlock?: number;
+};
+
+export class BlockFinder {
+  constructor(
+    private readonly provider: Provider,
+    private readonly blocks: Block[] = []
+  ) {}
+
+  /**
+   * @notice Gets the latest block whose timestamp is <= the provided timestamp.
+   * @param number Timestamp timestamp to search.
+   * @param hints Optional low and high block to bound the search space.
+   */
+  public async getBlockForTimestamp(timestamp: number | string, hints: BlockFinderHints = {}): Promise<Block> {
+    timestamp = Number(timestamp);
+    assert(timestamp !== undefined && timestamp !== null, "timestamp must be provided");
+    // If the last block we have stored is too early, grab the latest block.
+    if (this.blocks.length === 0 || this.blocks[this.blocks.length - 1].timestamp < timestamp) {
+      const block = await this.getLatestBlock();
+      if (timestamp >= block.timestamp) return block;
+    }
+
+    // Prime the BlockFinder cache with any supplied hints.
+    // If the hint is accurate, then this will bypass the subsequent estimation.
+    await Promise.all(
+      Object.values(hints)
+        .filter((blockNumber) => isDefined(blockNumber))
+        .map((blockNumber) => this.getBlock(blockNumber))
+    );
+
+    // Check the first block. If it's greater than our timestamp, we need to find an earlier block.
+    if (this.blocks[0].timestamp > timestamp) {
+      const initialBlock = this.blocks[0];
+      // We use a 2x cushion to reduce the number of iterations in the following loop and increase the chance
+      // that the first block we find sets a floor for the target timestamp. The loop converges on the correct block
+      // slower than the following incremental search performed by `findBlock`, so we want to minimize the number of
+      // loop iterations in favor of searching more blocks over the `findBlock` search.
+      const cushion = 1;
+      const incrementDistance = Math.max(
+        // Ensure the increment block distance is _at least_ a single block to prevent an infinite loop.
+        await estimateBlocksElapsed(initialBlock.timestamp - timestamp, cushion, this.provider),
+        1
+      );
+
+      // Search backwards by a constant increment until we find a block before the timestamp or hit block 0.
+      for (let multiplier = 1; ; multiplier++) {
+        const distance = multiplier * incrementDistance;
+        const blockNumber = Math.max(0, initialBlock.number - distance);
+        const block = await this.getBlock(blockNumber);
+        if (block.timestamp <= timestamp) break; // Found an earlier block.
+        assert(blockNumber > 0, "timestamp is before block 0"); // Block 0 was not earlier than this timestamp. The row.
+      }
+    }
+
+    // Find the index where the block would be inserted and use that as the end block (since it is >= the timestamp).
+    const index = sortedIndexBy(this.blocks, { timestamp } as Block, "timestamp");
+    return this.findBlock(this.blocks[index - 1], this.blocks[index], timestamp);
+  }
+
+  // Grabs the most recent block and caches it.
+  private async getLatestBlock() {
+    const block = await this.provider.getBlock("latest");
+    const index = sortedIndexBy(this.blocks, block, "number");
+    if (this.blocks[index]?.number !== block.number) this.blocks.splice(index, 0, block);
+    return this.blocks[index];
+  }
+
+  // Grabs the block for a particular number and caches it.
+  private async getBlock(number: number) {
+    let index = sortedIndexBy(this.blocks, { number } as Block, "number");
+    if (this.blocks[index]?.number === number) return this.blocks[index]; // Return early if block already exists.
+    const block = await this.provider.getBlock(number);
+
+    // Recompute the index after the async call since the state of this.blocks could have changed!
+    index = sortedIndexBy(this.blocks, { number } as Block, "number");
+
+    // Rerun this check to avoid duplicate insertion.
+    if (this.blocks[index]?.number === number) return this.blocks[index];
+    this.blocks.splice(index, 0, block); // A simple insert at index.
+    return block;
+  }
+
+  // Return the latest block, between startBlock and endBlock, whose timestamp is <= timestamp.
+  // Effectively, this is an interpolation search algorithm to minimize block requests.
+  // Note: startBlock and endBlock _must_ be different blocks.
+  private async findBlock(_startBlock: Block, _endBlock: Block, timestamp: number): Promise<Block> {
+    const [startBlock, endBlock] = [_startBlock, _endBlock];
+    // In the case of equality, the endBlock is expected to be passed as the one whose timestamp === the requested
+    // timestamp.
+    if (endBlock.timestamp === timestamp) return endBlock;
+
+    // If there's no equality, but the blocks are adjacent, return the startBlock, since we want the returned block's
+    // timestamp to be <= the requested timestamp.
+    if (endBlock.number === startBlock.number + 1) return startBlock;
+
+    assert(endBlock.number !== startBlock.number, "startBlock cannot equal endBlock");
+    assert(
+      timestamp < endBlock.timestamp && timestamp > startBlock.timestamp,
+      "timestamp not in between start and end blocks"
+    );
+
+    // Interpolating the timestamp we're searching for to block numbers.
+    const totalTimeDifference = endBlock.timestamp - startBlock.timestamp;
+    const totalBlockDistance = endBlock.number - startBlock.number;
+    const blockPercentile = (timestamp - startBlock.timestamp) / totalTimeDifference;
+    const estimatedBlock = startBlock.number + Math.round(blockPercentile * totalBlockDistance);
+
+    // Clamp ensures the estimated block is strictly greater than the start block and strictly less than the end block.
+    const newBlock = await this.getBlock(clamp(estimatedBlock, startBlock.number + 1, endBlock.number - 1));
+
+    // Depending on whether the new block is below or above the timestamp, narrow the search space accordingly.
+    if (newBlock.timestamp < timestamp) {
+      return this.findBlock(newBlock, endBlock, timestamp);
+    } else {
+      return this.findBlock(startBlock, newBlock, timestamp);
+    }
+  }
+}
+
+/**
+ * @notice Get the block number for a given timestamp fresh from on-chain data if not found in redis cache.
+ * If redis cache is not available, then requests block from blockFinder.
+ * @param chainId Chain to load block finder for.
+ * @param timestamp Approximate timestamp of the to requested block number.
+ * @param blockFinder Caller can optionally pass in a block finder object to use instead of creating a new one
+ * or loading from cache. This is useful for testing primarily.
+ * @returns Block number for the requested timestamp.
+ */
+export async function getCachedBlockForTimestamp(
+  chainId: number,
+  timestamp: number,
+  blockFinder: BlockFinder,
+  cache?: CachingMechanismInterface,
+  hints?: BlockFinderHints
+): Promise<number> {
+  // Resolve a convenience function to directly compute what we're
+  // looking for.
+  const resolver = async () => (await blockFinder.getBlockForTimestamp(timestamp, hints)).number;
+
+  // If no redis client, then request block from blockFinder.
+  if (!isDefined(cache)) {
+    return resolver();
+  }
+
+  // Cache exists. We should first check if it's possible to retrieve the block number from cache.
+
+  // Resolve the key for the block number.
+  const key = `${chainId}_block_number_${timestamp}`;
+  // See if it's even possible to retrieve the block number from cache.
+  if (shouldCache(timestamp, getCurrentTime(), DEFAULT_CACHING_SAFE_LAG)) {
+    // Attempt to retrieve the block number from cache.
+    const result = await cache.get<string>(key);
+    // If the block number is in cache, then return it.
+    if (result !== null) {
+      return parseInt(result);
+    }
+    // Otherwise, we need to resolve the block number and cache it.
+    else {
+      const blockNumber = await resolver();
+      // Expire key after 90 days.
+      await cache.set(key, blockNumber.toString(), 60 * 60 * 24 * 90); // 90 days
+      return blockNumber;
+    }
+  }
+  // It's too early to cache this key. Resolve the block number and return it.
+  else {
+    return resolver();
+  }
+}