@across-protocol/sdk 4.3.56 → 4.3.58

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -7,7 +7,7 @@ import {
   relayFillStatus,
   getTimestampForBlock as _getTimestampForBlock,
 } from "../../arch/evm";
-import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
+import { DepositWithBlock, FillStatus, Log, RelayData } from "../../interfaces";
 import {
   BigNumber,
   DepositSearchResult,
@@ -155,45 +155,14 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     }
 
     // No deposit found; revert to searching for it.
-    const upperBound = this.latestHeightSearched || undefined; // Don't permit block 0 as the high block.
-    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
-    const chain = getNetworkName(this.chainId);
-    if (!from) {
-      const reason =
-        `Unable to find ${chain} depositId ${depositId}` +
-        ` within blocks [${this.deploymentBlock}, ${upperBound ?? "latest"}].`;
-      return { found: false, code: InvalidFill.DepositIdNotFound, reason };
-    }
+    const result = await this.queryDepositEvents(depositId);
 
-    const to = from;
-    const tStart = Date.now();
-    // Check both V3FundsDeposited and FundsDeposited events to look for a specified depositId.
-    const { maxLookBack } = this.eventSearchConfig;
-    const query = (
-      await Promise.all([
-        paginatedEventQuery(
-          this.spokePool,
-          this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
-        ),
-        paginatedEventQuery(
-          this.spokePool,
-          this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
-        ),
-      ])
-    ).flat();
-    const tStop = Date.now();
-
-    const event = query.find(({ args }) => args["depositId"].eq(depositId));
-    if (event === undefined) {
-      return {
-        found: false,
-        code: InvalidFill.DepositIdNotFound,
-        reason: `${chain} depositId ${depositId} not found at block ${from}.`,
-      };
+    if ("reason" in result) {
+      return { found: false, code: InvalidFill.DepositIdNotFound, reason: result.reason };
     }
 
+    const { event, elapsedMs } = result;
+
     const partialDeposit = unpackDepositEvent(spreadEventWithBlockNumber(event), this.chainId);
     const quoteBlockNumber = await this.getBlockNumber(partialDeposit.quoteTimestamp);
     const outputToken = partialDeposit.outputToken.isZeroAddress()
@@ -212,13 +181,59 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       at: "SpokePoolClient#findDeposit",
       message: "Located deposit outside of SpokePoolClient's search range",
       deposit,
-      elapsedMs: tStop - tStart,
+      elapsedMs,
     });
-
     return { found: true, deposit };
   }
 
   public override getTimestampForBlock(blockNumber: number): Promise<number> {
     return _getTimestampForBlock(this.spokePool.provider, blockNumber);
   }
+
+  private async queryDepositEvents(
+    depositId: BigNumber
+  ): Promise<{ event: Log; elapsedMs: number } | { reason: string }> {
+    const tStart = Date.now();
+    const upperBound = this.latestHeightSearched || undefined;
+    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const chain = getNetworkName(this.chainId);
+
+    if (!from) {
+      return {
+        reason: `Unable to find ${chain} depositId ${depositId} within blocks [${this.deploymentBlock}, ${
+          upperBound ?? "latest"
+        }].`,
+      };
+    }
+
+    const to = from;
+
+    const { maxLookBack } = this.eventSearchConfig;
+    const events = (
+      await Promise.all([
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
+          { from, to, maxLookBack }
+        ),
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
+          { from, to, maxLookBack }
+        ),
+      ])
+    )
+      .flat()
+      .filter(({ args }) => args["depositId"].eq(depositId));
+
+    const tStop = Date.now();
+    const [event] = events;
+    if (!event) {
+      return {
+        reason: `Unable to find ${chain} depositId ${depositId} within blocks [${from}, ${upperBound ?? "latest"}].`,
+      };
+    }
+
+    return { event, elapsedMs: tStop - tStart };
+  }
 }

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -218,6 +218,11 @@ export class SVMSpokePoolClient extends SpokePoolClient {
    * Finds a deposit based on its deposit ID on the SVM chain.
    */
   public async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
+    // First check memory for deposits
+    const memoryDeposit = this.getDeposit(depositId);
+    if (memoryDeposit) {
+      return { found: true, deposit: memoryDeposit };
+    }
     const deposit = await findDeposit(this.svmEventsClient, depositId, this.logger);
     if (!deposit) {
       return {

package/src/interfaces/SpokePool.ts

@@ -175,3 +175,9 @@ export interface SpokePoolClientsByChain {
 export interface RelayDataWithMessageHash extends RelayData {
   messageHash?: string;
 }
+
+export interface InvalidFill {
+  fill: FillWithBlock;
+  reason: string;
+  deposit?: DepositWithBlock;
+}

package/src/pool/poolClient.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import * as uma from "@uma/sdk";
+import * as uma from "./uma";
 import {
   bnZero,
   toBNWei,

package/src/pool/uma/across/constants.ts

@@ -0,0 +1,2 @@
+export const SECONDS_PER_YEAR = 31557600; // based on 365.25 days per year
+export const DEFAULT_BLOCK_DELTA = 10; // look exchange rate up based on 10 block difference by default

package/src/pool/uma/across/index.ts

@@ -0,0 +1,2 @@
+export { default as TransactionManager } from "./transactionManager";
+export * as constants from "./constants";

package/src/pool/uma/across/transactionManager.ts

@@ -0,0 +1,73 @@
+import assert from "assert";
+import { Signer } from "ethers";
+import { TransactionRequest, TransactionReceipt } from "@ethersproject/abstract-provider";
+
+function makeKey(tx: TransactionRequest) {
+  return JSON.stringify(
+    Object.entries(tx).map(([key, value]) => {
+      return [key, (value || "").toString()];
+    })
+  );
+}
+
+type Config = {
+  confirmations?: number;
+};
+export type Emit = (event: string, key: string, data: TransactionReceipt | string | TransactionRequest | Error) => void;
+export default (config: Config, signer: Signer, emit: Emit = () => null) => {
+  assert(signer.provider, "signer requires a provider, use signer.connect(provider)");
+  const { confirmations = 3 } = config;
+  const requests = new Map<string, TransactionRequest>();
+  const submissions = new Map<string, string>();
+  const mined = new Map<string, TransactionReceipt>();
+  function request(unsignedTx: TransactionRequest) {
+    // this no longer calls signer.populateTransaction, to allow metamask to fill in missing details instead
+    // use overrides if you want to manually fill in other tx details, including the overrides.customData field.
+    const populated = unsignedTx;
+    const key = makeKey(populated);
+    assert(!requests.has(key), "Transaction already in progress");
+    requests.set(key, populated);
+    return key;
+  }
+  async function processRequest(key: string) {
+    const request = requests.get(key);
+    assert(request, "invalid request");
+    // always delete request, it should only be submitted once
+    requests.delete(key);
+    try {
+      const sent = await signer.sendTransaction(request);
+      submissions.set(key, sent.hash);
+      emit("submitted", key, sent.hash);
+    } catch (err) {
+      emit("error", key, err as Error);
+    }
+  }
+  async function processSubmission(key: string) {
+    const hash = submissions.get(key);
+    assert(hash, "invalid submission");
+    assert(signer.provider, "signer requires a provider, use signer.connect(provider)");
+    // we look for this transaction, but it may never find it if its sped up
+    const receipt = await signer.provider.getTransactionReceipt(hash).catch(() => undefined);
+    if (receipt == null) return;
+    if (receipt.confirmations < confirmations) return;
+    submissions.delete(key);
+    mined.set(key, receipt);
+    emit("mined", key, receipt);
+  }
+  function isMined(key: string) {
+    return Promise.resolve(mined.get(key));
+  }
+  async function update() {
+    for (const key of Array.from(requests.keys())) {
+      await processRequest(key);
+    }
+    for (const key of Array.from(submissions.keys())) {
+      await processSubmission(key);
+    }
+  }
+  return {
+    request,
+    isMined,
+    update,
+  };
+};

package/src/pool/uma/clients/erc20/README.md

@@ -0,0 +1,29 @@
+# UMA SDK ERC20 Client
+
+Client to interface with ERC20 style tokens, based on Ethers and typechain.
+
+## Usage
+
+```js
+import {ethers} from 'ethers'
+
+// assume you have a url injected from env
+const provider = new ethers.providers.WebSocketProvider(env.CUSTOM_NODE_URL)
+
+// get the contract instance
+const erc20Address:string = // assume you have an emp address you want to connect to
+const erc20Instance:uma.clients.erc20.Instance = uma.clients.erc20.connect(erc20Address,provider)
+
+// gets all emp events, see ethers queryFilter for details on contructing the query.
+const events = await erc20Instance.queryFilter({})
+
+// returns EventState, defined in the emp client. This can contain user balances as well as approval limits.
+const state:uma.clients.erc20.EventState = uma.clients.erc20.getEventState(events)
+
+// Types
+types {Transfer,Approval, Instance, EventState} = uma.clients.erc20
+// Transfer and Approval are event types
+// Instance is the contract instance once connected
+// Event state describes what the state reconstruction based on contract events will look like
+
+```

package/src/pool/uma/clients/erc20/client.e2e.ts

@@ -0,0 +1,26 @@
+import assert from "assert";
+import { ethers } from "ethers";
+import * as Client from "./client";
+
+const address = "0xeca82185adCE47f39c684352B0439f030f860318";
+// these require integration testing, skip for ci
+describe("erc20", function () {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let events: any;
+  let client: Client.Instance;
+  test("inits", function () {
+    const provider = ethers.providers.getDefaultProvider(process.env.CUSTOM_NODE_URL);
+    client = Client.connect(address, provider);
+    assert.ok(client);
+  });
+  test("getEventState between", async function () {
+    events = await client.queryFilter({}, 12477952, 12477952 + 1000);
+    assert.ok(events.length);
+  });
+  test("getEventState", async function () {
+    const state = await Client.getEventState(events);
+    assert.ok(state.balances);
+    assert.ok(state.approvalsByOwner);
+    assert.ok(state.approvalsBySpender);
+  });
+});

package/src/pool/uma/clients/erc20/client.ts

@@ -0,0 +1,67 @@
+import { ERC20Ethers, ERC20Ethers__factory } from "@uma/contracts-node";
+// eslint-disable-next-line no-restricted-imports
+import { Event } from "ethers";
+import { set } from "lodash";
+import { Balances } from "../../utils";
+import type { Provider, GetEventType } from "../..";
+
+export type Instance = ERC20Ethers;
+const Factory = ERC20Ethers__factory;
+
+export function connect(address: string, provider: Provider): Instance {
+  return Factory.connect(address, provider);
+}
+
+export interface EventState {
+  // any address that created a position, regardless of if they have closed it
+  balances?: Balances;
+  // approvals are keyed both ways here for ease of lookup by either owner or spender
+  approvalsByOwner?: {
+    [owner: string]: {
+      [spender: string]: {
+        amount: string;
+      };
+    };
+  };
+  approvalsBySpender?: {
+    [spender: string]: {
+      [owner: string]: {
+        amount: string;
+      };
+    };
+  };
+}
+
+export type Transfer = GetEventType<Instance, "Transfer">;
+export type Approval = GetEventType<Instance, "Approval">;
+
+// takes all events and returns user balances and approvals
+function reduceEvents(state: EventState = {}, event: Event): EventState {
+  switch (event.event) {
+    case "Transfer": {
+      const typedEvent = event as Transfer;
+      const { from, to, value } = typedEvent.args;
+      const balances = Balances(state.balances || {});
+      balances.sub(from, value);
+      balances.add(to, value);
+      return {
+        ...state,
+        balances: balances.balances,
+      };
+    }
+    case "Approval": {
+      const typedEvent = event as Approval;
+      const { owner, spender, value } = typedEvent.args;
+      set(state, ["approvalsByOwner", owner, spender], value.toString());
+      set(state, ["approvalsBySpender", spender, owner], value.toString());
+      return {
+        ...state,
+      };
+    }
+  }
+  return state;
+}
+
+export function getEventState(events: Event[], initialState: EventState = {}): EventState {
+  return events.reduce(reduceEvents, initialState);
+}

package/src/pool/uma/clients/erc20/index.ts

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

package/src/pool/uma/clients/index.ts

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

package/src/pool/uma/index.ts

@@ -0,0 +1,33 @@
+// eslint-disable-next-line no-restricted-imports
+import { Contract, ethers, Event } from "ethers";
+import type { TypedEventFilterEthers as TypedEventFilter, TypedEventEthers as TypedEvent } from "@uma/contracts-node";
+
+export * as across from "./across";
+export * as clients from "./clients";
+export * as oracle from "./oracle";
+export * as utils from "./utils";
+
+export { type Provider } from "@ethersproject/providers";
+
+type Result = ethers.utils.Result;
+
+export interface Callable {
+  (...args: unknown[]): unknown;
+}
+
+export type SerializableEvent = Omit<
+  Event,
+  "decode" | "removeListener" | "getBlock" | "getTransaction" | "getTransactionReceipt"
+>;
+
+// this convoluted type is meant to cast events to the types you need based on the contract and event name
+// example: type NewContractRegistered = GetEventType<Registry,"NewContractRegistered">;
+// TODO: the any below is a hacky solution because some typechain types fail to resolve due to
+// incompatible TypedEventFilter and TypedEvent types. This will be fixed by upgrading typechain
+// to a version where Ethers events are exported as first class types.
+export type GetEventType<ContractType extends Contract, EventName extends string> = ReturnType<
+  ContractType["filters"][EventName] extends Callable ? ContractType["filters"][EventName] : never
+> extends TypedEventFilter<infer T, infer S>
+  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    TypedEvent<T & S extends Result ? T & S : any>
+  : never;

package/src/pool/uma/oracle/index.ts

@@ -0,0 +1,2 @@
+// Minimal oracle module - only export utils needed by poolClient
+export * as utils from "./utils";

package/src/pool/uma/oracle/utils.ts

@@ -0,0 +1,38 @@
+import { BigNumberish } from "../../../utils";
+import sortedLastIndexBy from "lodash/sortedLastIndexBy";
+
+/**
+ * eventKey. Make a unique and sortable identifier string for an event
+ * Used by poolClient.ts lines 166, 246
+ *
+ * @param {Event} event
+ * @returns {string} - the unique id
+ */
+export function eventKey(event: {
+  blockNumber: BigNumberish;
+  transactionIndex: BigNumberish;
+  logIndex: BigNumberish;
+}): string {
+  return [
+    // we pad these because numbers of varying lengths will not sort correctly, ie "10" will incorrectly sort before "9", but "09" will be correct.
+    event.blockNumber.toString().padStart(16, "0"),
+    event.transactionIndex.toString().padStart(16, "0"),
+    event.logIndex?.toString().padStart(16, "0"),
+    // ~ is the last printable ascii char, so it does not interfere with sorting
+  ].join("~");
+}
+
+/**
+ * insertOrdered. Inserts items in an array maintaining sorted order, in this case lowest to highest. Does not check duplicates.
+ * Mainly used for caching all known events, in order of oldest to newest.
+ * Used by poolClient.ts line 181
+ *
+ * @param {T[]} array
+ * @param {T} element
+ * @param {Function} orderBy
+ */
+export function insertOrderedAscending<T>(array: T[], element: T, orderBy: (element: T) => string | number): T[] {
+  const index = sortedLastIndexBy(array, element, orderBy);
+  array.splice(index, 0, element);
+  return array;
+}

package/src/pool/uma/utils.test.ts

@@ -0,0 +1,24 @@
+import * as utils from "./utils";
+import assert from "assert";
+test("Balances", function () {
+  const balances = utils.Balances();
+  assert.ok(balances);
+  balances.create("a", "100");
+  balances.create("b", "99");
+  let result = balances.get("a");
+  assert.equal(result, "100");
+  result = balances.get("b");
+  assert.equal(result, "99");
+
+  result = balances.sub("a", 1);
+  assert.equal(result, "99");
+
+  result = balances.sub("b", 1);
+  assert.equal(result, "98");
+
+  result = balances.add("b", 2);
+  assert.equal(result, "100");
+
+  const bals = balances.balances;
+  assert.equal(Object.keys(bals).length, 2);
+});

package/src/pool/uma/utils.ts

@@ -0,0 +1,53 @@
+import assert from "assert";
+import { BigNumber, BigNumberish, delay as sleep } from "../../utils";
+
+export { delay as sleep } from "../../utils";
+
+// check if a value is not null or undefined, useful for numbers which could be 0.
+// "is" syntax: https://stackoverflow.com/questions/40081332/what-does-the-is-keyword-do-in-typescript
+/* eslint-disable-next-line @typescript-eslint/ban-types */
+export function exists<T>(value: T | null | undefined): value is NonNullable<T> {
+  return value !== null && value !== undefined;
+}
+
+// useful for maintaining balances from events
+export type Balances = { [key: string]: string };
+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 exists(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 };
+}
+
+// Loop forever but wait until execution is finished before starting next timer. Throw an error to break this
+// or add another utlity function if you need it to end on condition.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function loop(fn: (...args: any[]) => any, delay: number, ...args: any[]) {
+  do {
+    await fn(...args);
+    await sleep(delay);
+    /* eslint-disable-next-line no-constant-condition */
+  } while (true);
+}

package/src/utils/SpokeUtils.ts

@@ -6,6 +6,7 @@ import {
   Fill,
   FillWithBlock,
   FillType,
+  InvalidFill,
   RelayData,
   RelayExecutionEventInfo,
   SlowFillLeaf,
@@ -13,9 +14,10 @@ import {
 } from "../interfaces";
 import { svm } from "../arch";
 import { BigNumber } from "./BigNumberUtils";
-import { isMessageEmpty } from "./DepositUtils";
-import { chainIsSvm } from "./NetworkUtils";
+import { isMessageEmpty, validateFillForDeposit } from "./DepositUtils";
+import { chainIsSvm, getNetworkName } from "./NetworkUtils";
 import { toAddressType } from "./AddressUtils";
+import { SpokePoolClient } from "../clients";
 
 export function isSlowFill(fill: Fill): boolean {
   return fill.relayExecutionInfo.fillType === FillType.SlowFill;
@@ -171,3 +173,62 @@ export function isUnsafeDepositId(depositId: BigNumber): boolean {
 export function getMessageHash(message: string): string {
   return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as Hex);
 }
+
+export async function findInvalidFills(spokePoolClients: {
+  [chainId: number]: SpokePoolClient;
+}): Promise<InvalidFill[]> {
+  const invalidFills: InvalidFill[] = [];
+
+  // Iterate through each spoke pool client
+  for (const spokePoolClient of Object.values(spokePoolClients)) {
+    // Get all fills for this client
+    const fills = spokePoolClient.getFills();
+
+    // Process fills in parallel for this client
+    const fillDepositPairs = await Promise.all(
+      fills.map(async (fill) => {
+        // Skip fills with unsafe deposit IDs
+        if (isUnsafeDepositId(fill.depositId)) {
+          return null; // Return null for unsafe deposits
+        }
+
+        // Get all deposits (including duplicates) for this fill's depositId, both in memory and on-chain
+        const depositResult = await spokePoolClients[fill.originChainId]?.findDeposit(fill.depositId);
+
+        // If no deposits found at all
+        if (!depositResult?.found) {
+          return {
+            fill,
+            deposit: null,
+            reason: `No ${getNetworkName(fill.originChainId)} deposit with depositId ${fill.depositId} found`,
+          };
+        }
+
+        // Check if fill is valid for deposit
+        const validationResult = validateFillForDeposit(fill, depositResult.deposit);
+        if (!validationResult.valid) {
+          return {
+            fill,
+            deposit: depositResult.deposit,
+            reason: validationResult.reason,
+          };
+        }
+
+        // Valid fill with deposit - return null to filter out
+        return null;
+      })
+    );
+
+    for (const pair of fillDepositPairs) {
+      if (pair) {
+        invalidFills.push({
+          fill: pair.fill,
+          reason: pair.reason,
+          deposit: pair.deposit || undefined,
+        });
+      }
+    }
+  }
+
+  return invalidFills;
+}