@across-protocol/sdk 3.0.0

package/src/contracts/acrossConfigStore.ts

@@ -0,0 +1,49 @@
+import { Provider } from "@ethersproject/providers";
+import { AcrossConfigStore, AcrossConfigStore__factory } from "../typechain";
+import { object, string, Infer, assert, mask, record, optional } from "superstruct";
+import type { CallOverrides } from "@ethersproject/contracts";
+import { filterFalsyKeys } from "../utils";
+
+const RateModelSs = object({
+  UBar: string(), // denote the utilization kink along the rate model where the slope of the interest rate model changes.
+  R0: string(), // is the interest rate charged at 0 utilization
+  R1: string(), // R_0+R_1 is the interest rate charged at UBar
+  R2: string(), // R_0+R_1+R_2 is the interest rate charged at 100% utilization
+});
+const L1TokenConfigSs = object({
+  rateModel: RateModelSs,
+  routeRateModel: optional(record(string(), RateModelSs)),
+});
+export type RateModel = Infer<typeof RateModelSs>;
+export type L1TokenConfig = Infer<typeof L1TokenConfigSs>;
+
+export class Client {
+  public readonly contract: AcrossConfigStore;
+  constructor(address: string, provider: Provider) {
+    this.contract = AcrossConfigStore__factory.connect(address, provider);
+  }
+  static parseL1TokenConfig(data: string): L1TokenConfig {
+    const l1TokenConfig = JSON.parse(data);
+    const l1TokenConfigMask = filterFalsyKeys(mask(l1TokenConfig, L1TokenConfigSs));
+    assert(l1TokenConfigMask, L1TokenConfigSs);
+    return l1TokenConfigMask;
+  }
+  async getL1TokenConfig(l1TokenAddress: string, overrides: CallOverrides = {}): Promise<L1TokenConfig> {
+    const data = await this.contract.l1TokenConfig(l1TokenAddress, overrides);
+    return Client.parseL1TokenConfig(data);
+  }
+  async getRateModel(
+    l1TokenAddress: string,
+    overrides: CallOverrides = {},
+    originChainId?: number,
+    destinationChainId?: number
+  ): Promise<RateModel> {
+    const l1TokenConfig = await this.getL1TokenConfig(l1TokenAddress, overrides);
+    if (originChainId === undefined || destinationChainId === undefined) return l1TokenConfig.rateModel;
+    const routeRateModelKey = `${originChainId}-${destinationChainId}`;
+    if (l1TokenConfig.routeRateModel && l1TokenConfig.routeRateModel[routeRateModelKey]) {
+      return l1TokenConfig.routeRateModel[routeRateModelKey];
+    }
+    return l1TokenConfig.rateModel;
+  }
+}

package/src/contracts/hubPool.ts

@@ -0,0 +1,90 @@
+import { HubPool, HubPool__factory, HubPoolInterface } from "../typechain";
+
+import { providers, utils as ethersUtils, Signer } from "ethers";
+import { Balances, SerializableEvent } from "./utils";
+
+export type Instance = HubPool;
+export const Factory = HubPool__factory;
+export type Interface = HubPoolInterface;
+
+export function connect(address: string, provider: providers.Provider | Signer): Instance {
+  return Factory.connect(address, provider as Signer);
+}
+
+export type TokenEventState = {
+  tokenBalances: Balances;
+  lpTokenBalances: Balances;
+  l1Token?: string;
+  lpToken?: string;
+  enabled?: boolean;
+};
+export type EventState = Record<string, TokenEventState>;
+
+export function eventStateDefaults(): EventState {
+  return {};
+}
+function tokenEventStateDefaults(): TokenEventState {
+  return {
+    tokenBalances: {},
+    lpTokenBalances: {},
+  };
+}
+
+function reduceEvents(state: EventState, event: SerializableEvent): EventState {
+  const hubPoolInterface = new ethersUtils.Interface(Factory.abi);
+
+  const eventName = event.event ?? "unknown";
+  const { args } = hubPoolInterface.parseLog(event);
+  const { l1Token } = args;
+  const tokenEventState = state[l1Token] || tokenEventStateDefaults();
+  const tokens = Balances(tokenEventState.tokenBalances);
+  const lpTokens = Balances(tokenEventState.lpTokenBalances);
+
+  switch (eventName) {
+    case "LiquidityAdded":
+    case "LiquidityRemoved": {
+      const { amount, liquidityProvider } = args;
+      if (event.event === "LiquidityAdded") {
+        lpTokens.add(liquidityProvider, args.lpTokensMinted.toString());
+        tokens.add(liquidityProvider, amount.toString());
+      } else {
+        lpTokens.sub(liquidityProvider, args.lpTokensBurnt.toString());
+        tokens.sub(liquidityProvider, amount.toString());
+      }
+
+      return {
+        ...state,
+        [l1Token]: {
+          ...tokenEventState,
+          l1Token,
+          tokenBalances: {
+            ...tokens.balances,
+          },
+          lpTokenBalances: {
+            ...lpTokens.balances,
+          },
+        },
+      };
+    }
+
+    case "L1TokenEnabledForLiquidityProvision":
+    case "L2TokenDisabledForLiquidityProvision": {
+      const { lpToken } = args;
+      const enabled = event.event === "L1TokenEnabledForLiquidityProvision";
+      return {
+        ...state,
+        [l1Token]: {
+          ...tokenEventState,
+          lpToken,
+          l1Token,
+          enabled,
+        },
+      };
+    }
+  }
+
+  return state;
+}
+export function getEventState(events: SerializableEvent[], eventState: EventState = eventStateDefaults()): EventState {
+  return events.reduce(reduceEvents, eventState);
+}

package/src/contracts/index.ts

@@ -0,0 +1,2 @@
+export * as acrossConfigStore from "./acrossConfigStore";
+export * as hubPool from "./hubPool";

package/src/contracts/utils.ts

@@ -0,0 +1,56 @@
+import assert from "assert";
+import { BigNumber, BigNumberish, Event } from "ethers";
+import { isDefined } from "../utils";
+
+/**
+ * @dev Originally imported from @uma/sdk.
+ * @dev This code is intended to support existing use of contracts/hubPool.ts and should not be used for new code.
+ * @todo Refactor contracts/hubPool.ts to avoid the need for this.
+ */
+
+export type SerializableEvent = Omit<
+  Event,
+  "decode" | "removeListener" | "getBlock" | "getTransaction" | "getTransactionReceipt"
+>;
+
+// useful for maintaining balances from events
+export type Balances = { [key: string]: string };
+
+/**
+ * Utility for maintaining records of a token balance.
+ */
+export function Balances(balances: Balances = {}) {
+  function create(id: string, amount = "0") {
+    assert(!has(id), "balance already exists");
+    return set(id, amount);
+  }
+
+  function has(id: string) {
+    return isDefined(balances[id]);
+  }
+
+  function set(id: string, amount: string) {
+    balances[id] = amount;
+    return amount;
+  }
+
+  function add(id: string, amount: BigNumberish) {
+    return set(id, BigNumber.from(amount).add(getOrCreate(id)).toString());
+  }
+
+  function sub(id: string, amount: BigNumberish) {
+    return set(id, BigNumber.from(getOrCreate(id)).sub(amount).toString());
+  }
+
+  function get(id: string) {
+    assert(has(id), "balance does not exist");
+    return balances[id];
+  }
+
+  function getOrCreate(id: string) {
+    if (has(id)) return get(id);
+    return create(id);
+  }
+
+  return { create, add, sub, get, balances, set, has, getOrCreate };
+}

package/src/gasPriceOracle/adapters/arbitrum.ts

@@ -0,0 +1,21 @@
+import { ethers, providers, utils as ethersUtils } from "ethers";
+import { GasPriceEstimate } from "../types";
+import { eip1559 } from "./ethereum";
+
+// Arbitrum Nitro implements EIP-1559 pricing, but the priority fee is always refunded to the caller. Further,
+// ethers typically hardcodes the priority fee to 1.5 Gwei. So, confirm that the priority fee supplied was 1.5
+// Gwei, and then drop it to 1 Wei. Reference: https://developer.arbitrum.io/faqs/gas-faqs#q-priority
+export async function eip1559_arbitrum(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
+  const { maxFeePerGas: _maxFeePerGas, maxPriorityFeePerGas } = await eip1559(provider, chainId);
+
+  // If this throws, ethers default behaviour has changed, or Arbitrum RPCs are returning something more sensible.
+  if (!maxPriorityFeePerGas.eq(ethersUtils.parseUnits("1.5", 9))) {
+    throw new Error(`Expected hardcoded 1.5 Gwei priority fee on Arbitrum, got ${maxPriorityFeePerGas}`);
+  }
+
+  // eip1559() sets maxFeePerGas = lastBaseFeePerGas + maxPriorityFeePerGas, so revert that.
+  // The caller may apply scaling as they wish afterwards.
+  const maxFeePerGas = _maxFeePerGas.sub(maxPriorityFeePerGas).add(1);
+
+  return { maxPriorityFeePerGas: ethers.constants.One, maxFeePerGas };
+}

package/src/gasPriceOracle/adapters/ethereum.ts

@@ -0,0 +1,27 @@
+import { BigNumber, providers, ethers } from "ethers";
+import { GasPriceEstimate } from "../types";
+import { gasPriceError } from "../util";
+
+export async function eip1559(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
+  const feeData = await provider.getFeeData();
+
+  [feeData.lastBaseFeePerGas, feeData.maxPriorityFeePerGas].forEach((field: BigNumber | null) => {
+    if (!BigNumber.isBigNumber(field) || field.lt(0)) gasPriceError("getFeeData()", chainId, feeData);
+  });
+
+  const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas as BigNumber;
+  const maxFeePerGas = maxPriorityFeePerGas.add(feeData.lastBaseFeePerGas as BigNumber);
+
+  return { maxPriorityFeePerGas, maxFeePerGas };
+}
+
+export async function legacy(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
+  const gasPrice: BigNumber = await provider.getGasPrice();
+
+  if (!BigNumber.isBigNumber(gasPrice) || gasPrice.lt(0)) gasPriceError("getGasPrice()", chainId, gasPrice);
+
+  return {
+    maxFeePerGas: gasPrice,
+    maxPriorityFeePerGas: ethers.constants.Zero,
+  };
+}

package/src/gasPriceOracle/adapters/index.ts

@@ -0,0 +1,3 @@
+export * from "./ethereum";
+export * from "./arbitrum";
+export * from "./polygon";

package/src/gasPriceOracle/adapters/polygon.ts

@@ -0,0 +1,77 @@
+import { providers, utils as ethersUtils } from "ethers";
+import { BaseHTTPAdapter, BaseHTTPAdapterArgs } from "../../priceClient/adapters/baseAdapter";
+import { isDefined } from "../../utils/TypeGuards";
+import { GasPriceEstimate } from "../types";
+import { gasPriceError } from "../util";
+import { eip1559 } from "./ethereum";
+
+type Polygon1559GasPrice = {
+  maxPriorityFee: number | string;
+  maxFee: number | string;
+};
+
+type GasStationV2Response = {
+  safeLow: Polygon1559GasPrice;
+  standard: Polygon1559GasPrice;
+  fast: Polygon1559GasPrice;
+  estimatedBaseFee: number | string;
+  blockTime: number | string;
+  blockNumber: number | string;
+};
+
+type GasStationArgs = BaseHTTPAdapterArgs & {
+  chainId?: number;
+  host?: string;
+};
+
+// @dev toBNWei() is not imported from ../utils because of a circular dependency loop.
+//      The fix is probably to relocate the function estimateTotalGasRequiredByUnsignedTransaction().
+class PolygonGasStation extends BaseHTTPAdapter {
+  readonly chainId: number;
+
+  constructor({ chainId = 137, host, timeout = 1500, retries = 1 }: GasStationArgs = {}) {
+    host = host ?? chainId === 137 ? "gasstation.polygon.technology" : "gasstation-testnet.polygon.technology";
+
+    super("Polygon Gas Station", host, { timeout, retries });
+    this.chainId = chainId;
+  }
+
+  async getFeeData(strategy: "safeLow" | "standard" | "fast" = "fast"): Promise<GasPriceEstimate> {
+    const gas = await this.query("v2", {});
+
+    const gasPrice: Polygon1559GasPrice = (gas as GasStationV2Response)?.[strategy];
+    if (!this.isPolygon1559GasPrice(gasPrice)) {
+      // @todo: generalise gasPriceError() to accept a reason/cause?
+      gasPriceError("getFeeData()", this.chainId, ethersUtils.parseUnits("0"));
+    }
+
+    [gasPrice.maxFee, gasPrice.maxPriorityFee].forEach((gasPrice) => {
+      if (Number(gasPrice) < 0) {
+        gasPriceError("getFeeData()", this.chainId, ethersUtils.parseUnits(gasPrice.toString(), 9));
+      }
+    });
+
+    const maxPriorityFeePerGas = ethersUtils.parseUnits(gasPrice.maxPriorityFee.toString(), 9);
+    const maxFeePerGas = ethersUtils.parseUnits(gasPrice.maxFee.toString(), 9);
+
+    return { maxPriorityFeePerGas, maxFeePerGas };
+  }
+
+  protected isPolygon1559GasPrice(gasPrice: unknown): gasPrice is Polygon1559GasPrice {
+    if (!isDefined(gasPrice)) {
+      return false;
+    }
+    const _gasPrice = gasPrice as Polygon1559GasPrice;
+    return [_gasPrice.maxPriorityFee, _gasPrice.maxFee].every((field) => ["number", "string"].includes(typeof field));
+  }
+}
+
+export async function polygonGasStation(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
+  const gasStation = new PolygonGasStation({ chainId: chainId });
+  try {
+    return await gasStation.getFeeData();
+  } catch (err) {
+    // Fall back to the RPC provider. May be less accurate.
+    return await eip1559(provider, chainId);
+  }
+}

package/src/gasPriceOracle/index.ts

@@ -0,0 +1,2 @@
+export { getGasPriceEstimate } from "./oracle";
+export { GasPriceEstimate } from "./types";

package/src/gasPriceOracle/oracle.ts

@@ -0,0 +1,42 @@
+import { providers } from "ethers";
+import { eip1559, eip1559_arbitrum, legacy, polygonGasStation } from "./adapters";
+import { GasPriceEstimate, GasPriceFeed } from "./types";
+
+/**
+ * Provide an estimate for the current gas price for a particular chain.
+ * @param chainId The chain ID to query for gas prices.
+ * @param provider A valid ethers provider.
+ * @param legacyFallback In the case of an unrecognised chain, fall back to type 0 gas estimation.
+ * @returns Am object of type GasPriceEstimate.
+ */
+export async function getGasPriceEstimate(
+  provider: providers.Provider,
+  chainId?: number,
+  legacyFallback = true
+): Promise<GasPriceEstimate> {
+  if (!chainId) {
+    const network: providers.Network = await provider.getNetwork();
+    chainId = network.chainId;
+  }
+
+  const gasPriceFeeds: { [chainId: number]: GasPriceFeed } = {
+    1: eip1559,
+    10: eip1559,
+    137: polygonGasStation,
+    288: legacy,
+    324: legacy,
+    8453: eip1559,
+    42161: eip1559_arbitrum,
+  };
+
+  let gasPriceFeed: GasPriceFeed = gasPriceFeeds[chainId];
+  if (gasPriceFeed === undefined) {
+    if (!legacyFallback) {
+      throw new Error(`No suitable gas price oracle for Chain ID ${chainId}`);
+    }
+    gasPriceFeed = legacy;
+  }
+
+  const gasPriceEstimate: GasPriceEstimate = await gasPriceFeed(provider, chainId);
+  return gasPriceEstimate;
+}

package/src/gasPriceOracle/types.ts

@@ -0,0 +1,10 @@
+import { BigNumber, providers } from "ethers";
+
+export type GasPriceEstimate = {
+  maxFeePerGas: BigNumber;
+  maxPriorityFeePerGas: BigNumber;
+};
+
+export interface GasPriceFeed {
+  (provider: providers.Provider, chainId: number): Promise<GasPriceEstimate>;
+}

package/src/gasPriceOracle/util.ts

@@ -0,0 +1,5 @@
+import { BigNumber, providers } from "ethers";
+
+export function gasPriceError(method: string, chainId: number, data: providers.FeeData | BigNumber): void {
+  throw new Error(`Malformed ${method} response on chain ID ${chainId} (${JSON.stringify(data)})`);
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * as lpFeeCalculator from "./lpFeeCalculator";
+export * as pool from "./pool";
+export * as relayFeeCalculator from "./relayFeeCalculator";
+export * as utils from "./utils";
+export * as contracts from "./contracts";
+export * as coingecko from "./coingecko";
+export * as gasPriceOracle from "./gasPriceOracle";
+export * as priceClient from "./priceClient";
+export * as merkleDistributor from "./merkleDistributor";
+export * as constants from "./constants";
+export * as interfaces from "./interfaces";
+export * as typeguards from "./typeguards";
+export * as clients from "./clients";
+export * as typechain from "./typechain";
+export * as caching from "./caching";

package/src/interfaces/Bridge.ts

@@ -0,0 +1,10 @@
+import { BigNumber } from "ethers";
+
+export interface OutstandingTransfers {
+  [address: string]: {
+    [l1Token: string]: {
+      totalAmount: BigNumber;
+      depositTxHashes: string[];
+    };
+  };
+}

package/src/interfaces/CachingMechanism.ts

@@ -0,0 +1,37 @@
+import { Struct } from "superstruct";
+
+/**
+ * The interface for a caching mechanism. This is used to store and retrieve values from a cache.
+ * @interface CachingInterface
+ * @exports
+ */
+export interface CachingMechanismInterface {
+  /**
+   * Attempts to retrieve a value from the cache.
+   * @param key The key to retrieve.
+   * @returns The value if it exists, otherwise null.
+   */
+  get<ObjectType, OverrideType = unknown>(
+    key?: string,
+    structValidator?: Struct<unknown, unknown>,
+    overrides?: OverrideType
+  ): Promise<ObjectType | null>;
+
+  /**
+   * Attempts to set a key in the caching store. Returns the ID of the value stored. This is useful for storing values
+   * in a cache that are not known ahead of time. For example, if you want to store a value in a cache that is the result of a
+   * computation, you can use this method to store the value and retrieve the ID of the value stored.
+   * @param key The canonical key to store.
+   * @param value The value to store.
+   * @param ttl The time to live in seconds.
+   * @param overrides Any overrides to the default caching mechanism configuration for the given caching protocol.
+   * @note Caching mechanisms where the `key` is directly used to store values will return `key` on success.
+   * @returns The ID of the value stored. If the value could not be stored, undefined is returned. If the caching mechanism uses the `key` as the ID, the `key` is returned.
+   */
+  set<ObjectType, OverrideType>(
+    key: string,
+    value: ObjectType,
+    ttl?: number,
+    overrides?: OverrideType
+  ): Promise<string | undefined>;
+}

package/src/interfaces/Common.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from "ethers";
+
+export interface SortableEvent {
+  blockNumber: number;
+  transactionIndex: number;
+  logIndex: number;
+  transactionHash: string;
+}
+
+export interface BigNumberForToken {
+  [l1TokenAddress: string]: BigNumber;
+}

package/src/interfaces/ConfigStore.ts

@@ -0,0 +1,173 @@
+import { BigNumber } from "ethers";
+import { RateModelDictionary } from "../lpFeeCalculator/rateModel";
+import { SortableEvent } from "./Common";
+
+export interface ParsedTokenConfig {
+  rateModel: RateModelDictionary;
+  routeRateModel?: {
+    [path: string]: RateModelDictionary;
+  };
+  uba?: UBAOnChainConfigType;
+  spokeTargetBalances?: {
+    [chainId: number]: {
+      target: string;
+      threshold: string;
+    };
+  };
+}
+
+export interface SpokePoolTargetBalance {
+  target: BigNumber;
+  threshold: BigNumber;
+}
+
+export type SpokePoolTargetBalanceStringified = Omit<SpokePoolTargetBalance, "threshold" | "target"> & {
+  target: string;
+  threshold: string;
+};
+
+export interface SpokeTargetBalanceUpdate extends SortableEvent {
+  spokeTargetBalances?: {
+    [chainId: number]: SpokePoolTargetBalance;
+  };
+  l1Token: string;
+}
+
+export interface SpokeTargetBalanceUpdateStringified extends SortableEvent {
+  spokeTargetBalances?: {
+    [chainId: number]: SpokePoolTargetBalanceStringified;
+  };
+  l1Token: string;
+}
+
+export interface RouteRateModelUpdate extends SortableEvent {
+  routeRateModel: {
+    [path: string]: string;
+  };
+  l1Token: string;
+}
+
+export interface TokenConfig extends SortableEvent {
+  key: string;
+  value: string;
+}
+
+export interface GlobalConfigUpdate<ValueStore = number> extends SortableEvent {
+  value: ValueStore;
+}
+
+export interface ConfigStoreVersionUpdate<ValueStore = number> extends GlobalConfigUpdate<ValueStore> {
+  timestamp: number;
+}
+
+export interface DisabledChainsUpdate extends SortableEvent {
+  chainIds: number[];
+}
+
+/**
+ * A generic type of a dictionary that has string keys and values of type T. This
+ * record is enforced to have a default entry within the "default" key.
+ * @type Value The type of the values in the dictionary.
+ */
+type RecordWithDefaultEntry<Value> = Record<string, Value>;
+
+/**
+ * A generic type for an array of tuples.
+ * @type Value The type of the values in the array.
+ */
+type ArrayOfTuples<Value> = [Value, Value][];
+
+/**
+ * A type for the UBA config object stored both on and off chain.
+ * @type T The type of the values in the config.
+ * @note This is a dictionary of parameters that defines a fee curve for the token.
+ *       These parameters can be further subindexed by a route (e.g. using the key "1-10" or "42161-1")
+ *       to create a specific fee curve for a token per route. The subkeys are as followed:
+ *         - alpha: The alpha parameter of the fee curve.
+ *         - gamma: The gamma parameter of the fee curve.
+ *         - omega: The omega parameter of the fee curve.
+ *         - rebalance: The rebalance parameters of the fee curve.
+ */
+type UBAAgnosticConfigType<T> = {
+  /**
+   * A DAO controlled variable to track any donations made to the incentivePool liquidity
+   */
+  incentivePoolAdjustment?: Record<string, T>;
+  /**
+   * Used to scale rewards when a fee is larger than the incentive balance
+   */
+  ubaRewardMultiplier?: Record<string, T>;
+  /**
+   * This is a scalar value that is a constant percentage of each transfer that is allocated for LPs.
+   * This value can be determined by token and route-by-route.
+   */
+  alpha: RecordWithDefaultEntry<T>;
+  /**
+   * This is a piecewise linear function (defined by a vector of cut-off points and the values at
+   * those points) that determine additional LP fees as a function of utilization. This piecewise
+   * linear function can be determined by token and chain-by-chain.
+   */
+  gamma: RecordWithDefaultEntry<ArrayOfTuples<T>>;
+  /**
+   * This is a piecewise linear function (defined by a vector of cut-off points and the values at
+   * those points) that determine the balancing fees (rewards) that are imposed on (paid to) a user
+   * who makes a transfer involving a particular chain. There is a single piecewise linear function for
+   * each token/chain combination. A transfer will incur a balancing fee on both the origin and destination
+   * chains.
+   */
+  omega: RecordWithDefaultEntry<ArrayOfTuples<T>>;
+  /**
+   * This is a set of parameters that determine when a rebalance is triggered. A rebalance is triggered
+   * when the utilization of a pool is outside of the range defined by the lower and upper thresholds.
+   */
+  rebalance: RecordWithDefaultEntry<{
+    /**
+     * For tokens/chains that have a supported bridge, these are the lower and upper threshold that trigger
+     * the reallocation of funds. i.e. If the running balance on a chain moves below (above) threshold_lower
+     * (threshold_upper) then the bridge moves funds from Ethereum to the chain (from the chain to Ethereum).
+     */
+    threshold_lower?: T;
+    /**
+     * For tokens/chains that have a supported bridge, these are the lower and upper threshold that trigger
+     * the reallocation of funds. i.e. If the running balance on a chain moves below (above) threshold_lower
+     * (threshold_upper) then the bridge moves funds from Ethereum to the chain (from the chain to Ethereum).
+     */
+    threshold_upper?: T;
+    /**
+     * For tokens/chains that have a supported bridge, these are the values that are targeted whenever funds
+     * are reallocated.
+     */
+    target_lower?: T;
+    /**
+     * For tokens/chains that have a supported bridge, these are the values that are targeted whenever funds
+     * are reallocated.
+     */
+    target_upper?: T;
+  }>;
+};
+
+/**
+ * A type for the UBA config object stored on chain.
+ */
+export type UBAOnChainConfigType = UBAAgnosticConfigType<string>;
+
+/**
+ * A type for the UBA config object after it has been parsed.
+ */
+export type UBAParsedConfigType = UBAAgnosticConfigType<BigNumber>;
+
+/**
+ * A type for UBAConfig Update events.
+ */
+export type UBAConfigUpdates = SortableEvent & {
+  config: UBAParsedConfigType;
+  l1Token: string;
+};
+
+/**
+ * A type for stringified UBAConfig Update events.
+ */
+export type UBASerializedConfigUpdates = SortableEvent & {
+  config: UBAOnChainConfigType;
+  l1Token: string;
+};

package/src/interfaces/Error.ts

@@ -0,0 +1,5 @@
+export type EthersError = Error & {
+  code: string;
+  reason: string;
+  error?: Error;
+};