@across-protocol/sdk 4.0.2 → 4.0.3

package/src/clients/BundleDataClient/utils/FillUtils.ts

@@ -53,6 +53,30 @@ export function getRepaymentChainId(fill: Fill, matchedDeposit: Deposit): number
   return matchedDeposit.fromLiteChain ? matchedDeposit.originChainId : fill.repaymentChainId;
 }
 
+export function forceDestinationRepayment(
+  repaymentChainId: number,
+  matchedDeposit: Deposit & { quoteBlockNumber: number },
+  hubPoolClient: HubPoolClient
+): boolean {
+  if (!matchedDeposit.fromLiteChain) {
+    try {
+      const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
+        matchedDeposit.inputToken,
+        matchedDeposit.originChainId,
+        matchedDeposit.quoteBlockNumber
+      );
+      hubPoolClient.getL2TokenForL1TokenAtBlock(l1TokenCounterpart, repaymentChainId, matchedDeposit.quoteBlockNumber);
+      // Repayment token could be found, this is a valid repayment chain.
+      return false;
+    } catch {
+      // Repayment token doesn't exist on repayment chain via PoolRebalanceRoutes, impossible to repay filler there.
+      return true;
+    }
+  } else {
+    return false;
+  }
+}
+
 // Verify that a fill sent to an EVM chain has a 20 byte address. If the fill does not, then attempt
 // to repay the `msg.sender` of the relay transaction. Otherwise, return undefined.
 export async function verifyFillRepayment(
@@ -72,19 +96,8 @@ export async function verifyFillRepayment(
 
   // If repayment chain doesn't have a Pool Rebalance Route for the input token, then change the repayment
   // chain to the destination chain.
-  if (!isSlowFill(fill) && !matchedDeposit.fromLiteChain) {
-    try {
-      const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-        fill.inputToken,
-        fill.originChainId,
-        matchedDeposit.quoteBlockNumber
-      );
-      hubPoolClient.getL2TokenForL1TokenAtBlock(l1TokenCounterpart, repaymentChainId, matchedDeposit.quoteBlockNumber);
-      // Repayment token could be found, this is a valid repayment chain.
-    } catch {
-      // Repayment token doesn't exist on repayment chain via PoolRebalanceRoutes, impossible to repay filler there.
-      repaymentChainId = fill.destinationChainId;
-    }
+  if (forceDestinationRepayment(repaymentChainId, matchedDeposit, hubPoolClient)) {
+    repaymentChainId = fill.destinationChainId;
   }
 
   if (!isValidEvmAddress(fill.relayer)) {

package/src/clients/BundleDataClient/utils/SuperstructUtils.ts

@@ -1,4 +1,5 @@
 import {
+  Infer,
   object,
   number,
   optional,
@@ -13,6 +14,7 @@ import {
   union,
   type,
 } from "superstruct";
+import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
 import { BigNumber } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
@@ -54,6 +56,7 @@ const SortableEventSS = {
 };
 
 const V3DepositSS = {
+  messageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
   fromLiteChain: defaulted(boolean(), false),
   toLiteChain: defaulted(boolean(), false),
   destinationChainId: number(),
@@ -83,16 +86,17 @@ const V3RelayExecutionEventInfoSS = object({
   fillType: FillTypeSS,
   updatedRecipient: string(),
   updatedMessage: string(),
+  updatedMessageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
 });
 
 const V3FillSS = {
   ...V3RelayDataSS,
+  messageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
   destinationChainId: number(),
   relayer: string(),
   repaymentChainId: number(),
   relayExecutionInfo: V3RelayExecutionEventInfoSS,
   quoteTimestamp: number(),
-  messageHash: optional(string()),
 };
 
 const V3FillWithBlockSS = {
@@ -132,3 +136,5 @@ export const BundleDataSS = type({
   bundleSlowFillsV3: nestedV3DepositRecordWithLpFeePctSS,
   bundleFillsV3: nestedV3BundleFillsSS,
 });
+
+export type BundleData = Infer<typeof BundleDataSS>;

package/src/clients/SpokePoolClient.ts

@@ -9,11 +9,15 @@ import {
   MAX_BIG_INT,
   MakeOptional,
   assign,
-  getRelayDataHash,
+  getRelayEventKey,
   isDefined,
   toBN,
   bnOne,
+  getMessageHash,
   isUnsafeDepositId,
+  isSlowFill,
+  isValidEvmAddress,
+  isZeroAddress,
 } from "../utils";
 import {
   paginatedEventQuery,
@@ -43,6 +47,7 @@ import { getBlockRangeForDepositId, getDepositIdAtBlock, relayFillStatus } from
 import { BaseAbstractClient, isUpdateFailureReason, UpdateFailureReason } from "./BaseAbstractClient";
 import { HubPoolClient } from "./HubPoolClient";
 import { AcrossConfigStoreClient } from "./AcrossConfigStoreClient";
+import { getRepaymentChainId, forceDestinationRepayment } from "./BundleDataClient/utils/FillUtils";
 
 type SpokePoolUpdateSuccess = {
   success: true;
@@ -143,7 +148,7 @@ export class SpokePoolClient extends BaseAbstractClient {
    * unless the original deposit is a duplicate.
    */
   private _getDuplicateDeposits(deposit: DepositWithBlock): DepositWithBlock[] {
-    const depositHash = this.getDepositHash(deposit);
+    const depositHash = getRelayEventKey(deposit);
     return this.duplicateDepositHashes[depositHash] ?? [];
   }
 
@@ -297,8 +302,7 @@ export class SpokePoolClient extends BaseAbstractClient {
    * @returns The corresponding deposit if found, undefined otherwise.
    */
   public getDeposit(depositId: BigNumber): DepositWithBlock | undefined {
-    const depositHash = this.getDepositHash({ depositId, originChainId: this.chainId });
-    return this.depositHashes[depositHash];
+    return Object.values(this.depositHashes).find(({ depositId: _depositId }) => _depositId.eq(depositId));
   }
 
   /**
@@ -307,7 +311,8 @@ export class SpokePoolClient extends BaseAbstractClient {
    * @returns The corresponding SlowFIllRequest event if found, otherwise undefined.
    */
   public getSlowFillRequest(relayData: RelayData): SlowFillRequestWithBlock | undefined {
-    const hash = getRelayDataHash(relayData, this.chainId);
+    const messageHash = getMessageHash(relayData.message);
+    const hash = getRelayEventKey({ ...relayData, messageHash, destinationChainId: this.chainId });
     return this.slowFillRequests[hash];
   }
 
@@ -336,7 +341,7 @@ export class SpokePoolClient extends BaseAbstractClient {
    * @returns The corresponding deposit if found, undefined otherwise.
    */
   public getDepositForFill(fill: Fill): DepositWithBlock | undefined {
-    const deposit = this.depositHashes[this.getDepositHash(fill)];
+    const deposit = this.depositHashes[getRelayEventKey(fill)];
     const match = validateFillForDeposit(fill, deposit);
     if (match.valid) {
       return deposit;
@@ -359,7 +364,7 @@ export class SpokePoolClient extends BaseAbstractClient {
    * @returns A valid fill for the deposit, or undefined.
    */
   public getFillForDeposit(deposit: Deposit): FillWithBlock | undefined {
-    const fills = this.depositHashesToFills[this.getDepositHash(deposit)];
+    const fills = this.depositHashesToFills[getRelayEventKey(deposit)];
     return fills?.find((fill) => validateFillForDeposit(fill, deposit));
   }
 
@@ -376,23 +381,44 @@ export class SpokePoolClient extends BaseAbstractClient {
     invalidFills: Fill[];
   } {
     const { outputAmount } = deposit;
-    const fillsForDeposit = this.depositHashesToFills[this.getDepositHash(deposit)];
+    const fillsForDeposit = this.depositHashesToFills[getRelayEventKey(deposit)];
 
     // If no fills then the full amount is remaining.
     if (fillsForDeposit === undefined || fillsForDeposit.length === 0) {
       return { unfilledAmount: outputAmount, fillCount: 0, invalidFills: [] };
     }
 
-    const { validFills, invalidFills } = fillsForDeposit.reduce(
-      (groupedFills: { validFills: Fill[]; invalidFills: Fill[] }, fill: Fill) => {
+    const { validFills, invalidFills, unrepayableFills } = fillsForDeposit.reduce(
+      (groupedFills: { validFills: Fill[]; invalidFills: Fill[]; unrepayableFills: Fill[] }, fill: Fill) => {
         if (validateFillForDeposit(fill, deposit).valid) {
+          const repaymentChainId = getRepaymentChainId(fill, deposit);
+          // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills that
+          // we'll have to overwrite repayment information for. This includes fills for lite chains where the
+          // repayment address is invalid, and fills for non-lite chains where the repayment address is valid or
+          // the repayment chain is invalid. We don't check that the origin chain is a valid EVM chain for
+          // lite chain deposits yet because only EVM chains are supported on Across...for now. This means
+          // this logic will have to be revisited when we add SVM to log properly.
+          if (
+            this.hubPoolClient &&
+            !isSlowFill(fill) &&
+            (!isValidEvmAddress(fill.relayer) ||
+              forceDestinationRepayment(
+                repaymentChainId,
+                { ...deposit, quoteBlockNumber: this.hubPoolClient!.latestBlockSearched },
+                this.hubPoolClient
+              ))
+          ) {
+            groupedFills.unrepayableFills.push(fill);
+          }
+          // This fill is still valid and means that the deposit cannot be filled on-chain anymore, but it
+          // also can be unrepayable which we should want to log.
           groupedFills.validFills.push(fill);
         } else {
           groupedFills.invalidFills.push(fill);
         }
         return groupedFills;
       },
-      { validFills: [], invalidFills: [] }
+      { validFills: [], invalidFills: [], unrepayableFills: [] }
     );
 
     // Log any invalid deposits with same deposit id but different params.
@@ -407,6 +433,17 @@ export class SpokePoolClient extends BaseAbstractClient {
         notificationPath: "across-invalid-fills",
       });
     }
+    const unrepayableFillsForDeposit = unrepayableFills.filter((x) => x.depositId.eq(deposit.depositId));
+    if (unrepayableFillsForDeposit.length > 0) {
+      this.logger.warn({
+        at: "SpokePoolClient",
+        chainId: this.chainId,
+        message: "Unrepayable fills found where we need to switch repayment address and or chain",
+        deposit,
+        unrepayableFills: Object.fromEntries(unrepayableFillsForDeposit.map((x) => [x.relayer, x])),
+        notificationPath: "across-unrepayable-fills",
+      });
+    }
 
     // If all fills are invalid we can consider this unfilled.
     if (validFills.length === 0) {
@@ -574,12 +611,17 @@ export class SpokePoolClient extends BaseAbstractClient {
       }
     }
 
-    if (eventsToQuery.includes("V3FundsDeposited")) {
-      const depositEvents = queryResults[eventsToQuery.indexOf("V3FundsDeposited")] ?? [];
+    // Performs the indexing of a deposit-like spoke pool event.
+    const queryDepositEvents = async (eventName: string) => {
+      const depositEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
       if (depositEvents.length > 0) {
-        this.log("debug", `Using ${depositEvents.length} newly queried deposit events for chain ${this.chainId}`, {
-          earliestEvent: depositEvents[0].blockNumber,
-        });
+        this.log(
+          "debug",
+          `Using ${depositEvents.length} newly queried ${eventName} deposit events for chain ${this.chainId}`,
+          {
+            earliestEvent: depositEvents[0].blockNumber,
+          }
+        );
       }
 
       // For each deposit, resolve its quoteTimestamp to a block number on the HubPool.
@@ -593,6 +635,7 @@ export class SpokePoolClient extends BaseAbstractClient {
         // Derive and append the common properties that are not part of the onchain event.
         const deposit = {
           ...spreadEventWithBlockNumber(event),
+          messageHash: getMessageHash(event.args.message),
           quoteBlockNumber,
           originChainId: this.chainId,
           // The following properties are placeholders to be updated immediately.
@@ -603,15 +646,15 @@ export class SpokePoolClient extends BaseAbstractClient {
         deposit.fromLiteChain = this.isOriginLiteChain(deposit);
         deposit.toLiteChain = this.isDestinationLiteChain(deposit);
 
-        if (deposit.outputToken === ZERO_ADDRESS) {
+        if (isZeroAddress(deposit.outputToken)) {
           deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
         }
 
-        if (this.depositHashes[this.getDepositHash(deposit)] !== undefined) {
-          assign(this.duplicateDepositHashes, [this.getDepositHash(deposit)], [deposit]);
+        if (this.depositHashes[getRelayEventKey(deposit)] !== undefined) {
+          assign(this.duplicateDepositHashes, [getRelayEventKey(deposit)], [deposit]);
           continue;
         }
-        assign(this.depositHashes, [this.getDepositHash(deposit)], deposit);
+        assign(this.depositHashes, [getRelayEventKey(deposit)], deposit);
 
         if (deposit.depositId.lt(this.earliestDepositIdQueried) && !isUnsafeDepositId(deposit.depositId)) {
           this.earliestDepositIdQueried = deposit.depositId;
@@ -620,11 +663,17 @@ export class SpokePoolClient extends BaseAbstractClient {
           this.latestDepositIdQueried = deposit.depositId;
         }
       }
+    };
+
+    for (const event of ["V3FundsDeposited", "FundsDeposited"]) {
+      if (eventsToQuery.includes(event)) {
+        await queryDepositEvents(event);
+      }
     }
 
-    // Update deposits with speed up requests from depositor.
-    if (eventsToQuery.includes("RequestedSpeedUpV3Deposit")) {
-      const speedUpEvents = queryResults[eventsToQuery.indexOf("RequestedSpeedUpV3Deposit")] ?? [];
+    // Performs indexing of a "speed up deposit"-like event.
+    const querySpeedUpDepositEvents = (eventName: string) => {
+      const speedUpEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
 
       for (const event of speedUpEvents) {
         const speedUp = { ...spreadEventWithBlockNumber(event), originChainId: this.chainId } as SpeedUpWithBlock;
@@ -632,38 +681,54 @@ export class SpokePoolClient extends BaseAbstractClient {
 
         // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
         // if the hash+data exists.
-        const depositHash = this.getDepositHash(speedUp);
+        const deposit = this.getDeposit(speedUp.depositId);
 
         // We can assume all deposits in this lookback window are loaded in-memory already so if the depositHash
         // is not mapped to a deposit, then we can throw away the speedup as it can't be applied to anything.
-        const depositDataAssociatedWithSpeedUp = this.depositHashes[depositHash];
-        if (isDefined(depositDataAssociatedWithSpeedUp)) {
-          this.depositHashes[depositHash] = this.appendMaxSpeedUpSignatureToDeposit(depositDataAssociatedWithSpeedUp);
+        if (isDefined(deposit)) {
+          const eventKey = getRelayEventKey(deposit);
+          this.depositHashes[eventKey] = this.appendMaxSpeedUpSignatureToDeposit(deposit);
         }
       }
-    }
+    };
+
+    // Update deposits with speed up requests from depositor.
+    ["RequestedSpeedUpV3Deposit", "RequestedSpeedUpDeposit"].forEach((event) => {
+      if (eventsToQuery.includes(event)) {
+        querySpeedUpDepositEvents(event);
+      }
+    });
 
-    if (eventsToQuery.includes("RequestedV3SlowFill")) {
-      const slowFillRequests = queryResults[eventsToQuery.indexOf("RequestedV3SlowFill")];
+    // Performs indexing of "requested slow fill"-like events.
+    const queryRequestedSlowFillEvents = (eventName: string) => {
+      const slowFillRequests = queryResults[eventsToQuery.indexOf(eventName)];
       for (const event of slowFillRequests) {
         const slowFillRequest = {
           ...spreadEventWithBlockNumber(event),
           destinationChainId: this.chainId,
         } as SlowFillRequestWithBlock;
 
-        const relayDataHash = getRelayDataHash(slowFillRequest, this.chainId);
-        if (this.slowFillRequests[relayDataHash] !== undefined) {
-          continue;
+        if (eventName === "RequestedV3SlowFill") {
+          slowFillRequest.messageHash = getMessageHash(slowFillRequest.message);
         }
-        this.slowFillRequests[relayDataHash] = slowFillRequest;
+
+        const depositHash = getRelayEventKey({ ...slowFillRequest, destinationChainId: this.chainId });
+        this.slowFillRequests[depositHash] ??= slowFillRequest;
       }
-    }
+    };
+
+    ["RequestedV3SlowFill", "RequestedSlowFill"].forEach((event) => {
+      if (eventsToQuery.includes(event)) {
+        queryRequestedSlowFillEvents(event);
+      }
+    });
 
-    if (eventsToQuery.includes("FilledV3Relay")) {
-      const fillEvents = queryResults[eventsToQuery.indexOf("FilledV3Relay")] ?? [];
+    // Performs indexing of filled relay-like events.
+    const queryFilledRelayEvents = (eventName: string) => {
+      const fillEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
 
       if (fillEvents.length > 0) {
-        this.log("debug", `Using ${fillEvents.length} newly queried fill events for chain ${this.chainId}`, {
+        this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
           earliestEvent: fillEvents[0].blockNumber,
         });
       }
@@ -673,13 +738,26 @@ export class SpokePoolClient extends BaseAbstractClient {
       for (const event of fillEvents) {
         const fill = {
           ...spreadEventWithBlockNumber(event),
+          messageHash: getMessageHash(event.args["message"]),
           destinationChainId: this.chainId,
         } as FillWithBlock;
 
+        if (eventName === "FilledV3Relay") {
+          fill.messageHash = getMessageHash(event.args.message);
+          fill.relayExecutionInfo.updatedMessageHash = getMessageHash(event.args.relayExecutionInfo.updatedMessage);
+        }
+
         assign(this.fills, [fill.originChainId], [fill]);
-        assign(this.depositHashesToFills, [this.getDepositHash(fill)], [fill]);
+        assign(this.depositHashesToFills, [getRelayEventKey(fill)], [fill]);
       }
-    }
+    };
+
+    // Update observed fills with ingested event data.
+    ["FilledV3Relay", "FilledRelay"].forEach((event) => {
+      if (eventsToQuery.includes(event)) {
+        queryFilledRelayEvents(event);
+      }
+    });
 
     if (eventsToQuery.includes("EnabledDepositRoute")) {
       const enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")];
@@ -859,7 +937,7 @@ export class SpokePoolClient extends BaseAbstractClient {
       toLiteChain: true, // To be updated immediately afterwards.
     } as DepositWithBlock;
 
-    if (deposit.outputToken === ZERO_ADDRESS) {
+    if (isZeroAddress(deposit.outputToken)) {
       deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
     }
     deposit.fromLiteChain = this.isOriginLiteChain(deposit);