@across-protocol/sdk 4.2.16-alpha.6 → 4.2.16

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -1,5 +1,4 @@
 import winston from "winston";
-import { utils as ethersUtils } from "ethers";
 import {
   AnyObject,
   BigNumber,
@@ -7,7 +6,6 @@ import {
   DefaultLogLevels,
   DepositSearchResult,
   EventSearchConfig,
-  EvmAddress,
   MAX_BIG_INT,
   MakeOptional,
   assign,
@@ -15,14 +13,16 @@ import {
   isDefined,
   getMessageHash,
   isSlowFill,
+  isValidEvmAddress,
   isZeroAddress,
+  toEvmAddress,
   validateFillForDeposit,
+  chainIsEvm,
   chainIsProd,
   Address,
-  toAddressType,
 } from "../../utils";
 import { duplicateEvent, sortEventsAscendingInPlace } from "../../utils/EventUtils";
-import { CHAIN_IDs, ZERO_ADDRESS } from "../../constants";
+import { ZERO_ADDRESS } from "../../constants";
 import {
   BridgedToHubPoolWithBlock,
   ClaimedRelayerRefundWithBlock,
@@ -39,7 +39,6 @@ import {
   SortableEvent,
   SpeedUpWithBlock,
   TokensBridged,
-  RelayExecutionEventInfo,
 } from "../../interfaces";
 import { BaseAbstractClient, UpdateFailureReason } from "../BaseAbstractClient";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
@@ -209,8 +208,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @param relayer The relayer address.
    * @returns A list of fills.
    */
-  public getFillsForRelayer(relayer: Address): FillWithBlock[] {
-    return this.getFills().filter((fill) => fill.relayer.eq(relayer));
+  public getFillsForRelayer(relayer: string): FillWithBlock[] {
+    return this.getFills().filter((fill) => fill.relayer === relayer);
   }
 
   /**
@@ -274,8 +273,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.
-    // Additionally, speed ups can only be done on EVM networks.
-    const speedups = this.speedUps[depositor.toEvmAddress()]?.[depositId.toString()];
+    const speedups = this.speedUps[toEvmAddress(depositor)]?.[depositId.toString()];
+
     if (!isDefined(speedups) || speedups.length === 0) {
       return deposit;
     }
@@ -404,7 +403,11 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
           // is not a valid EVM chain. In the case where the repayment address is not a valid EVM address, the dataworker
           // might be able to overwrite the repayment address to the msg.sender on the fill txn, but to keep this
           // functioon synchronous, we can't make that decision now. So this function might log some false positives.
-          if (this.hubPoolClient && !isSlowFill(fill) && !fill.relayer.isValidOn(repaymentChainId)) {
+          if (
+            this.hubPoolClient &&
+            !isSlowFill(fill) &&
+            (!chainIsEvm(repaymentChainId) || !isValidEvmAddress(fill.relayer))
+          ) {
             groupedFills.unrepayableFills.push(fill);
           }
           // This fill is still valid and means that the deposit cannot be filled on-chain anymore, but it
@@ -426,7 +429,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.toNative(), x])),
+        unrepayableFills: Object.fromEntries(unrepayableFillsForDeposit.map((x) => [x.relayer, x])),
         notificationPath: "across-unrepayable-fills",
       });
     }
@@ -498,36 +501,14 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     const { events: queryResults, currentTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
-      for (const _event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
-        const event = _event as TokensBridged & {
-          l2TokenAddress: string;
-        };
-        this.tokensBridged.push({
-          ...event,
-          l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),
-        });
+      for (const event of queryResults[eventsToQuery.indexOf("TokensBridged")] as TokensBridged[]) {
+        this.tokensBridged.push(event);
       }
     }
 
     // Performs the indexing of a deposit-like spoke pool event.
     const queryDepositEvents = async (eventName: string) => {
-      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, this.chainId),
-          recipient: toAddressType(event.recipient, event.destinationChainId),
-          inputToken: toAddressType(event.inputToken, this.chainId),
-          outputToken: toAddressType(event.outputToken, event.destinationChainId),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer, event.destinationChainId),
-        } as DepositWithBlock;
-      });
+      const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as DepositWithBlock[];
       if (depositEvents.length > 0) {
         this.log(
           "debug",
@@ -584,31 +565,11 @@ 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)] ?? [])
-        .map((_event) => {
-          const event = _event as SpeedUpWithBlock & { depositor: string; updatedRecipient: string };
-
-          const invalid = [event.depositor, event.updatedRecipient].some(
-            (addr) => !EvmAddress.validate(ethersUtils.arrayify(addr))
-          );
-          if (invalid) {
-            return;
-          }
-
-          return {
-            ...event,
-            depositor: EvmAddress.from(event.depositor),
-            updatedRecipient: EvmAddress.from(event.updatedRecipient),
-          } as SpeedUpWithBlock;
-        })
-        .filter(isDefined);
+      const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SpeedUpWithBlock[];
 
       for (const event of speedUpEvents) {
-        const speedUp = {
-          ...event,
-          originChainId: this.chainId,
-        };
-        assign(this.speedUps, [speedUp.depositor.toEvmAddress(), speedUp.depositId.toString()], [speedUp]);
+        const speedUp = { ...event, originChainId: this.chainId };
+        assign(this.speedUps, [speedUp.depositor, 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.
@@ -632,23 +593,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of "requested slow fill"-like events.
     const queryRequestedSlowFillEvents = (eventName: string) => {
-      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, event.originChainId),
-          recipient: toAddressType(event.recipient, this.chainId),
-          inputToken: toAddressType(event.inputToken, event.originChainId),
-          outputToken: toAddressType(event.outputToken, this.chainId),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer, this.chainId),
-        } as SlowFillRequestWithBlock;
-      });
+      const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SlowFillRequestWithBlock[];
       for (const event of slowFillRequests) {
         const slowFillRequest = {
           ...event,
@@ -675,30 +620,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of filled relay-like events.
     const queryFilledRelayEvents = (eventName: string) => {
-      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, event.originChainId),
-          recipient: toAddressType(event.recipient, this.chainId),
-          inputToken: toAddressType(event.inputToken, event.originChainId),
-          outputToken: toAddressType(event.outputToken, this.chainId),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer, this.chainId),
-          relayer: toAddressType(event.relayer, this.chainId),
-          relayExecutionInfo: {
-            ...event.relayExecutionInfo,
-            updatedRecipient: toAddressType(event.relayExecutionInfo.updatedRecipient, this.chainId),
-          },
-        } as FillWithBlock;
-      });
+      const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as FillWithBlock[];
 
       if (fillEvents.length > 0) {
         this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
@@ -734,9 +656,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     });
 
     if (eventsToQuery.includes("EnabledDepositRoute")) {
-      const enableDepositsEvents = queryResults[
-        eventsToQuery.indexOf("EnabledDepositRoute")
-      ] as EnabledDepositRouteWithBlock[];
+      const enableDepositsEvents = (queryResults[eventsToQuery.indexOf("EnabledDepositRoute")] ??
+        []) as EnabledDepositRouteWithBlock[];
 
       for (const event of enableDepositsEvents) {
         assign(this.depositRoutes, [event.originToken, event.destinationChainId], event.enabled);
@@ -744,23 +665,18 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     }
 
     if (eventsToQuery.includes("RelayedRootBundle")) {
-      const relayedRootBundleEvents = queryResults[
-        eventsToQuery.indexOf("RelayedRootBundle")
-      ] as RootBundleRelayWithBlock[];
+      const relayedRootBundleEvents = (queryResults[eventsToQuery.indexOf("RelayedRootBundle")] ??
+        []) as RootBundleRelayWithBlock[];
       for (const event of relayedRootBundleEvents) {
         this.rootBundleRelays.push(event);
       }
     }
 
     if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
-      const refundEvents = queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")];
-      for (const _event of refundEvents) {
-        const event = _event as { l2TokenAddress: string; refundAddresses: string[] } & RelayerRefundExecutionWithBlock;
-        this.relayerRefundExecutions.push({
-          ...event,
-          l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),
-          refundAddresses: event.refundAddresses.map((addr) => toAddressType(addr, this.chainId)),
-        });
+      const refundEvents = (queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")] ??
+        []) as RelayerRefundExecutionWithBlock[];
+      for (const event of refundEvents) {
+        this.relayerRefundExecutions.push(event);
       }
     }
 
@@ -827,9 +743,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): Address {
+  protected getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
     if (!this.canResolveZeroAddressOutputToken(deposit)) {
-      return toAddressType(ZERO_ADDRESS, CHAIN_IDs.MAINNET);
+      return ZERO_ADDRESS;
     }
     // L1 token should be resolved if we get here:
     const l1Token = this.hubPoolClient!.getL1TokenForL2TokenAtBlock(
@@ -837,12 +753,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       deposit.originChainId,
       deposit.quoteBlockNumber
     )!;
-    const counterpartToken = this.hubPoolClient!.getL2TokenForL1TokenAtBlock(
-      l1Token,
-      deposit.destinationChainId,
-      deposit.quoteBlockNumber
+    return (
+      this.hubPoolClient!.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber) ??
+      ZERO_ADDRESS
     );
-    return counterpartToken ?? toAddressType(ZERO_ADDRESS, CHAIN_IDs.MAINNET);
   }
 
   /**

package/src/clients/SpokePoolClient/SpokePoolClientManager.ts

@@ -0,0 +1,36 @@
+import winston from "winston";
+import { SpokePoolClient } from "./SpokePoolClient";
+
+/**
+ * SpokePoolClientManager is a wrapper around spokePoolClients. We want to use wrapper almost always
+ * instead of direct access to spokePoolClients because chainId can be invalid and we want to return undefined.
+ */
+export class SpokePoolManager {
+  private spokePoolClients: { [chainId: number]: SpokePoolClient };
+
+  constructor(
+    readonly logger: winston.Logger,
+    spokePoolClients: { [chainId: number]: SpokePoolClient }
+  ) {
+    this.spokePoolClients = spokePoolClients;
+  }
+
+  /**
+   * Retrieves a SpokePoolClient for a given chainId.
+   * @param chainId - The chainId of the spokePoolClient to retrieve.
+   * @returns SpokePoolClient | undefined
+   * @note This method returns SpokePoolClient for given chainId. If its not found, it returns undefined.
+   */
+  getClient(chainId: number): SpokePoolClient | undefined {
+    return this.spokePoolClients[chainId];
+  }
+
+  /**
+   * Retrieves all SpokePoolClients
+   * @returns SpokePoolClient[]
+   * @note This method returns all SpokePoolClients.
+   */
+  getSpokePoolClients(): { [chainId: number]: SpokePoolClient } {
+    return this.spokePoolClients;
+  }
+}

package/src/clients/mocks/MockHubPoolClient.ts

@@ -1,17 +1,16 @@
 import winston from "winston";
 import { Contract } from "ethers";
-import { BigNumber, randomAddress, assign, bnZero, toAddressType, EvmAddress, Address, isDefined } from "../../utils";
-import { Log, PendingRootBundle, RealizedLpFee, L1TokenInfo } from "../../interfaces";
+import { BigNumber, randomAddress, assign, bnZero } from "../../utils";
+import { L1Token, Log, PendingRootBundle, RealizedLpFee } 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: EvmAddress.from(ZERO_ADDRESS),
+  proposer: "",
   unclaimedPoolRebalanceLeafCount: 0,
   challengePeriodEndTimestamp: 0,
   bundleEvaluationBlockNumbers: [],
@@ -23,9 +22,9 @@ export class MockHubPoolClient extends HubPoolClient {
   private realizedLpFeePct: BigNumber = bnZero;
   private realizedLpFeePctOverride = false;
 
-  private l1TokensMock: L1TokenInfo[] = []; // L1Tokens and their associated info.
+  private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
 
-  private spokePoolTokens: { [l1Token: string]: { [chainId: number]: Address } } = {};
+  private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
 
   private eventManager: EventManager;
 
@@ -70,7 +69,7 @@ export class MockHubPoolClient extends HubPoolClient {
       [chainId],
       [
         {
-          spokePool: toAddressType(contract, chainId),
+          spokePool: contract,
           blockNumber: blockNumber,
           transactionIndex: 0,
           logIndex: 0,
@@ -83,7 +82,7 @@ export class MockHubPoolClient extends HubPoolClient {
     this.latestHeightSearched = blockNumber;
   }
 
-  addL1Token(l1Token: L1TokenInfo) {
+  addL1Token(l1Token: L1Token) {
     this.l1TokensMock.push(l1Token);
   }
 
@@ -93,19 +92,19 @@ export class MockHubPoolClient extends HubPoolClient {
 
   setTokenMapping(l1Token: string, chainId: number, l2Token: string) {
     this.spokePoolTokens[l1Token] ??= {};
-    this.spokePoolTokens[l1Token][chainId] = toAddressType(l2Token, chainId);
+    this.spokePoolTokens[l1Token][chainId] = l2Token;
   }
 
-  l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
-    if (this.spokePoolTokens[l1Token.toEvmAddress()]?.[destinationChainId]) {
+  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
+    if (this.spokePoolTokens[l1Token]?.[destinationChainId]) {
       return true;
     } else {
       return super.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, hubBlockNumber);
     }
   }
-  l2TokenHasPoolRebalanceRoute(l2Token: Address, chainId: number, hubPoolBlock: number): boolean {
+  l2TokenHasPoolRebalanceRoute(l2Token: string, chainId: number, hubPoolBlock: number): boolean {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId]?.eq(l2Token)
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
     );
     if (!l1Token) {
       return super.l2TokenHasPoolRebalanceRoute(l2Token, chainId, hubPoolBlock);
@@ -116,24 +115,20 @@ export class MockHubPoolClient extends HubPoolClient {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }
 
-  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress {
+  getL1TokenForL2TokenAtBlock(l2Token: string, chainId: number, blockNumber: number): string {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId].eq(l2Token)
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
     );
-    if (isDefined(l1Token)) {
-      return EvmAddress.from(l1Token);
-    } else {
-      return super.getL1TokenForL2TokenAtBlock(l2Token, chainId, blockNumber);
-    }
+    return l1Token ?? super.getL1TokenForL2TokenAtBlock(l2Token, chainId, blockNumber);
   }
 
-  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address {
-    const l2Token = this.spokePoolTokens[l1Token.toEvmAddress()]?.[chainId];
+  getL2TokenForL1TokenAtBlock(l1Token: string, chainId: number, blockNumber: number): string {
+    const l2Token = this.spokePoolTokens[l1Token]?.[chainId];
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }
 
-  getTokenInfoForL1Token(l1Token: EvmAddress): L1TokenInfo | undefined {
-    return this.l1TokensMock.find((token) => token.address.eq(l1Token));
+  getTokenInfoForL1Token(l1Token: string): L1Token | undefined {
+    return this.l1TokensMock.find((token) => token.address === 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, ZERO_BYTES } from "../../constants";
+import { EMPTY_MESSAGE, ZERO_ADDRESS } from "../../constants";
 import {
   Log,
   Deposit,
@@ -27,9 +27,6 @@ import {
   bnOne,
   toBytes32,
   spreadEventWithBlockNumber,
-  Address,
-  toAddressType,
-  isDefined,
 } from "../../utils";
 import { EVMSpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
@@ -65,11 +62,8 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     this.destinationTokenForChainOverride[chainId] = token;
   }
 
-  getDestinationTokenForDeposit(deposit: DepositWithBlock): Address {
-    const override = this.destinationTokenForChainOverride[deposit.originChainId];
-    return isDefined(override)
-      ? toAddressType(override, deposit.destinationChainId)
-      : super.getDestinationTokenForDeposit(deposit);
+  getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
+    return this.destinationTokenForChainOverride[deposit.originChainId] ?? super.getDestinationTokenForDeposit(deposit);
   }
 
   setLatestBlockNumber(blockNumber: number): void {
@@ -135,26 +129,23 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     return this._deposit("FundsDeposited", deposit);
   }
 
-  protected _deposit(
-    event: string,
-    deposit: Omit<Deposit, "messageHash"> & { message?: string } & Partial<SortableEvent>
-  ): Log {
+  protected _deposit(event: string, deposit: Omit<Deposit, "messageHash"> & 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 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);
+    const depositor = toBytes32(deposit.depositor ?? randomAddress());
+    const recipient = toBytes32(deposit.recipient ?? depositor);
+    const inputToken = toBytes32(deposit.inputToken ?? randomAddress());
+    const outputToken = toBytes32(deposit.outputToken ?? inputToken);
+    const exclusiveRelayer = toBytes32(deposit.exclusiveRelayer ?? 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 = {
@@ -200,20 +191,19 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     outputAmount ??= inputAmount;
     fillDeadline ??= getCurrentTime() + 60;
 
-    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 depositor = toBytes32(fill.depositor ?? randomAddress());
+    const recipient = toBytes32(fill.recipient ?? depositor);
+    const inputToken = toBytes32(fill.inputToken ?? randomAddress());
+    const outputToken = toBytes32(fill.outputToken ?? ZERO_ADDRESS);
+    const exclusiveRelayer = toBytes32(fill.exclusiveRelayer ?? ZERO_ADDRESS);
+    const relayer = toBytes32(fill.relayer ?? randomAddress());
 
     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,
+      updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
       updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
       fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
     };
@@ -233,7 +223,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       depositor,
       recipient,
       relayExecutionInfo: {
-        updatedRecipient,
+        updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
         updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
         fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
       },
@@ -263,7 +253,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
   }
 
   protected _speedUpDeposit(event: string, speedUp: SpeedUp): Log {
-    const depositor = speedUp.depositor.toBytes32();
+    const depositor = toBytes32(speedUp.depositor);
     const topics = [speedUp.depositId, depositor];
     const args = { ...speedUp };
 
@@ -274,7 +264,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       args: {
         ...args,
         depositor,
-        updatedRecipient: speedUp.updatedRecipient.toBytes32(),
+        updatedRecipient: toBytes32(speedUp.updatedRecipient),
       },
     });
   }
@@ -304,7 +294,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     const topics = [originChainId, depositId];
     const args = { ...request };
 
-    const depositor = args.depositor.toBytes32() ?? toBytes32(randomAddress());
+    const depositor = toBytes32(args.depositor ?? randomAddress());
 
     return this.eventManager.generateEvent({
       event,
@@ -314,11 +304,10 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
         ...args,
         destinationChainId: this.chainId,
         depositor,
-        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,
+        recipient: toBytes32(args.recipient ?? depositor),
+        inputToken: toBytes32(args.inputToken ?? randomAddress()),
+        outputToken: toBytes32(args.outputToken ?? ZERO_ADDRESS),
+        exclusiveRelayer: toBytes32(args.exclusiveRelayer ?? ZERO_ADDRESS),
       },
       blockNumber: request.blockNumber,
       transactionIndex: request.txnIndex,
@@ -328,11 +317,10 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
   // This is a simple wrapper around fillRelay().
   // rootBundleId and proof are discarded here - we have no interest in verifying that.
   executeSlowRelayLeaf(leaf: Omit<SlowFillLeaf, "messageHash">): Log {
-    const destinationChainId = this.chainId;
     const fill = {
       ...leaf.relayData,
-      destinationChainId,
-      relayer: toAddressType(ZERO_ADDRESS, destinationChainId),
+      destinationChainId: this.chainId,
+      relayer: ZERO_ADDRESS,
       repaymentChainId: 0,
       relayExecutionInfo: {
         updatedRecipient: leaf.relayData.recipient,

package/src/clients/mocks/MockSvmCpiEventsClient.ts

@@ -1,5 +1,4 @@
 import assert from "assert";
-import { utils as ethersUtils } from "ethers";
 import { createHash } from "crypto";
 import { hexlify, arrayify, hexZeroPad } from "ethers/lib/utils";
 import { random } from "lodash";
@@ -18,11 +17,9 @@ import {
   SVMProvider,
   getRandomSvmAddress,
 } from "../../arch/svm";
-import { bnZero, bnOne, bs58, getCurrentTime, randomAddress, EvmAddress, SvmAddress } from "../../utils";
+import { bnZero, bnOne, bs58, getCurrentTime, randomAddress, EvmAddress } from "../../utils";
 import { FillType } from "../../interfaces";
 
-const randomBytes = (n: number) => ethersUtils.hexlify(ethersUtils.randomBytes(n));
-
 export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
   private events: Record<EventName, EventWithData[]> = {} as Record<EventName, EventWithData[]>;
   private slotHeight: bigint = BigInt(0);
@@ -78,9 +75,9 @@ export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
 
     destinationChainId ??= BigInt(random(1, 42161, false));
     const depositor = deposit.depositor ?? getRandomSvmAddress();
-    const recipient = deposit.recipient ?? SvmAddress.from(randomBytes(32), "base16").toBase58();
+    const recipient = deposit.recipient ?? EvmAddress.from(randomAddress()).toBase58();
     const inputToken = deposit.inputToken ?? getRandomSvmAddress();
-    const outputToken = deposit.outputToken ?? SvmAddress.from(randomBytes(32), "base16").toBase58();
+    const outputToken = deposit.outputToken ?? EvmAddress.from(randomAddress()).toBase58();
     inputAmount ??= BigInt(random(1, 1000, false));
     outputAmount ??= (inputAmount * BigInt(95)) / BigInt(100);
     const message = deposit.message ?? new Uint8Array(32);
@@ -161,9 +158,9 @@ export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
     let { depositId, originChainId } = slowFillRequest;
     depositId ??= Uint8Array.from([random(1, 100_000, false)]);
     originChainId ??= BigInt(random(1, 42161, false));
-    const depositor = slowFillRequest.depositor ?? SvmAddress.from(randomBytes(32)).toBase58();
+    const depositor = slowFillRequest.depositor ?? EvmAddress.from(randomAddress()).toBase58();
     const recipient = slowFillRequest.recipient ?? getRandomSvmAddress();
-    const inputToken = slowFillRequest.inputToken ?? SvmAddress.from(randomBytes(32)).toBase58();
+    const inputToken = slowFillRequest.inputToken ?? EvmAddress.from(randomAddress()).toBase58();
     const outputToken = slowFillRequest.outputToken ?? getRandomSvmAddress();
 
     const args = {

package/src/clients/mocks/MockSvmSpokePoolClient.ts

@@ -2,15 +2,7 @@ import winston from "winston";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { Address } from "@solana/kit";
 import { DepositWithBlock, RelayerRefundExecution, SortableEvent, SlowFillLeaf, Log } from "../../interfaces";
-import {
-  getCurrentTime,
-  bnZero,
-  MakeOptional,
-  EventSearchConfig,
-  Address as SDKAddress,
-  toAddressType,
-  isDefined,
-} from "../../utils";
+import { getCurrentTime, bnZero, MakeOptional, EventSearchConfig } from "../../utils";
 import { SpokePoolUpdate, SVMSpokePoolClient } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
 import { EventOverrides } from "./MockEvents";
@@ -54,9 +46,8 @@ export class MockSvmSpokePoolClient extends SVMSpokePoolClient {
     this.destinationTokenForChainOverride[chainId] = token;
   }
 
-  getDestinationTokenForDeposit(deposit: DepositWithBlock): SDKAddress {
-    const override = this.destinationTokenForChainOverride[deposit.originChainId];
-    return isDefined(override) ? toAddressType(override, this.chainId) : super.getDestinationTokenForDeposit(deposit);
+  getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
+    return this.destinationTokenForChainOverride[deposit.originChainId] ?? super.getDestinationTokenForDeposit(deposit);
   }
 
   setLatestBlockNumber(blockNumber: number): void {