@across-protocol/sdk 4.2.7 → 4.2.9-alpha.0

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -13,13 +13,12 @@ import {
   isDefined,
   getMessageHash,
   isSlowFill,
-  isValidEvmAddress,
   isZeroAddress,
-  toAddress,
   validateFillForDeposit,
   chainIsEvm,
   chainIsProd,
   Address,
+  toAddressType,
 } from "../../utils";
 import { duplicateEvent, sortEventsAscendingInPlace } from "../../utils/EventUtils";
 import { ZERO_ADDRESS } from "../../constants";
@@ -37,6 +36,7 @@ import {
   SortableEvent,
   SpeedUpWithBlock,
   TokensBridged,
+  RelayExecutionEventInfo,
 } from "../../interfaces";
 import { BaseAbstractClient, UpdateFailureReason } from "../BaseAbstractClient";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
@@ -202,8 +202,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @param relayer The relayer address.
    * @returns A list of fills.
    */
-  public getFillsForRelayer(relayer: string): FillWithBlock[] {
-    return this.getFills().filter((fill) => fill.relayer === relayer);
+  public getFillsForRelayer(relayer: Address): FillWithBlock[] {
+    return this.getFills().filter((fill) => fill.relayer.eq(relayer));
   }
 
   /**
@@ -251,7 +251,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     const { depositId, depositor } = deposit;
 
     // Note: we know depositor cannot be more than 20 bytes since this is guaranteed by contracts.
-    const speedups = this.speedUps[toAddress(depositor)]?.[depositId.toString()];
+    // Additionally, speed ups can only be done on EVM networks.
+    const speedups = this.speedUps[depositor.toEvmAddress()]?.[depositId.toString()];
 
     if (!isDefined(speedups) || speedups.length === 0) {
       return deposit;
@@ -302,9 +303,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @param relayData RelayData field for the SlowFill request.
    * @returns The corresponding SlowFillRequest event if found, otherwise undefined.
    */
-  public getSlowFillRequest(relayData: RelayData): SlowFillRequestWithBlock | undefined {
-    const messageHash = getMessageHash(relayData.message);
-    const hash = getRelayEventKey({ ...relayData, messageHash, destinationChainId: this.chainId });
+  public getSlowFillRequest(
+    relayData: Omit<RelayData, "message"> & { messageHash: string }
+  ): SlowFillRequestWithBlock | undefined {
+    const hash = getRelayEventKey({ ...relayData, destinationChainId: this.chainId });
     return this.slowFillRequests[hash];
   }
 
@@ -383,7 +385,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
           if (
             this.hubPoolClient &&
             !isSlowFill(fill) &&
-            (!chainIsEvm(repaymentChainId) || !isValidEvmAddress(fill.relayer))
+            chainIsEvm(repaymentChainId) &&
+            !fill.relayer.isValidEvmAddress()
           ) {
             groupedFills.unrepayableFills.push(fill);
           }
@@ -416,7 +419,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         chainId: this.chainId,
         message: "Invalid fills found matching deposit ID",
         deposit,
-        invalidFills: Object.fromEntries(invalidFillsForDeposit.map((x) => [x.relayer, x])),
+        invalidFills: Object.fromEntries(invalidFillsForDeposit.map((x) => [x.relayer.toAddress(), x])),
         notificationPath: "across-invalid-fills",
       });
     }
@@ -427,7 +430,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         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])),
+        unrepayableFills: Object.fromEntries(unrepayableFillsForDeposit.map((x) => [x.relayer.toAddress(), x])),
         notificationPath: "across-unrepayable-fills",
       });
     }
@@ -499,14 +502,36 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     const { events: queryResults, currentTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
-      for (const event of queryResults[eventsToQuery.indexOf("TokensBridged")] as TokensBridged[]) {
-        this.tokensBridged.push(event);
+      for (const _event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
+        const event = _event as TokensBridged & {
+          l2TokenAddress: string;
+        };
+        this.tokensBridged.push({
+          ...event,
+          l2TokenAddress: toAddressType(event.l2TokenAddress),
+        } as TokensBridged);
       }
     }
 
     // Performs the indexing of a deposit-like spoke pool event.
     const queryDepositEvents = async (eventName: string) => {
-      const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as DepositWithBlock[];
+      const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
+        const event = _event as DepositWithBlock & {
+          depositor: string;
+          recipient: string;
+          inputToken: string;
+          outputToken: string;
+          exclusiveRelayer: string;
+        };
+        return {
+          ...event,
+          depositor: toAddressType(event.depositor),
+          recipient: toAddressType(event.recipient),
+          inputToken: toAddressType(event.inputToken),
+          outputToken: toAddressType(event.outputToken),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
+        } as DepositWithBlock;
+      }) as DepositWithBlock[];
       if (depositEvents.length > 0) {
         this.log(
           "debug",
@@ -555,7 +580,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       }
     };
 
-    for (const event of ["V3FundsDeposited", "FundsDeposited"]) {
+    for (const event of ["FundsDeposited"]) {
       if (eventsToQuery.includes(event)) {
         await queryDepositEvents(event);
       }
@@ -563,11 +588,21 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of a "speed up deposit"-like event.
     const querySpeedUpDepositEvents = (eventName: string) => {
-      const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SpeedUpWithBlock[];
+      const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
+        const event = _event as SpeedUpWithBlock & { depositor: string; updatedRecipient: string };
+        return {
+          ...event,
+          depositor: toAddressType(event.depositor),
+          updatedRecipient: toAddressType(event.updatedRecipient),
+        } as SpeedUpWithBlock;
+      });
 
       for (const event of speedUpEvents) {
-        const speedUp = { ...event, originChainId: this.chainId };
-        assign(this.speedUps, [speedUp.depositor, speedUp.depositId.toString()], [speedUp]);
+        const speedUp = {
+          ...event,
+          originChainId: this.chainId,
+        };
+        assign(this.speedUps, [speedUp.depositor.toAddress(), speedUp.depositId.toString()], [speedUp]);
 
         // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
         // if the hash+data exists.
@@ -583,7 +618,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     };
 
     // Update deposits with speed up requests from depositor.
-    ["RequestedSpeedUpV3Deposit", "RequestedSpeedUpDeposit"].forEach((event) => {
+    ["RequestedSpeedUpDeposit"].forEach((event) => {
       if (eventsToQuery.includes(event)) {
         querySpeedUpDepositEvents(event);
       }
@@ -591,17 +626,29 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of "requested slow fill"-like events.
     const queryRequestedSlowFillEvents = (eventName: string) => {
-      const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SlowFillRequestWithBlock[];
+      const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
+        const event = _event as SlowFillRequestWithBlock & {
+          depositor: string;
+          recipient: string;
+          inputToken: string;
+          outputToken: string;
+          exclusiveRelayer: string;
+        };
+        return {
+          ...event,
+          depositor: toAddressType(event.depositor),
+          recipient: toAddressType(event.recipient),
+          inputToken: toAddressType(event.inputToken),
+          outputToken: toAddressType(event.outputToken),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
+        } as SlowFillRequestWithBlock;
+      }) as SlowFillRequestWithBlock[];
       for (const event of slowFillRequests) {
         const slowFillRequest = {
           ...event,
           destinationChainId: this.chainId,
         };
 
-        if (eventName === "RequestedV3SlowFill") {
-          slowFillRequest.messageHash = getMessageHash(slowFillRequest.message);
-        }
-
         const depositHash = getRelayEventKey({ ...slowFillRequest, destinationChainId: this.chainId });
 
         // Sanity check that this event is not a duplicate.
@@ -614,7 +661,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       }
     };
 
-    ["RequestedV3SlowFill", "RequestedSlowFill"].forEach((event) => {
+    ["RequestedSlowFill"].forEach((event) => {
       if (eventsToQuery.includes(event)) {
         queryRequestedSlowFillEvents(event);
       }
@@ -622,7 +669,30 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of filled relay-like events.
     const queryFilledRelayEvents = (eventName: string) => {
-      const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as FillWithBlock[];
+      const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []).map((_event) => {
+        const event = _event as FillWithBlock & {
+          depositor: string;
+          recipient: string;
+          inputToken: string;
+          outputToken: string;
+          exclusiveRelayer: string;
+          relayer: string;
+          relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
+        };
+        return {
+          ...event,
+          depositor: toAddressType(event.depositor),
+          recipient: toAddressType(event.recipient),
+          inputToken: toAddressType(event.inputToken),
+          outputToken: toAddressType(event.outputToken),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
+          relayer: toAddressType(event.relayer),
+          relayExecutionInfo: {
+            ...event.relayExecutionInfo,
+            updatedRecipient: toAddressType(event.relayExecutionInfo.updatedRecipient),
+          },
+        } as FillWithBlock;
+      }) as FillWithBlock[];
 
       if (fillEvents.length > 0) {
         this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
@@ -638,11 +708,6 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
           destinationChainId: this.chainId,
         };
 
-        if (eventName === "FilledV3Relay") {
-          fill.messageHash = getMessageHash((event as unknown as { message: string }).message);
-          fill.relayExecutionInfo.updatedMessageHash = getMessageHash(event.relayExecutionInfo.updatedMessage!);
-        }
-
         // Sanity check that this event is not a duplicate.
         const duplicateFill = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
         if (duplicateFill) {
@@ -656,7 +721,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     };
 
     // Update observed fills with ingested event data.
-    ["FilledV3Relay", "FilledRelay"].forEach((event) => {
+    ["FilledRelay"].forEach((event) => {
       if (eventsToQuery.includes(event)) {
         queryFilledRelayEvents(event);
       }
@@ -731,9 +796,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @param deposit The deposit to retrieve the destination token for.
    * @returns The destination token.
    */
-  protected getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
+  protected getDestinationTokenForDeposit(deposit: DepositWithBlock): Address {
     if (!this.canResolveZeroAddressOutputToken(deposit)) {
-      return ZERO_ADDRESS;
+      return toAddressType(ZERO_ADDRESS);
     }
     // L1 token should be resolved if we get here:
     const l1Token = this.hubPoolClient!.getL1TokenForL2TokenAtBlock(
@@ -741,10 +806,12 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       deposit.originChainId,
       deposit.quoteBlockNumber
     )!;
-    return (
-      this.hubPoolClient!.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber) ??
-      ZERO_ADDRESS
+    const counterpartToken = this.hubPoolClient!.getL2TokenForL1TokenAtBlock(
+      l1Token,
+      deposit.destinationChainId,
+      deposit.quoteBlockNumber
     );
+    return counterpartToken ?? toAddressType(ZERO_ADDRESS);
   }
 
   /**

package/src/clients/mocks/MockHubPoolClient.ts

@@ -1,16 +1,17 @@
 import winston from "winston";
 import { Contract } from "ethers";
-import { BigNumber, randomAddress, assign, bnZero } from "../../utils";
-import { L1Token, Log, PendingRootBundle, RealizedLpFee } from "../../interfaces";
+import { BigNumber, randomAddress, assign, bnZero, toAddressType, EvmAddress, Address, isDefined } from "../../utils";
+import { TokenInfo, Log, PendingRootBundle, RealizedLpFee, L1TokenInfo } from "../../interfaces";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "../AcrossConfigStoreClient";
 import { HubPoolClient, HubPoolUpdate, LpFeeRequest } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
+import { ZERO_ADDRESS } from "../../constants";
 
 const emptyRootBundle: PendingRootBundle = {
   poolRebalanceRoot: "",
   relayerRefundRoot: "",
   slowRelayRoot: "",
-  proposer: "",
+  proposer: EvmAddress.from(ZERO_ADDRESS),
   unclaimedPoolRebalanceLeafCount: 0,
   challengePeriodEndTimestamp: 0,
   bundleEvaluationBlockNumbers: [],
@@ -22,9 +23,9 @@ export class MockHubPoolClient extends HubPoolClient {
   private realizedLpFeePct: BigNumber = bnZero;
   private realizedLpFeePctOverride = false;
 
-  private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
+  private l1TokensMock: L1TokenInfo[] = []; // L1Tokens and their associated info.
 
-  private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
+  private spokePoolTokens: { [l1Token: string]: { [chainId: number]: Address } } = {};
 
   private eventManager: EventManager;
 
@@ -69,7 +70,7 @@ export class MockHubPoolClient extends HubPoolClient {
       [chainId],
       [
         {
-          spokePool: contract,
+          spokePool: toAddressType(contract),
           blockNumber: blockNumber,
           transactionIndex: 0,
           logIndex: 0,
@@ -82,7 +83,7 @@ export class MockHubPoolClient extends HubPoolClient {
     this.latestHeightSearched = blockNumber;
   }
 
-  addL1Token(l1Token: L1Token) {
+  addL1Token(l1Token: TokenInfo) {
     this.l1TokensMock.push(l1Token);
   }
 
@@ -92,19 +93,19 @@ export class MockHubPoolClient extends HubPoolClient {
 
   setTokenMapping(l1Token: string, chainId: number, l2Token: string) {
     this.spokePoolTokens[l1Token] ??= {};
-    this.spokePoolTokens[l1Token][chainId] = l2Token;
+    this.spokePoolTokens[l1Token][chainId] = toAddressType(l2Token);
   }
 
-  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
-    if (this.spokePoolTokens[l1Token]?.[destinationChainId]) {
+  l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
+    if (this.spokePoolTokens[l1Token.toEvmAddress()]?.[destinationChainId]) {
       return true;
     } else {
       return super.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, hubBlockNumber);
     }
   }
-  l2TokenHasPoolRebalanceRoute(l2Token: string, chainId: number, hubPoolBlock: number): boolean {
+  l2TokenHasPoolRebalanceRoute(l2Token: Address, chainId: number, hubPoolBlock: number): boolean {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId]?.eq(l2Token)
     );
     if (!l1Token) {
       return super.l2TokenHasPoolRebalanceRoute(l2Token, chainId, hubPoolBlock);
@@ -115,20 +116,24 @@ export class MockHubPoolClient extends HubPoolClient {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }
 
-  getL1TokenForL2TokenAtBlock(l2Token: string, chainId: number, blockNumber: number): string {
+  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId].eq(l2Token)
     );
-    return l1Token ?? super.getL1TokenForL2TokenAtBlock(l2Token, chainId, blockNumber);
+    if (isDefined(l1Token)) {
+      return EvmAddress.from(l1Token);
+    } else {
+      return super.getL1TokenForL2TokenAtBlock(l2Token, chainId, blockNumber);
+    }
   }
 
-  getL2TokenForL1TokenAtBlock(l1Token: string, chainId: number, blockNumber: number): string {
-    const l2Token = this.spokePoolTokens[l1Token]?.[chainId];
+  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address {
+    const l2Token = this.spokePoolTokens[l1Token.toEvmAddress()]?.[chainId];
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }
 
-  getTokenInfoForL1Token(l1Token: string): L1Token | undefined {
-    return this.l1TokensMock.find((token) => token.address === l1Token);
+  getTokenInfoForL1Token(l1Token: EvmAddress): TokenInfo | undefined {
+    return this.l1TokensMock.find((token) => token.address.eq(l1Token));
   }
 
   _update(eventNames: string[]): Promise<HubPoolUpdate> {

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -2,7 +2,7 @@ import assert from "assert";
 import { Contract } from "ethers";
 import { random } from "lodash";
 import winston from "winston";
-import { EMPTY_MESSAGE, ZERO_ADDRESS } from "../../constants";
+import { EMPTY_MESSAGE, ZERO_ADDRESS, ZERO_BYTES } from "../../constants";
 import {
   Log,
   Deposit,
@@ -25,9 +25,11 @@ import {
   BigNumber,
   bnZero,
   bnOne,
-  toAddress,
   toBytes32,
   spreadEventWithBlockNumber,
+  Address,
+  toAddressType,
+  isDefined,
 } from "../../utils";
 import { EVMSpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
@@ -63,8 +65,9 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     this.destinationTokenForChainOverride[chainId] = token;
   }
 
-  getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
-    return this.destinationTokenForChainOverride[deposit.originChainId] ?? super.getDestinationTokenForDeposit(deposit);
+  getDestinationTokenForDeposit(deposit: DepositWithBlock): Address {
+    const override = this.destinationTokenForChainOverride[deposit.originChainId];
+    return isDefined(override) ? toAddressType(override) : super.getDestinationTokenForDeposit(deposit);
   }
 
   setLatestBlockNumber(blockNumber: number): void {
@@ -85,6 +88,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       lastDepositId = _depositIds[i];
     }
   }
+
   _getDepositIdAtBlock(blockTag: number): Promise<BigNumber> {
     return Promise.resolve(this.depositIdAtBlock[blockTag]);
   }
@@ -129,28 +133,26 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     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 {
+  protected _deposit(
+    event: string,
+    deposit: Omit<Deposit, "messageHash"> & { message?: string } & Partial<SortableEvent>
+  ): Log {
     const { blockNumber, txnIndex } = deposit;
     let { depositId, destinationChainId, inputAmount, outputAmount } = deposit;
     depositId ??= this.numberOfDeposits;
     this.numberOfDeposits = depositId.add(bnOne);
 
     destinationChainId ??= random(1, 42161, false);
-    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);
+    const depositor = deposit.depositor?.toBytes32() ?? toBytes32(randomAddress());
+    const recipient = deposit.recipient?.toBytes32() ?? toBytes32(depositor);
+    const inputToken = deposit.inputToken?.toBytes32() ?? toBytes32(randomAddress());
+    const outputToken = deposit.outputToken?.toBytes32() ?? inputToken;
+    const exclusiveRelayer = deposit.exclusiveRelayer?.toBytes32() ?? toBytes32(ZERO_ADDRESS);
 
     inputAmount ??= toBNWei(random(1, 1000, false));
     outputAmount ??= inputAmount.mul(toBN("0.95"));
 
-    const message = deposit["message"] ?? "0x";
+    const message = deposit.message ?? "0x";
     const topics = [destinationChainId, depositId, depositor];
     const quoteTimestamp = deposit.quoteTimestamp ?? getCurrentTime();
     const args = {
@@ -180,17 +182,13 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     });
   }
 
-  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 {
+  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>
+    fill: Omit<Fill, "messageHash"> & { message?: string } & Partial<SortableEvent>
   ): Log {
     const { blockNumber, txnIndex } = fill;
     let { originChainId, depositId, inputAmount, outputAmount, fillDeadline } = fill;
@@ -200,20 +198,20 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     outputAmount ??= inputAmount;
     fillDeadline ??= getCurrentTime() + 60;
 
-    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 depositor = fill.depositor?.toBytes32() ?? toBytes32(randomAddress());
+    const recipient = fill.recipient?.toBytes32() ?? toBytes32(depositor);
+    const inputToken = fill.inputToken?.toBytes32() ?? toBytes32(randomAddress());
+    const outputToken = fill.outputToken?.toBytes32() ?? toBytes32(ZERO_ADDRESS);
+    const exclusiveRelayer = fill.exclusiveRelayer?.toBytes32() ?? toBytes32(ZERO_ADDRESS);
+    const relayer = fill.relayer?.toBytes32() ?? toBytes32(randomAddress());
 
-    const topics = [originChainId, depositId, relayer]; // @todo verify
+    const topics = [originChainId, depositId, relayer];
     const message = fill.message ?? EMPTY_MESSAGE;
     const updatedMessage = fill.relayExecutionInfo?.updatedMessage ?? message;
+    const updatedRecipient = fill.relayExecutionInfo?.updatedRecipient.toBytes32() ?? recipient;
 
     const relayExecutionInfo = {
-      updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
+      updatedRecipient,
       updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
       fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
     };
@@ -233,31 +231,20 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       depositor,
       recipient,
       relayExecutionInfo: {
-        updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
+        updatedRecipient,
         updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
         fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
       },
     };
 
-    const args =
-      event === "FilledRelay"
-        ? {
-            ..._args,
-            messageHash: getMessageHash(message),
-            relayExecutionInfo: {
-              ...relayExecutionInfo,
-              updatedMessageHash: getMessageHash(updatedMessage),
-            },
-          }
-        : {
-            // FilledV3Relay
-            ..._args,
-            message,
-            relayExecutionInfo: {
-              ...relayExecutionInfo,
-              updatedMessage,
-            },
-          };
+    const args = {
+      ..._args,
+      messageHash: getMessageHash(message),
+      relayExecutionInfo: {
+        ...relayExecutionInfo,
+        updatedMessageHash: getMessageHash(updatedMessage),
+      },
+    };
 
     return this.eventManager.generateEvent({
       event,
@@ -269,17 +256,12 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     });
   }
 
-  speedUpV3Deposit(speedUp: SpeedUp): Log {
-    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 depositor = speedUp.depositor.toBytes32();
     const topics = [speedUp.depositId, depositor];
     const args = { ...speedUp };
 
@@ -290,7 +272,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       args: {
         ...args,
         depositor,
-        updatedRecipient: addressModifier(speedUp.updatedRecipient),
+        updatedRecipient: speedUp.updatedRecipient.toBytes32(),
       },
     });
   }
@@ -308,24 +290,19 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     });
   }
 
-  requestV3SlowFill(request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>): Log {
-    return this._requestSlowFill("RequestedV3SlowFill", request);
-  }
-
-  requestSlowFill(request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>): Log {
+  requestSlowFill(request: Omit<SlowFillRequest, "destinationChainId"> & Partial<SortableEvent>): Log {
     return this._requestSlowFill("RequestedSlowFill", request);
   }
 
   protected _requestSlowFill(
     event: string,
-    request: Omit<SlowFillRequest, "messageHash"> & Partial<SortableEvent>
+    request: Omit<SlowFillRequest, "destinationChainId"> & 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());
+    const depositor = args.depositor.toBytes32() ?? toBytes32(randomAddress());
 
     return this.eventManager.generateEvent({
       event,
@@ -333,24 +310,26 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       topics: topics.map((topic) => topic.toString()),
       args: {
         ...args,
+        destinationChainId: this.chainId,
         depositor,
-        recipient: addressModifier(args.recipient ?? depositor),
-        inputToken: addressModifier(args.inputToken ?? randomAddress()),
-        outputToken: addressModifier(args.outputToken ?? ZERO_ADDRESS),
-        exclusiveRelayer: addressModifier(args.exclusiveRelayer ?? ZERO_ADDRESS),
+        recipient: args.recipient?.toBytes32() ?? depositor,
+        inputToken: args.inputToken?.toBytes32() ?? toBytes32(randomAddress()),
+        outputToken: args.outputToken?.toBytes32() ?? toBytes32(ZERO_ADDRESS),
+        exclusiveRelayer: args.exclusiveRelayer?.toBytes32() ?? toBytes32(ZERO_ADDRESS),
+        messageHash: args.messageHash ?? ZERO_BYTES,
       },
       blockNumber: request.blockNumber,
       transactionIndex: request.txnIndex,
     });
   }
 
-  // This is a simple wrapper around fillV3Relay().
+  // This is a simple wrapper around fillRelay().
   // rootBundleId and proof are discarded here - we have no interest in verifying that.
-  executeV3SlowRelayLeaf(leaf: Omit<SlowFillLeaf, "messageHash">): Log {
+  executeSlowRelayLeaf(leaf: Omit<SlowFillLeaf, "messageHash">): Log {
     const fill = {
       ...leaf.relayData,
       destinationChainId: this.chainId,
-      relayer: ZERO_ADDRESS,
+      relayer: toAddressType(ZERO_ADDRESS),
       repaymentChainId: 0,
       relayExecutionInfo: {
         updatedRecipient: leaf.relayData.recipient,
@@ -361,7 +340,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       },
     };
 
-    return this.fillV3Relay(fill);
+    return this.fillRelay(fill);
   }
 
   executeRelayerRefundLeaf(refund: RelayerRefundExecution & Partial<SortableEvent>): Log {