@across-protocol/sdk 4.0.2 → 4.0.3

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -5,17 +5,30 @@ import winston from "winston";
 import { ZERO_ADDRESS } from "../../constants";
 import {
   Log,
+  Deposit,
   DepositWithBlock,
   FillType,
-  RelayerRefundExecutionWithBlock,
-  SlowFillRequestWithBlock,
+  RelayerRefundExecution,
+  SlowFillRequest,
+  SortableEvent,
   Fill,
-  FillWithBlock,
   SlowFillLeaf,
   SpeedUp,
   TokensBridged,
 } from "../../interfaces";
-import { toBN, toBNWei, getCurrentTime, randomAddress, BigNumber, bnZero, bnOne, bnMax } from "../../utils";
+import {
+  toBN,
+  toBNWei,
+  getCurrentTime,
+  getMessageHash,
+  randomAddress,
+  BigNumber,
+  bnZero,
+  bnMax,
+  bnOne,
+  toAddress,
+  toBytes32,
+} from "../../utils";
 import { SpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
@@ -117,22 +130,32 @@ export class MockSpokePoolClient extends SpokePoolClient {
     EnabledDepositRoute: "address,uint256,bool",
   };
 
-  depositV3(deposit: DepositWithBlock): Log {
-    const event = "V3FundsDeposited";
+  deposit(deposit: Omit<Deposit, "messageHash"> & Partial<SortableEvent>): Log {
+    return this._deposit("FundsDeposited", deposit);
+  }
+
+  depositV3(deposit: Omit<Deposit, "messageHash"> & Partial<SortableEvent>): Log {
+    return this._deposit("V3FundsDeposited", deposit);
+  }
 
+  protected _deposit(event: string, deposit: Omit<Deposit, "messageHash"> & Partial<SortableEvent>): Log {
     const { blockNumber, transactionIndex } = deposit;
-    let { depositId, depositor, destinationChainId, inputToken, inputAmount, outputToken, outputAmount } = deposit;
+    let { depositId, destinationChainId, inputAmount, outputAmount } = deposit;
     depositId ??= this.numberOfDeposits;
     this.numberOfDeposits = depositId.add(bnOne);
 
     destinationChainId ??= random(1, 42161, false);
-    depositor ??= randomAddress();
-    inputToken ??= randomAddress();
-    outputToken ??= inputToken;
+    const addressModifier = event === "FundsDeposited" ? toBytes32 : toAddress;
+    const depositor = addressModifier(deposit.depositor ?? randomAddress());
+    const recipient = addressModifier(deposit.recipient ?? depositor);
+    const inputToken = addressModifier(deposit.inputToken ?? randomAddress());
+    const outputToken = addressModifier(deposit.outputToken ?? inputToken);
+    const exclusiveRelayer = addressModifier(deposit.exclusiveRelayer ?? ZERO_ADDRESS);
+
     inputAmount ??= toBNWei(random(1, 1000, false));
     outputAmount ??= inputAmount.mul(toBN("0.95"));
 
-    const message = deposit["message"] ?? `${event} event at block ${blockNumber}, index ${transactionIndex}.`;
+    const message = deposit["message"] ?? "0x";
     const topics = [destinationChainId, depositId, depositor];
     const quoteTimestamp = deposit.quoteTimestamp ?? getCurrentTime();
     const args = {
@@ -140,14 +163,14 @@ export class MockSpokePoolClient extends SpokePoolClient {
       originChainId: deposit.originChainId ?? this.chainId,
       destinationChainId,
       depositor,
-      recipient: deposit.recipient ?? depositor,
+      recipient,
       inputToken,
       inputAmount,
       outputToken,
       outputAmount,
       quoteTimestamp,
       fillDeadline: deposit.fillDeadline ?? quoteTimestamp + 3600,
-      exclusiveRelayer: deposit.exclusiveRelayer ?? ZERO_ADDRESS,
+      exclusiveRelayer,
       exclusivityDeadline: deposit.exclusivityDeadline ?? quoteTimestamp + 600,
       message,
     };
@@ -162,26 +185,47 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  fillV3Relay(fill: FillWithBlock): Log {
-    const event = "FilledV3Relay";
+  fillV3Relay(fill: Omit<Fill, "messageHash"> & { message: string } & Partial<SortableEvent>): Log {
+    return this._fillRelay("FilledV3Relay", fill);
+  }
+
+  fillRelay(fill: Omit<Fill, "messageHash"> & { message: string } & Partial<SortableEvent>): Log {
+    return this._fillRelay("FilledRelay", fill);
+  }
 
+  protected _fillRelay(
+    event: string,
+    fill: Omit<Fill, "messageHash"> & { message: string } & Partial<SortableEvent>
+  ): Log {
     const { blockNumber, transactionIndex } = fill;
-    let { originChainId, depositId, inputToken, inputAmount, outputAmount, fillDeadline, relayer } = fill;
+    let { originChainId, depositId, inputAmount, outputAmount, fillDeadline } = fill;
     originChainId ??= random(1, 42161, false);
     depositId ??= BigNumber.from(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 addressModifier = event === "FilledRelay" ? toBytes32 : toAddress;
+    const depositor = addressModifier(fill.depositor ?? randomAddress());
+    const recipient = addressModifier(fill.recipient ?? depositor);
+    const inputToken = addressModifier(fill.inputToken ?? randomAddress());
+    const outputToken = addressModifier(fill.outputToken ?? ZERO_ADDRESS);
+    const exclusiveRelayer = addressModifier(fill.exclusiveRelayer ?? ZERO_ADDRESS);
+    const relayer = addressModifier(fill.relayer ?? randomAddress());
+
+    const topics = [originChainId, depositId, relayer]; // @todo verify
+    const message = fill["message"] ?? "0x";
+    const updatedMessage = fill.relayExecutionInfo?.updatedMessage ?? message;
+
+    const relayExecutionInfo = {
+      updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
+      updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
+      fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
+    };
 
-    const args = {
+    const _args = {
       inputToken,
-      outputToken: fill.outputToken ?? ZERO_ADDRESS, // resolved via HubPoolClient.
+      outputToken,
       inputAmount: fill.inputAmount,
       outputAmount: fill.outputAmount,
       repaymentChainId: fill.repaymentChainId ?? this.chainId,
@@ -189,19 +233,40 @@ export class MockSpokePoolClient extends SpokePoolClient {
       depositId,
       fillDeadline,
       exclusivityDeadline: fill.exclusivityDeadline ?? fillDeadline,
-      exclusiveRelayer: fill.exclusiveRelayer ?? ZERO_ADDRESS,
+      exclusiveRelayer,
       relayer,
-      depositor: fill.depositor ?? randomAddress(),
+      depositor,
       recipient,
       message,
       relayExecutionInfo: {
         updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
-        updatedMessage: fill.relayExecutionInfo?.updatedMessage ?? message,
+        updatedMessage,
+        updatedMessageHash: getMessageHash(updatedMessage),
         updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
         fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
       },
     };
 
+    const args =
+      event === "FilledRelay"
+        ? {
+            ..._args,
+            messageHash: getMessageHash(message),
+            relayExecutionInfo: {
+              ...relayExecutionInfo,
+              updatedMessageHash: fill.relayExecutionInfo.updatedMessageHash ?? getMessageHash(fill.message),
+            },
+          }
+        : {
+            // FilledV3Relay
+            ..._args,
+            message,
+            relayExecutionInfo: {
+              ...relayExecutionInfo,
+              updatedMessage: fill.relayExecutionInfo?.updatedMessage ?? message,
+            },
+          };
+
     return this.eventManager.generateEvent({
       event,
       address: this.spokePool.address,
@@ -213,15 +278,28 @@ export class MockSpokePoolClient extends SpokePoolClient {
   }
 
   speedUpV3Deposit(speedUp: SpeedUp): Log {
-    const event = "RequestedSpeedUpV3Deposit";
-    const topics = [speedUp.depositId, speedUp.depositor];
+    return this._speedUpDeposit("RequestedSpeedUpV3Deposit", speedUp);
+  }
+
+  speedUpDeposit(speedUp: SpeedUp): Log {
+    return this._speedUpDeposit("RequestedSpeedUpDeposit", speedUp);
+  }
+
+  protected _speedUpDeposit(event: string, speedUp: SpeedUp): Log {
+    const addressModifier = event === "RequestedSpeedUpDeposit" ? toBytes32 : toAddress;
+    const depositor = addressModifier(speedUp.depositor);
+    const topics = [speedUp.depositId, depositor];
     const args = { ...speedUp };
 
     return this.eventManager.generateEvent({
       event,
       address: this.spokePool.address,
       topics: topics.map((topic) => topic.toString()),
-      args,
+      args: {
+        ...args,
+        depositor,
+        updatedRecipient: addressModifier(speedUp.updatedRecipient),
+      },
     });
   }
 
@@ -238,18 +316,37 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  requestV3SlowFill(request: SlowFillRequestWithBlock): Log {
-    const event = "RequestedV3SlowFill";
+  requestV3SlowFill(request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>): Log {
+    return this._requestSlowFill("RequestedV3SlowFill", request);
+  }
+
+  requestSlowFill(request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>): Log {
+    return this._requestSlowFill("RequestedSlowFill", request);
+  }
 
+  protected _requestSlowFill(
+    event: string,
+    request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>
+  ): Log {
     const { originChainId, depositId } = request;
     const topics = [originChainId, depositId];
     const args = { ...request };
 
+    const addressModifier = event === "RequestedSlowFill" ? toBytes32 : toAddress;
+    const depositor = addressModifier(args.depositor ?? randomAddress());
+
     return this.eventManager.generateEvent({
       event,
       address: this.spokePool.address,
       topics: topics.map((topic) => topic.toString()),
-      args,
+      args: {
+        ...args,
+        depositor,
+        recipient: addressModifier(args.recipient ?? depositor),
+        inputToken: addressModifier(args.inputToken ?? randomAddress()),
+        outputToken: addressModifier(args.outputToken ?? ZERO_ADDRESS),
+        exclusiveRelayer: addressModifier(args.exclusiveRelayer ?? ZERO_ADDRESS),
+      },
       blockNumber: request.blockNumber,
       transactionIndex: request.transactionIndex,
     });
@@ -257,8 +354,8 @@ 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): Log {
-    const fill: Fill = {
+  executeV3SlowRelayLeaf(leaf: Omit<SlowFillLeaf, "messageHash">): Log {
+    const fill = {
       ...leaf.relayData,
       destinationChainId: this.chainId,
       relayer: ZERO_ADDRESS,
@@ -267,14 +364,15 @@ export class MockSpokePoolClient extends SpokePoolClient {
         updatedRecipient: leaf.relayData.recipient,
         updatedOutputAmount: leaf.updatedOutputAmount,
         updatedMessage: leaf.relayData.message,
+        updatedMessageHash: getMessageHash(leaf.relayData.message),
         fillType: FillType.SlowFill,
       },
     };
 
-    return this.fillV3Relay(fill as FillWithBlock);
+    return this.fillV3Relay(fill);
   }
 
-  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Log {
+  executeRelayerRefundLeaf(refund: RelayerRefundExecution & Partial<SortableEvent>): Log {
     const event = "ExecutedRelayerRefundRoot";
 
     const chainId = refund.chainId ?? this.chainId;

package/src/constants.ts

@@ -35,7 +35,11 @@ export const PRE_FILL_MIN_CONFIG_STORE_VERSION = 5;
 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 = 3;
+// Version 3:
+// - Changed depositId number -> string (uint32 -> uint256).
+// Version 4:
+// - Dropped message field from Fill event data.
+export const ARWEAVE_TAG_APP_VERSION = 4;
 
 /**
  * A default list of chain Ids that the protocol supports. This is outlined
@@ -56,6 +60,7 @@ export const DEFAULT_SIMULATED_RELAYER_ADDRESS_TEST = "0x9A8f92a830A5cB89a3816e3
 export const DEFAULT_ARWEAVE_STORAGE_ADDRESS = "Z6hjBM8FHu90lYWB8o5jR1dfX92FlV2WBaND9xgp8Lg";
 
 export const EMPTY_MESSAGE = "0x";
+export const UNDEFINED_MESSAGE_HASH = "";
 
 export const BRIDGED_USDC_SYMBOLS = [
   TOKEN_SYMBOLS_MAP["USDC.e"].symbol,

package/src/interfaces/SpokePool.ts

@@ -22,6 +22,7 @@ export interface RelayData {
 }
 
 export interface Deposit extends RelayData {
+  messageHash: string;
   destinationChainId: number;
   quoteTimestamp: number;
   speedUpSignature?: string;
@@ -51,11 +52,13 @@ export enum FillType {
 export interface RelayExecutionEventInfo {
   updatedRecipient: string;
   updatedOutputAmount: BigNumber;
-  updatedMessage: string;
+  updatedMessage?: string;
+  updatedMessageHash: string;
   fillType: FillType;
 }
 
-export interface Fill extends RelayData {
+export interface Fill extends Omit<RelayData, "message"> {
+  messageHash: string;
   destinationChainId: number;
   relayer: string;
   repaymentChainId: number;
@@ -77,6 +80,7 @@ export interface SpeedUp {
 export interface SpeedUpWithBlock extends SpeedUp, SortableEvent {}
 
 export interface SlowFillRequest extends RelayData {
+  messageHash: string;
   destinationChainId: number;
 }
 export interface SlowFillRequestWithBlock extends SlowFillRequest, SortableEvent {}

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -71,7 +71,7 @@ export class QueryBase implements QueryInterface {
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
-    deposit: Deposit,
+    deposit: Omit<Deposit, "messageHash">,
     relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     options: Partial<{
       gasPrice: BigNumberish;
@@ -121,7 +121,7 @@ export class QueryBase implements QueryInterface {
    * @returns PopulatedTransaction
    */
   getUnsignedTxFromDeposit(
-    deposit: Deposit,
+    deposit: Omit<Deposit, "messageHash">,
     relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
@@ -133,7 +133,10 @@ export class QueryBase implements QueryInterface {
    * @param relayer Sender of PopulatedTransaction
    * @returns Estimated gas cost based on ethers.VoidSigner's gas estimation
    */
-  async getNativeGasCost(deposit: Deposit, relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS): Promise<BigNumber> {
+  async getNativeGasCost(
+    deposit: Omit<Deposit, "messageHash">,
+    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
+  ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
     const voidSigner = new VoidSigner(relayer, this.provider);
     return voidSigner.estimateGas(unsignedTx);

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -22,7 +22,7 @@ import { Transport } from "viem";
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
 export interface QueryInterface {
   getGasCosts: (
-    deposit: Deposit,
+    deposit: Omit<Deposit, "messageHash">,
     relayer: string,
     options?: Partial<{
       gasPrice: BigNumberish;

package/src/utils/AddressUtils.ts

@@ -39,10 +39,14 @@ export function compareAddressesSimple(addressA?: string, addressB?: string): bo
   return addressA.toLowerCase() === addressB.toLowerCase();
 }
 
-// Converts an input (assumed to be) bytes32 string into a bytes20 string.
-// If the input is not a bytes32 but is less than type(uint160).max, then this function
-// will still succeed.
-// Throws an error if the string as an unsigned integer is greater than type(uint160).max.
+// Converts an input hex data string into a bytes32 string. Note that the output bytes will be lowercase
+// so that it naturally matches with ethers event data.
+// Throws an error if the input string is already greater than 32 bytes.
+export function toBytes32(address: string): string {
+  return utils.hexZeroPad(address, 32).toLowerCase();
+}
+
+// Checks if the input string can be coerced into a bytes20 evm address. Returns true if it is possible, and false otherwise.
 export function toAddress(hexString: string): string {
   // rawAddress is the address which is not properly checksummed.
   const rawAddress = utils.hexZeroPad(utils.hexStripZeros(hexString), 20);

package/src/utils/CachingUtils.ts

@@ -2,7 +2,7 @@ import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL } from "../constants";
 import { CachingMechanismInterface, Deposit, Fill, SlowFillRequest } from "../interfaces";
 import { assert } from "./LogUtils";
 import { composeRevivers, objectWithBigNumberReviver } from "./ReviverUtils";
-import { getRelayHashFromEvent } from "./SpokeUtils";
+import { getRelayEventKey } from "./SpokeUtils";
 import { getCurrentTime } from "./TimeUtils";
 import { isDefined } from "./TypeGuards";
 
@@ -51,6 +51,6 @@ export async function setDepositInCache(
  * @returns The key for caching the event.
  */
 export function getDepositKey(bridgeEvent: Deposit | Fill | SlowFillRequest): string {
-  const relayHash = getRelayHashFromEvent(bridgeEvent);
+  const relayHash = getRelayEventKey(bridgeEvent);
   return `deposit_${bridgeEvent.originChainId}_${bridgeEvent.depositId.toString()}_${relayHash}`;
 }

package/src/utils/DepositUtils.ts

@@ -3,9 +3,10 @@ import { SpokePoolClient } from "../clients";
 import { DEFAULT_CACHING_TTL, EMPTY_MESSAGE, ZERO_BYTES } from "../constants";
 import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, SlowFillRequest } from "../interfaces";
 import { getNetworkName } from "./NetworkUtils";
+import { bnZero } from "./BigNumberUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
 import { validateFillForDeposit } from "./FlowUtils";
-import { isUnsafeDepositId } from "./SpokeUtils";
+import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getCurrentTime } from "./TimeUtils";
 import { isDefined } from "./TypeGuards";
 import { isDepositFormedCorrectly } from "./ValidatorUtils";
@@ -122,6 +123,8 @@ export async function queryHistoricalDepositForFill(
     }
   }
 
+  deposit.messageHash ??= getMessageHash(deposit.message);
+
   const match = validateFillForDeposit(fill, deposit);
   if (match.valid) {
     return { found: true, deposit };
@@ -146,8 +149,10 @@ export function isZeroValueDeposit(deposit: Pick<Deposit, "inputAmount" | "messa
   return deposit.inputAmount.eq(0) && isMessageEmpty(deposit.message);
 }
 
-export function isZeroValueFillOrSlowFillRequest(e: Pick<Fill | SlowFillRequest, "inputAmount" | "message">): boolean {
-  return e.inputAmount.eq(0) && isFillOrSlowFillRequestMessageEmpty(e.message);
+export function isZeroValueFillOrSlowFillRequest(
+  e: Pick<Fill | SlowFillRequest, "inputAmount" | "messageHash">
+): boolean {
+  return e.inputAmount.eq(bnZero) && e.messageHash === ZERO_BYTES;
 }
 
 /**

package/src/utils/FlowUtils.ts

@@ -1,5 +1,6 @@
 import { isDefined } from "../utils";
 import { Deposit, RelayData } from "../interfaces";
+import { UNDEFINED_MESSAGE_HASH } from "../constants";
 
 export const RELAYDATA_KEYS = [
   "depositId",
@@ -14,14 +15,14 @@ export const RELAYDATA_KEYS = [
   "fillDeadline",
   "exclusivityDeadline",
   "exclusiveRelayer",
-  "message",
+  "messageHash",
 ] as const;
 
 // Ensure that each deposit element is included with the same value in the fill. This includes all elements defined
 // by the depositor as well as destinationToken, which are pulled from other clients.
 export function validateFillForDeposit(
-  relayData: RelayData & { destinationChainId: number },
-  deposit?: Deposit
+  relayData: Omit<RelayData, "message"> & { messageHash: string; destinationChainId: number },
+  deposit?: Omit<Deposit, "quoteTimestamp" | "fromLiteChain" | "toLiteChain">
 ): { valid: true } | { valid: false; reason: string } {
   if (deposit === undefined) {
     return { valid: false, reason: "Deposit is undefined" };
@@ -30,7 +31,12 @@ export function validateFillForDeposit(
   // Note: this short circuits when a key is found where the comparison doesn't match.
   // TODO: if we turn on "strict" in the tsconfig, the elements of FILL_DEPOSIT_COMPARISON_KEYS will be automatically
   // validated against the fields in Fill and Deposit, generating an error if there is a discrepency.
-  const invalidKey = RELAYDATA_KEYS.find((key) => relayData[key].toString() !== deposit[key].toString());
+  let invalidKey = RELAYDATA_KEYS.find((key) => relayData[key].toString() !== deposit[key].toString());
+
+  // There should be no paths for `messageHash` to be unset, but mask it off anyway.
+  if (!isDefined(invalidKey) && [relayData.messageHash, deposit.messageHash].includes(UNDEFINED_MESSAGE_HASH)) {
+    invalidKey = "messageHash";
+  }
 
   return isDefined(invalidKey)
     ? { valid: false, reason: `${invalidKey} mismatch (${relayData[invalidKey]} != ${deposit[invalidKey]})` }

package/src/utils/SpokeUtils.ts

@@ -1,7 +1,7 @@
 import assert from "assert";
 import { BytesLike, Contract, PopulatedTransaction, providers, utils as ethersUtils } from "ethers";
 import { CHAIN_IDs, MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
-import { Deposit, Fill, FillStatus, FillWithBlock, RelayData, SlowFillRequest } from "../interfaces";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../interfaces";
 import { SpokePoolClient } from "../clients";
 import { chunk } from "./ArrayUtils";
 import { BigNumber, toBN, bnOne, bnZero } from "./BigNumberUtils";
@@ -21,7 +21,7 @@ type BlockTag = providers.BlockTag;
  */
 export function populateV3Relay(
   spokePool: Contract,
-  deposit: Deposit,
+  deposit: Omit<Deposit, "messageHash">,
   relayer: string,
   repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {
@@ -57,6 +57,35 @@ export function populateV3Relay(
   return spokePool.populateTransaction.fillV3Relay(v3RelayData, repaymentChainId, { from: relayer });
 }
 
+/**
+ * Concatenate all fields from a Deposit, Fill or SlowFillRequest into a single string.
+ * This can be used to identify a bridge event in a mapping. This is used instead of the actual keccak256 hash
+ * (getRelayDataHash()) for two reasons: performance and the fact that only Deposit includes the `message` field, which
+ * is required to compute a complete RelayData hash.
+ * note: This function should _not_ be used to query the SpokePool.fillStatuses mapping.
+ */
+export function getRelayEventKey(
+  data: Omit<RelayData, "message"> & { messageHash: string; destinationChainId: number }
+): string {
+  return [
+    data.depositor,
+    data.recipient,
+    data.exclusiveRelayer,
+    data.inputToken,
+    data.outputToken,
+    data.inputAmount,
+    data.outputAmount,
+    data.originChainId,
+    data.destinationChainId,
+    data.depositId,
+    data.fillDeadline,
+    data.exclusivityDeadline,
+    data.messageHash,
+  ]
+    .map(String)
+    .join("-");
+}
+
 /**
  * Find the block range that contains the deposit ID. This is a binary search that searches for the block range
  * that contains the deposit ID.
@@ -257,7 +286,7 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   );
 }
 
-export function getRelayHashFromEvent(e: Deposit | Fill | SlowFillRequest): string {
+export function getRelayHashFromEvent(e: RelayData & { destinationChainId: number }): string {
   return getRelayDataHash(e, e.destinationChainId);
 }
 
@@ -428,6 +457,7 @@ export async function findFillEvent(
   const fill = {
     ...spreadEventWithBlockNumber(event),
     destinationChainId,
+    messageHash: getMessageHash(event.args.message),
   } as FillWithBlock;
   return fill;
 }