@across-protocol/sdk 3.0.0

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -0,0 +1,341 @@
+import assert from "assert";
+import { BigNumber, Contract, Event, providers } from "ethers";
+import { random } from "lodash";
+import winston from "winston";
+import { ZERO_ADDRESS } from "../../constants";
+import {
+  DepositWithBlock,
+  FillType,
+  V3FundsDepositedEvent,
+  RealizedLpFee,
+  RelayerRefundExecutionWithBlock,
+  SlowFillRequestWithBlock,
+  Fill,
+  FillWithBlock,
+  SlowFillLeaf,
+  SpeedUp,
+} from "../../interfaces";
+import { bnZero, toBN, toBNWei, forEachAsync, getCurrentTime, randomAddress } from "../../utils";
+import { SpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
+import { HubPoolClient } from "../HubPoolClient";
+import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
+
+type Block = providers.Block;
+
+// This class replaces internal SpokePoolClient functionality, enabling the
+// user to bypass on-chain queries and inject ethers Event objects directly.
+export class MockSpokePoolClient extends SpokePoolClient {
+  public eventManager: EventManager;
+  private realizedLpFeePct: BigNumber = bnZero;
+  private realizedLpFeePctOverride = false;
+  private destinationTokenForChainOverride: Record<number, string> = {};
+  // Allow tester to set the numberOfDeposits() returned by SpokePool at a block height.
+  public depositIdAtBlock: number[] = [];
+  public numberOfDeposits = 0;
+  public blocks: Record<number, Block> = {};
+
+  constructor(
+    logger: winston.Logger,
+    spokePool: Contract,
+    chainId: number,
+    deploymentBlock: number,
+    opts: { hubPoolClient: HubPoolClient | null } = { hubPoolClient: null }
+  ) {
+    super(logger, spokePool, opts.hubPoolClient, chainId, deploymentBlock);
+    this.latestBlockSearched = deploymentBlock;
+    this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
+  }
+
+  setDefaultRealizedLpFeePct(fee: BigNumber): void {
+    this.realizedLpFeePct = fee;
+    this.realizedLpFeePctOverride = true;
+  }
+
+  clearDefaultRealizedLpFeePct(): void {
+    this.realizedLpFeePctOverride = false;
+  }
+
+  async computeRealizedLpFeePct(depositEvent: V3FundsDepositedEvent) {
+    const { realizedLpFeePct, realizedLpFeePctOverride } = this;
+    const { blockNumber: quoteBlock } = depositEvent;
+    return realizedLpFeePctOverride
+      ? { realizedLpFeePct, quoteBlock }
+      : await super.computeRealizedLpFeePct(depositEvent);
+  }
+
+  async batchComputeRealizedLpFeePct(depositEvents: V3FundsDepositedEvent[]): Promise<RealizedLpFee[]> {
+    const { realizedLpFeePct, realizedLpFeePctOverride } = this;
+    return realizedLpFeePctOverride
+      ? depositEvents.map(({ blockNumber: quoteBlock }) => {
+          return { realizedLpFeePct, quoteBlock };
+        })
+      : await super.batchComputeRealizedLpFeePct(depositEvents);
+  }
+
+  setDestinationTokenForChain(chainId: number, token: string): void {
+    this.destinationTokenForChainOverride[chainId] = token;
+  }
+
+  getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
+    return this.destinationTokenForChainOverride[deposit.originChainId] ?? super.getDestinationTokenForDeposit(deposit);
+  }
+
+  setLatestBlockNumber(blockNumber: number): void {
+    this.latestBlockSearched = blockNumber;
+  }
+
+  setDepositIds(_depositIds: number[]): void {
+    this.depositIdAtBlock = [];
+    if (_depositIds.length === 0) {
+      return;
+    }
+    let lastDepositId = _depositIds[0];
+    for (let i = 0; i < _depositIds.length; i++) {
+      if (_depositIds[i] < lastDepositId) {
+        throw new Error("deposit ID must be equal to or greater than previous");
+      }
+      this.depositIdAtBlock[i] = _depositIds[i];
+      lastDepositId = _depositIds[i];
+    }
+  }
+  _getDepositIdAtBlock(blockTag: number): Promise<number> {
+    return Promise.resolve(this.depositIdAtBlock[blockTag]);
+  }
+
+  async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
+    // Generate new "on chain" responses.
+    const latestBlockSearched = this.eventManager.blockNumber;
+    const currentTime = getCurrentTime();
+
+    const blocks: { [blockNumber: number]: Block } = {};
+
+    // Ensure an array for every requested event exists, in the requested order.
+    // All requested event types must be populated in the array (even if empty).
+    const events: Event[][] = eventsToQuery.map(() => []);
+    await forEachAsync(this.eventManager.getEvents().flat(), async (event) => {
+      const idx = eventsToQuery.indexOf(event.event as string);
+      if (idx !== -1) {
+        events[idx].push(event);
+        blocks[event.blockNumber] = await event.getBlock();
+      }
+    });
+    this.blocks = blocks;
+
+    // Update latestDepositIdQueried.
+    const idx = eventsToQuery.indexOf("V3FundsDeposited");
+    const latestDepositId = (events[idx] ?? []).reduce(
+      (depositId, event) => Math.max(depositId, event.args?.["depositId"] ?? 0),
+      this.latestDepositIdQueried
+    );
+
+    return {
+      success: true,
+      firstDepositId: 0,
+      latestDepositId,
+      currentTime,
+      oldestTime: 0,
+      events,
+      searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
+      hasCCTPBridgingEnabled: false,
+    };
+  }
+
+  // Event signatures. Not strictly required, but they make generated events more recognisable.
+  public readonly eventSignatures: Record<string, string> = {
+    EnabledDepositRoute: "address,uint256,bool",
+    FilledRelay: "uint256,uint256,uint256,int64,uint32,uint32,address,address,address,bytes",
+    FundsDeposited: "uint256,uint256,uint256,int64,uint32,uint32,address,address,address,bytes",
+  };
+
+  depositV3(deposit: DepositWithBlock): Event {
+    const event = "V3FundsDeposited";
+
+    const { blockNumber, transactionIndex } = deposit;
+    let { depositId, depositor, destinationChainId, inputToken, inputAmount, outputToken, outputAmount } = deposit;
+    depositId ??= this.numberOfDeposits;
+    assert(depositId >= this.numberOfDeposits, `${depositId} < ${this.numberOfDeposits}`);
+    this.numberOfDeposits = depositId + 1;
+
+    destinationChainId ??= random(1, 42161, false);
+    depositor ??= randomAddress();
+    inputToken ??= randomAddress();
+    outputToken ??= inputToken;
+    inputAmount ??= toBNWei(random(1, 1000, false));
+    outputAmount ??= inputAmount.mul(toBN("0.95"));
+
+    const message = deposit["message"] ?? `${event} event at block ${blockNumber}, index ${transactionIndex}.`;
+    const topics = [destinationChainId, depositId, depositor];
+    const quoteTimestamp = deposit.quoteTimestamp ?? getCurrentTime();
+    const args = {
+      depositId,
+      originChainId: deposit.originChainId ?? this.chainId,
+      destinationChainId,
+      depositor,
+      recipient: deposit.recipient ?? depositor,
+      inputToken,
+      inputAmount,
+      outputToken,
+      outputAmount,
+      quoteTimestamp,
+      fillDeadline: deposit.fillDeadline ?? quoteTimestamp + 3600,
+      exclusiveRelayer: deposit.exclusiveRelayer ?? ZERO_ADDRESS,
+      exclusivityDeadline: deposit.exclusivityDeadline ?? quoteTimestamp + 600,
+      message,
+    };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber,
+      transactionIndex,
+    });
+  }
+
+  fillV3Relay(fill: FillWithBlock): Event {
+    const event = "FilledV3Relay";
+
+    const { blockNumber, transactionIndex } = fill;
+    let { originChainId, depositId, inputToken, inputAmount, outputAmount, fillDeadline, relayer } = fill;
+    originChainId ??= random(1, 42161, false);
+    depositId ??= random(1, 100_000, false);
+    inputToken ??= randomAddress();
+    inputAmount ??= toBNWei(random(1, 1000, false));
+    outputAmount ??= inputAmount;
+    fillDeadline ??= getCurrentTime() + 60;
+    relayer ??= randomAddress();
+
+    const topics = [originChainId, depositId, relayer];
+    const recipient = fill.recipient ?? randomAddress();
+    const message = fill["message"] ?? `${event} event at block ${blockNumber}, index ${transactionIndex}.`;
+
+    const args = {
+      inputToken,
+      outputToken: fill.outputToken ?? ZERO_ADDRESS, // resolved via HubPoolClient.
+      inputAmount: fill.inputAmount,
+      outputAmount: fill.outputAmount,
+      repaymentChainId: fill.repaymentChainId ?? this.chainId,
+      originChainId,
+      depositId,
+      fillDeadline,
+      exclusivityDeadline: fill.exclusivityDeadline ?? fillDeadline,
+      exclusiveRelayer: fill.exclusiveRelayer ?? ZERO_ADDRESS,
+      relayer,
+      depositor: fill.depositor ?? randomAddress(),
+      recipient,
+      message,
+      relayExecutionInfo: {
+        updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
+        updatedMessage: fill.relayExecutionInfo?.updatedMessage ?? message,
+        updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
+        fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
+      },
+    };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber,
+      transactionIndex,
+    });
+  }
+
+  speedUpV3Deposit(speedUp: SpeedUp): Event {
+    const event = "RequestedSpeedUpV3Deposit";
+    const topics = [speedUp.depositId, speedUp.depositor];
+    const args = { ...speedUp };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+    });
+  }
+
+  requestV3SlowFill(request: SlowFillRequestWithBlock): Event {
+    const event = "RequestedV3SlowFill";
+
+    const { originChainId, depositId } = request;
+    const topics = [originChainId, depositId];
+    const args = { ...request };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber: request.blockNumber,
+      transactionIndex: request.transactionIndex,
+    });
+  }
+
+  // This is a simple wrapper around fillV3Relay().
+  // rootBundleId and proof are discarded here - we have no interest in verifying that.
+  executeV3SlowRelayLeaf(leaf: SlowFillLeaf): Event {
+    const fill: Fill = {
+      ...leaf.relayData,
+      destinationChainId: this.chainId,
+      relayer: ZERO_ADDRESS,
+      repaymentChainId: 0,
+      relayExecutionInfo: {
+        updatedRecipient: leaf.relayData.recipient,
+        updatedOutputAmount: leaf.updatedOutputAmount,
+        updatedMessage: leaf.relayData.message,
+        fillType: FillType.SlowFill,
+      },
+    };
+
+    return this.fillV3Relay(fill as FillWithBlock);
+  }
+
+  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Event {
+    const event = "ExecutedRelayerRefundRoot";
+
+    const chainId = refund.chainId ?? this.chainId;
+    assert(chainId === this.chainId);
+
+    const { rootBundleId, leafId } = refund;
+    const topics = [chainId, rootBundleId, leafId];
+    const args = {
+      chainId,
+      rootBundleId,
+      leafId,
+      amountToReturn: refund.amountToReturn,
+      l2TokenAddress: refund.l2TokenAddress,
+      refundAddresses: refund.refundAddresses,
+      refundAmounts: refund.refundAmounts,
+    };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber: refund.blockNumber,
+    });
+  }
+
+  setEnableRoute(
+    originToken: string,
+    destinationChainId: number,
+    enabled: boolean,
+    overrides: EventOverrides = {}
+  ): Event {
+    const event = "EnabledDepositRoute";
+
+    const topics = [originToken, destinationChainId];
+    const args = { originToken, destinationChainId, enabled };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.spokePool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber: overrides.blockNumber,
+    });
+  }
+}

package/src/clients/mocks/index.ts

@@ -0,0 +1,3 @@
+export * from "./MockConfigStoreClient";
+export * from "./MockHubPoolClient";
+export * from "./MockSpokePoolClient";

package/src/coingecko/Coingecko.ts

@@ -0,0 +1,277 @@
+import axios, { AxiosError } from "axios";
+import assert from "assert";
+import get from "lodash.get";
+import { retry } from "../utils";
+import { Logger } from "../relayFeeCalculator";
+
+export function msToS(ms: number) {
+  return Math.floor(ms / 1000);
+}
+
+export type CoinGeckoAssetPlatform = {
+  id: string;
+  chain_identifier: number;
+  name: string;
+  shortname: string;
+};
+
+export type CoinGeckoPrice = {
+  address: string;
+  timestamp: number;
+  price: number;
+};
+
+type PriceCache = {
+  [chain: string]: {
+    [currency: string]: {
+      [address: string]: CoinGeckoPrice;
+    };
+  };
+};
+
+// Singleton Coingecko class.
+export class Coingecko {
+  private static instance: Coingecko | undefined;
+  private prices: PriceCache;
+  private _maxPriceAge = 300; // seconds
+
+  // Retry configuration.
+  private retryDelay = 1;
+  private numRetries = 0; // Most failures are due to 429 rate-limiting, so there is no point in retrying.
+  private basicApiTimeout = 500; // ms
+
+  public static get(logger: Logger, apiKey?: string) {
+    if (!this.instance)
+      this.instance = new Coingecko(
+        "https://api.coingecko.com/api/v3",
+        "https://pro-api.coingecko.com/api/v3",
+        logger,
+        apiKey
+      );
+    return this.instance;
+  }
+
+  get maxPriceAge(): number {
+    return this._maxPriceAge;
+  }
+
+  set maxPriceAge(age: number) {
+    assert(age >= 0);
+    this.logger.debug({
+      at: "Coingecko#maxPriceAge",
+      message: `Setting maxPriceAge (S) ${this._maxPriceAge} => ${age}.`,
+    });
+    this._maxPriceAge = age;
+  }
+
+  protected constructor(
+    private readonly host: string,
+    private readonly proHost: string,
+    private readonly logger: Logger,
+    private readonly apiKey?: string
+  ) {
+    this.prices = {};
+  }
+
+  // Fetch historic prices for a `contract` denominated in `currency` between timestamp `from` and `to`. Note timestamps
+  // are assumed to be js timestamps and are converted to unixtimestamps by dividing by 1000.
+  async getHistoricContractPrices(contract: string, from: number, to: number, currency = "usd") {
+    assert(contract, "requires contract address");
+    assert(currency, "requires currency symbol");
+    assert(from, "requires from timestamp");
+    assert(to, "requires to timestamp");
+    const _from = msToS(from);
+    const _to = msToS(to);
+    const result = await this.call(
+      `coins/ethereum/contract/${contract.toLowerCase()}/market_chart/range/?vs_currency=${currency}&from=${_from}&to=${_to}`
+    );
+    // fyi timestamps are returned in ms in contrast to the current price endpoint
+    if (result.prices) return result.prices;
+    throw new Error("Something went wrong fetching coingecko prices!");
+  }
+  getContractDetails(contract_address: string, platform_id = "ethereum") {
+    return this.call(`coins/${platform_id}/contract/${contract_address.toLowerCase()}`);
+  }
+  async getCurrentPriceByContract(
+    contract_address: string,
+    currency = "usd",
+    platform_id = "ethereum"
+  ): Promise<[string, number]> {
+    const priceCache: { [addr: string]: CoinGeckoPrice } = this.getPriceCache(currency, platform_id);
+    const now: number = msToS(Date.now());
+    let tokenPrice: CoinGeckoPrice | undefined = priceCache[contract_address];
+
+    if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
+      if (this.maxPriceAge > 0) {
+        this.logger.debug({
+          at: "Coingecko#getCurrentPriceByContract",
+          message: `Cache miss on ${platform_id}/${currency} for ${contract_address}`,
+          maxPriceAge: this.maxPriceAge,
+          tokenPrice: tokenPrice,
+        });
+      }
+
+      await this.getContractPrices([contract_address], currency, platform_id);
+      tokenPrice = priceCache[contract_address];
+    } else {
+      this.logger.debug({
+        at: "Coingecko#getCurrentPriceByContract",
+        message: `Cache hit on token ${contract_address} (age ${now - tokenPrice.timestamp} S).`,
+        price: tokenPrice,
+      });
+    }
+
+    assert(tokenPrice !== undefined);
+    return [tokenPrice.timestamp.toString(), tokenPrice.price];
+  }
+  // Return an array of spot prices for an array of collateral addresses in one async call. Note we might in future
+  // This was adapted from packages/merkle-distributor/kpi-options-helpers/calculate-uma-tvl.ts
+  async getContractPrices(
+    addresses: Array<string>,
+    currency = "usd",
+    platform_id = "ethereum"
+  ): Promise<CoinGeckoPrice[]> {
+    const priceCache: { [addr: string]: CoinGeckoPrice } = this.getPriceCache(currency, platform_id);
+
+    // Pre-populate price cache with requested token addresses
+    addresses.forEach((addr: string) => {
+      if (priceCache[addr] === undefined) {
+        priceCache[addr] = { address: addr, price: 0, timestamp: 0 };
+      }
+    });
+
+    // Collect all known token addresses (requested + other cached).
+    const contract_addresses: string[] = Object.keys(priceCache);
+    assert(contract_addresses.length > 0, "Must supply at least 1 contract address");
+    this.logger.debug({
+      at: "Coingecko#getContractPrices",
+      message: `Updating ${platform_id}/${currency} token prices.`,
+      tokens: contract_addresses,
+    });
+
+    // annoying, but have to type this to iterate over entries
+    type CGTokenPrice = {
+      [currency: string]: number;
+      last_updated_at: number;
+    };
+    type Result = {
+      [address: string]: CGTokenPrice;
+    };
+
+    let result: Result = {};
+    try {
+      // Coingecko expects a comma-delimited (%2c) list.
+      result = await this.call(
+        `simple/token_price/${platform_id}?contract_addresses=${contract_addresses.join(
+          "%2C"
+        )}&vs_currencies=${currency}&include_last_updated_at=true`
+      );
+    } catch (err) {
+      const errMsg = `Failed to retrieve ${platform_id}/${currency} prices (${err})`;
+      this.logger.debug({
+        at: "Coingecko#getCurrentPriceByContract",
+        message: errMsg,
+        tokens: contract_addresses,
+      });
+      throw new Error(errMsg);
+    }
+
+    // Note: contract_addresses is a reliable reference for the price lookup.
+    // priceCache might have been updated subsequently by concurrent price requests.
+    const updated: string[] = [];
+    contract_addresses.forEach((addr) => {
+      const cgPrice: CGTokenPrice | undefined = result[addr.toLowerCase()];
+
+      if (cgPrice === undefined) {
+        this.logger.debug({
+          at: "Coingecko#getContractPrices",
+          message: `Token ${addr} not included in CoinGecko response.`,
+        });
+      } else if (cgPrice.last_updated_at > priceCache[addr].timestamp) {
+        priceCache[addr] = {
+          address: addr,
+          price: cgPrice[currency],
+          timestamp: cgPrice.last_updated_at,
+        };
+        updated.push(addr);
+      } else if (cgPrice.last_updated_at === priceCache[addr].timestamp) {
+        this.logger.debug({
+          at: "Coingecko#getContractPrices",
+          message: `No new price available for token ${addr}.`,
+          token: cgPrice,
+        });
+      }
+    });
+
+    if (updated.length > 0) {
+      this.logger.debug({
+        at: "Coingecko#updatePriceCache",
+        message: `Updated ${platform_id}/${currency} token price cache.`,
+        tokens: updated,
+      });
+    }
+    return addresses.map((addr: string) => priceCache[addr]);
+  }
+
+  getPlatforms(): Promise<CoinGeckoAssetPlatform[]> {
+    return this.call("asset_platforms");
+  }
+
+  call(path: string) {
+    const sendRequest = async () => {
+      const { proHost } = this;
+
+      // If no pro api key, only send basic request:
+      if (this.apiKey === undefined) {
+        return await this._callBasic(path);
+      }
+
+      // If pro api key, try basic and use pro as fallback.
+      try {
+        return await this._callBasic(path, this.basicApiTimeout);
+      } catch (err) {
+        this.logger.debug({
+          at: "sdk/coingecko",
+          message: `Basic CG url request failed, falling back to CG PRO host ${proHost}`,
+          errMessage: (err as AxiosError).message,
+        });
+        return await this._callPro(path);
+      }
+    };
+
+    // Note: If a pro API key is configured, there is no need to retry as the Pro API will act as the basic's fall back.
+    return retry(sendRequest, this.apiKey === undefined ? this.numRetries : 0, this.retryDelay);
+  }
+
+  protected getPriceCache(currency: string, platform_id: string): { [addr: string]: CoinGeckoPrice } {
+    if (this.prices[platform_id] === undefined) this.prices[platform_id] = {};
+    if (this.prices[platform_id][currency] === undefined) this.prices[platform_id][currency] = {};
+    return this.prices[platform_id][currency];
+  }
+
+  private async _callBasic(path: string, timeout?: number) {
+    const url = `${this.host}/${path}`;
+
+    try {
+      // Don't use timeout if there is no pro API to fallback to.
+      const result = await axios(url, { timeout });
+      return result.data;
+    } catch (err) {
+      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
+      throw new Error(msg);
+    }
+  }
+
+  private async _callPro(path: string) {
+    const url = `${this.proHost}/${path}`;
+
+    try {
+      // Don't use timeout if there is no pro API to fallback to.
+      const result = await axios(url, { params: { x_cg_pro_api_key: this.apiKey } });
+      return result.data;
+    } catch (err) {
+      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
+      throw new Error(msg);
+    }
+  }
+}

package/src/coingecko/index.ts

@@ -0,0 +1 @@
+export * from "./Coingecko";

package/src/constants.ts

@@ -0,0 +1,53 @@
+import { constants as ethersConstants, BigNumber, utils } from "ethers";
+
+export {
+  CHAIN_IDs,
+  MAINNET_CHAIN_IDs,
+  PUBLIC_NETWORKS,
+  TESTNET_CHAIN_IDs,
+  TOKEN_SYMBOLS_MAP,
+} from "@across-protocol/constants";
+
+export const { AddressZero: ZERO_ADDRESS } = ethersConstants;
+
+// 2^96 - 1 is a conservative erc20 max allowance.
+export const MAX_SAFE_ALLOWANCE = "79228162514264337593543950335";
+
+export const SECONDS_PER_YEAR = 31557600; // 365.25 days per year.
+
+/**
+ * This is the protocol default chain Id for the hub pool.
+ */
+export const HUBPOOL_CHAIN_ID = 1;
+
+// List of versions where certain UMIP features were deprecated
+export const TRANSFER_THRESHOLD_MAX_CONFIG_STORE_VERSION = 1;
+
+// A hardcoded identifier used, by default, to tag all Arweave records.
+export const ARWEAVE_TAG_APP_NAME = "across-protocol";
+
+// A hardcoded version number used, by default, to tag all Arweave records.
+export const ARWEAVE_TAG_APP_VERSION = 2;
+
+/**
+ * A default list of chain Ids that the protocol supports. This is outlined
+ * in the UMIP (https://github.com/UMAprotocol/UMIPs/pull/590) and is used
+ * to determine which chain Ids are supported by the protocol. As time progresses,
+ * new chain Ids will be available in the Across ConfigStore contract, but
+ * this list serves as a baseline set of chain Ids that the protocol supports
+ * before the dynamic config store was introduced.
+ */
+export const PROTOCOL_DEFAULT_CHAIN_ID_INDICES = [1, 10, 137, 288, 42161];
+
+export const DEFAULT_CACHING_TTL = 60 * 60 * 24 * 7 * 2; // 2 Weeks
+export const DEFAULT_CACHING_SAFE_LAG = 60 * 60; // 1 hour
+
+export const UBA_BOUNDS_RANGE_MAX = BigNumber.from(String(Number.MAX_SAFE_INTEGER)).mul(utils.parseEther("1.0"));
+export const UBA_BOUNDS_RANGE_MIN = UBA_BOUNDS_RANGE_MAX.mul(-1);
+
+export const DEFAULT_SIMULATED_RELAYER_ADDRESS = "0x428AB2BA90Eba0a4Be7aF34C9Ac451ab061AC010";
+export const DEFAULT_SIMULATED_RELAYER_ADDRESS_TEST = "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D"; // Görli, ...
+
+export const DEFAULT_ARWEAVE_STORAGE_ADDRESS = "Z6hjBM8FHu90lYWB8o5jR1dfX92FlV2WBaND9xgp8Lg";
+
+export const EMPTY_MESSAGE = "0x";