@across-protocol/sdk 3.1.35 → 3.2.0

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -1,13 +1,12 @@
 import assert from "assert";
-import { Contract, Event, providers } from "ethers";
+import { Contract } from "ethers";
 import { random } from "lodash";
 import winston from "winston";
 import { ZERO_ADDRESS } from "../../constants";
 import {
+  Log,
   DepositWithBlock,
   FillType,
-  V3FundsDepositedEvent,
-  RealizedLpFee,
   RelayerRefundExecutionWithBlock,
   SlowFillRequestWithBlock,
   Fill,
@@ -15,25 +14,20 @@ import {
   SlowFillLeaf,
   SpeedUp,
 } from "../../interfaces";
-import { BigNumber, bnZero, toBN, toBNWei, forEachAsync, getCurrentTime, randomAddress } from "../../utils";
+import { toBN, toBNWei, getCurrentTime, randomAddress } from "../../utils";
 import { SpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
 
-type Block = providers.Block;
-
-// This class replaces internal SpokePoolClient functionality, enabling the
-// user to bypass on-chain queries and inject ethers Event objects directly.
+// This class replaces internal SpokePoolClient functionality, enabling
+// the user to bypass on-chain queries and inject Log 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,
@@ -47,36 +41,10 @@ export class MockSpokePoolClient extends SpokePoolClient {
     this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
   }
 
-  setDefaultRealizedLpFeePct(fee: BigNumber): void {
-    this.realizedLpFeePct = fee;
-    this.realizedLpFeePctOverride = true;
-  }
-
   setConfigStoreClient(configStore?: AcrossConfigStoreClient): void {
     this.configStoreClient = configStore;
   }
 
-  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;
   }
@@ -107,33 +75,32 @@ export class MockSpokePoolClient extends SpokePoolClient {
     return Promise.resolve(this.depositIdAtBlock[blockTag]);
   }
 
-  async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
+  _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;
+    const events: Log[][] = eventsToQuery.map(() => []);
+    this.eventManager
+      .getEvents()
+      .flat()
+      .forEach((event) => {
+        const idx = eventsToQuery.indexOf(event.event);
+        if (idx !== -1) {
+          events[idx].push(event);
+        }
+      });
 
     // Update latestDepositIdQueried.
     const idx = eventsToQuery.indexOf("V3FundsDeposited");
     const latestDepositId = (events[idx] ?? []).reduce(
-      (depositId, event) => Math.max(depositId, event.args?.["depositId"] ?? 0),
+      (depositId, event) => Math.max(depositId, (event.args["depositId"] ?? 0) as number),
       this.latestDepositIdQueried
     );
 
-    return {
+    return Promise.resolve({
       success: true,
       firstDepositId: 0,
       latestDepositId,
@@ -141,7 +108,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
       oldestTime: 0,
       events,
       searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
-    };
+    });
   }
 
   // Event signatures. Not strictly required, but they make generated events more recognisable.
@@ -151,7 +118,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     FundsDeposited: "uint256,uint256,uint256,int64,uint32,uint32,address,address,address,bytes",
   };
 
-  depositV3(deposit: DepositWithBlock): Event {
+  depositV3(deposit: DepositWithBlock): Log {
     const event = "V3FundsDeposited";
 
     const { blockNumber, transactionIndex } = deposit;
@@ -197,7 +164,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  fillV3Relay(fill: FillWithBlock): Event {
+  fillV3Relay(fill: FillWithBlock): Log {
     const event = "FilledV3Relay";
 
     const { blockNumber, transactionIndex } = fill;
@@ -247,7 +214,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  speedUpV3Deposit(speedUp: SpeedUp): Event {
+  speedUpV3Deposit(speedUp: SpeedUp): Log {
     const event = "RequestedSpeedUpV3Deposit";
     const topics = [speedUp.depositId, speedUp.depositor];
     const args = { ...speedUp };
@@ -260,7 +227,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  requestV3SlowFill(request: SlowFillRequestWithBlock): Event {
+  requestV3SlowFill(request: SlowFillRequestWithBlock): Log {
     const event = "RequestedV3SlowFill";
 
     const { originChainId, depositId } = request;
@@ -279,7 +246,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
 
   // This is a simple wrapper around fillV3Relay().
   // rootBundleId and proof are discarded here - we have no interest in verifying that.
-  executeV3SlowRelayLeaf(leaf: SlowFillLeaf): Event {
+  executeV3SlowRelayLeaf(leaf: SlowFillLeaf): Log {
     const fill: Fill = {
       ...leaf.relayData,
       destinationChainId: this.chainId,
@@ -296,7 +263,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     return this.fillV3Relay(fill as FillWithBlock);
   }
 
-  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Event {
+  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Log {
     const event = "ExecutedRelayerRefundRoot";
 
     const chainId = refund.chainId ?? this.chainId;
@@ -328,7 +295,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     destinationChainId: number,
     enabled: boolean,
     overrides: EventOverrides = {}
-  ): Event {
+  ): Log {
     const event = "EnabledDepositRoute";
 
     const topics = [originToken, destinationChainId];

package/src/contracts/utils.ts

@@ -1,5 +1,6 @@
 import assert from "assert";
-import { Event } from "ethers";
+// eslint-disable-next-line no-restricted-imports
+import { Event } from "@ethersproject/contracts";
 import { BigNumber, BigNumberish, isDefined } from "../utils";
 
 /**

package/src/gasPriceOracle/adapters/polygon.ts

@@ -1,6 +1,6 @@
 import { providers } from "ethers";
 import { BaseHTTPAdapter, BaseHTTPAdapterArgs } from "../../priceClient/adapters/baseAdapter";
-import { bnZero, isDefined, parseUnits } from "../../utils";
+import { BigNumber, bnZero, isDefined, parseUnits } from "../../utils";
 import { CHAIN_IDs } from "../../constants";
 import { GasPriceEstimate } from "../types";
 import { gasPriceError } from "../util";
@@ -27,8 +27,6 @@ type GasStationArgs = BaseHTTPAdapterArgs & {
 
 const { POLYGON } = CHAIN_IDs;
 
-// @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;
 
@@ -42,7 +40,7 @@ class PolygonGasStation extends BaseHTTPAdapter {
   async getFeeData(strategy: "safeLow" | "standard" | "fast" = "fast"): Promise<GasPriceEstimate> {
     const gas = await this.query("v2", {});
 
-    const gasPrice: Polygon1559GasPrice = (gas as GasStationV2Response)?.[strategy];
+    const gasPrice = (gas as GasStationV2Response)?.[strategy];
     if (!this.isPolygon1559GasPrice(gasPrice)) {
       // @todo: generalise gasPriceError() to accept a reason/cause?
       gasPriceError("getFeeData()", this.chainId, bnZero);
@@ -69,12 +67,25 @@ class PolygonGasStation extends BaseHTTPAdapter {
   }
 }
 
-export function gasStation(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
-  const gasStation = new PolygonGasStation({ chainId: chainId });
+export async function gasStation(provider: providers.Provider, chainId: number): Promise<GasPriceEstimate> {
+  const gasStation = new PolygonGasStation({ chainId: chainId, timeout: 2000, retries: 0 });
+  let maxPriorityFeePerGas: BigNumber;
+  let maxFeePerGas: BigNumber;
   try {
-    return gasStation.getFeeData();
+    ({ maxPriorityFeePerGas, maxFeePerGas } = await gasStation.getFeeData());
   } catch (err) {
     // Fall back to the RPC provider. May be less accurate.
-    return eip1559(provider, chainId);
+    ({ maxPriorityFeePerGas, maxFeePerGas } = await eip1559(provider, chainId));
+
+    // Per the GasStation docs, the minimum priority fee on Polygon is 30 Gwei.
+    // https://docs.polygon.technology/tools/gas/polygon-gas-station/#interpretation
+    const minPriorityFee = parseUnits("30", 9);
+    if (maxPriorityFeePerGas.lt(minPriorityFee)) {
+      const priorityDelta = minPriorityFee.sub(maxPriorityFeePerGas);
+      maxPriorityFeePerGas = minPriorityFee;
+      maxFeePerGas = maxFeePerGas.add(priorityDelta);
+    }
   }
+
+  return { maxPriorityFeePerGas, maxFeePerGas };
 }

package/src/interfaces/Common.ts

@@ -1,5 +1,12 @@
+import { Log as _Log } from "@ethersproject/abstract-provider";
 import { BigNumber } from "../utils";
 
+export type Log = _Log & {
+  event: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args: { [key: string]: any };
+};
+
 export interface SortableEvent {
   blockNumber: number;
   transactionIndex: number;

package/src/priceClient/adapters/baseAdapter.ts

@@ -40,6 +40,7 @@ export class BaseHTTPAdapter {
   protected async query(path: string, urlArgs?: object): Promise<unknown> {
     const url = `https://${this.host}/${path ?? ""}`;
     const args = {
+      headers: { "User-Agent": process.env.ACROSS_USER_AGENT ?? "across-protocol" },
       timeout: this.timeout,
       params: urlArgs ?? {},
     };

package/src/utils/EventUtils.ts

@@ -1,17 +1,18 @@
 import { Result } from "@ethersproject/abi";
-import { delay } from "./common";
-import { SortableEvent } from "../interfaces";
+// eslint-disable-next-line no-restricted-imports
 import { Contract, Event, EventFilter } from "ethers";
+import { Log, SortableEvent } from "../interfaces";
+import { delay } from "./common";
 
 const maxRetries = 3;
 const retrySleepTime = 10;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function spreadEvent(args: Result = {} as Result): any {
+export function spreadEvent(args: Result | Record<string, unknown>): { [key: string]: any } {
   const keys = Object.keys(args).filter((key: string) => isNaN(+key)); // Extract non-numeric keys.
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const returnedObject: any = {};
+  const returnedObject: { [key: string]: unknown } = {};
   keys.forEach((key: string) => {
     switch (typeof args[key]) {
       case "boolean": // fallthrough
@@ -67,15 +68,18 @@ export interface EventSearchConfig {
   maxBlockLookBack?: number;
 }
 
+export const eventToLog = (event: Event): Log => ({ ...event, event: event.event!, args: spreadEvent(event.args!) });
+
 export async function paginatedEventQuery(
   contract: Contract,
   filter: EventFilter,
   searchConfig: EventSearchConfig,
   retryCount = 0
-): Promise<Event[]> {
+): Promise<Log[]> {
   // If the max block look back is set to 0 then we dont need to do any pagination and can query over the whole range.
   if (searchConfig.maxBlockLookBack === 0) {
-    return await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
+    const events = await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
+    return events.map(eventToLog);
   }
 
   // Compute the number of queries needed. If there is no maxBlockLookBack set then we can execute the whole query in
@@ -93,6 +97,7 @@ export async function paginatedEventQuery(
         .flat()
         // Filter events by block number because ranges can include blocks that are outside the range specified for caching reasons.
         .filter((event) => event.blockNumber >= searchConfig.fromBlock && event.blockNumber <= searchConfig.toBlock)
+        .map(eventToLog)
     );
   } catch (error) {
     if (retryCount < maxRetries) {
@@ -163,7 +168,7 @@ export function getPaginatedBlockRanges({
   return ranges;
 }
 
-export function spreadEventWithBlockNumber(event: Event): SortableEvent {
+export function spreadEventWithBlockNumber(event: Log): SortableEvent {
   return {
     ...spreadEvent(event.args),
     blockNumber: event.blockNumber,

package/src/utils/JSONUtils.ts

@@ -53,7 +53,7 @@ export function jsonReplacerWithBigNumbers(_key: string, value: unknown): unknow
   // We need to check if this is a big number, because the JSON parser
   // is not aware of BigNumbers and will convert them to the string representation
   // of the object itself which is not what we want.
-  if (BigNumber.isBigNumber(value)) {
+  if (BigNumber.isBigNumber(value) || typeof value === "bigint") {
     return value.toString();
   }
   // There's a legacy issues that returns BigNumbers as { type: "BigNumber", hex: "0x..." }