@across-protocol/sdk 4.2.14-alpha.1 → 4.2.14

package/src/arch/evm/SpokeUtils.ts

@@ -1,9 +1,8 @@
 import assert from "assert";
 import { BytesLike, Contract, PopulatedTransaction, providers } from "ethers";
 import { CHAIN_IDs } from "../../constants";
-import { Deposit, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
 import {
-  EvmAddress,
   bnUint32Max,
   BigNumber,
   toBN,
@@ -14,11 +13,11 @@ import {
   isDefined,
   isUnsafeDepositId,
   isZeroAddress,
+  getDepositRelayData,
   getNetworkName,
   paginatedEventQuery,
   spreadEventWithBlockNumber,
-  Address,
-  toAddressType,
+  toBytes32,
 } from "../../utils";
 
 type BlockTag = providers.BlockTag;
@@ -31,31 +30,11 @@ type BlockTag = providers.BlockTag;
  */
 export function populateV3Relay(
   spokePool: Contract,
-  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain"> & {
-    recipient: EvmAddress;
-    exclusiveRelayer: EvmAddress;
-  },
-  relayer: Address,
+  deposit: Omit<Deposit, "messageHash">,
+  relayer: string,
   repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {
-  assert(
-    relayer.isValidOn(repaymentChainId),
-    `Invalid repayment address for chain ${repaymentChainId}: ${relayer.toAddress()}.`
-  );
-  const relayData = {
-    depositor: deposit.depositor.toBytes32(),
-    recipient: deposit.recipient.toBytes32(),
-    inputToken: deposit.inputToken.toBytes32(),
-    outputToken: deposit.outputToken.toBytes32(),
-    inputAmount: deposit.inputAmount,
-    outputAmount: deposit.outputAmount,
-    originChainId: deposit.originChainId,
-    depositId: deposit.depositId,
-    fillDeadline: deposit.fillDeadline,
-    exclusivityDeadline: deposit.exclusivityDeadline,
-    message: deposit.message,
-    exclusiveRelayer: deposit.exclusiveRelayer.toBytes32(),
-  };
+  const relayData = getDepositRelayData(deposit);
 
   if (isDefined(deposit.speedUpSignature)) {
     assert(isDefined(deposit.updatedRecipient) && !isZeroAddress(deposit.updatedRecipient));
@@ -64,18 +43,16 @@ export function populateV3Relay(
     return spokePool.populateTransaction.fillRelayWithUpdatedDeposit(
       relayData,
       repaymentChainId,
-      relayer.toBytes32(),
+      toBytes32(relayer),
       deposit.updatedOutputAmount,
-      deposit.updatedRecipient.toBytes32(),
+      toBytes32(deposit.updatedRecipient),
       deposit.updatedMessage,
       deposit.speedUpSignature,
-      { from: relayer.toAddress() }
+      { from: relayer }
     );
   }
 
-  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, relayer.toBytes32(), {
-    from: relayer.toAddress(),
-  });
+  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, toBytes32(relayer), { from: relayer });
 }
 
 /**
@@ -338,27 +315,8 @@ export async function findFillEvent(
   const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
     ? (await spokePool.provider.getNetwork()).chainId
     : Number(await spokePool.chainId());
-  const fillEvent = spreadEventWithBlockNumber(event) as FillWithBlock & {
-    depositor: string;
-    recipient: string;
-    inputToken: string;
-    outputToken: string;
-    exclusiveRelayer: string;
-    relayer: string;
-    relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
-  };
   const fill = {
-    ...fillEvent,
-    inputToken: toAddressType(fillEvent.inputToken, relayData.originChainId),
-    outputToken: toAddressType(fillEvent.outputToken, destinationChainId),
-    depositor: toAddressType(fillEvent.depositor, relayData.originChainId),
-    recipient: toAddressType(fillEvent.recipient, destinationChainId),
-    exclusiveRelayer: toAddressType(fillEvent.exclusiveRelayer, destinationChainId),
-    relayer: toAddressType(fillEvent.relayer, destinationChainId),
-    relayExecutionInfo: {
-      ...fillEvent.relayExecutionInfo,
-      updatedRecipient: toAddressType(fillEvent.relayExecutionInfo.updatedRecipient, destinationChainId),
-    },
+    ...spreadEventWithBlockNumber(event),
     destinationChainId,
     messageHash: getMessageHash(event.args.message),
   } as FillWithBlock;

package/src/arch/svm/SpokeUtils.ts

@@ -27,14 +27,7 @@ import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
 
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
-import {
-  Deposit,
-  DepositWithBlock,
-  FillStatus,
-  FillWithBlock,
-  RelayData,
-  RelayExecutionEventInfo,
-} from "../../interfaces";
+import { Deposit, DepositWithBlock, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
 import { BigNumber, SvmAddress, chainIsSvm, chunk, isUnsafeDepositId, keccak256, toAddressType } from "../../utils";
 import {
   SvmCpiEventsClient,
@@ -143,19 +136,13 @@ export async function findDeposit(
     return undefined;
   }
 
-  const unwrappedDepositEvent = unwrapEventData(depositEvent.data) as Record<string, unknown>;
   // Return the deposit event with block info
   return {
     txnRef: depositEvent.signature.toString(),
     blockNumber: Number(depositEvent.slot),
     txnIndex: 0,
     logIndex: 0,
-    ...unwrappedDepositEvent,
-    depositor: toAddressType(unwrappedDepositEvent.depositor as string),
-    recipient: toAddressType(unwrappedDepositEvent.recipient as string),
-    inputToken: toAddressType(unwrappedDepositEvent.inputToken as string),
-    outputToken: toAddressType(unwrappedDepositEvent.outputToken as string),
-    exclusiveRelayer: toAddressType(unwrappedDepositEvent.exclusiveRelayer as string),
+    ...(unwrapEventData(depositEvent.data) as Record<string, unknown>),
   } as DepositWithBlock;
 }
 
@@ -331,34 +318,14 @@ export async function findFillEvent(
 
   if (fillEvents.length > 0) {
     const rawFillEvent = fillEvents[0];
-    const eventData = unwrapEventData(rawFillEvent.data) as FillWithBlock & {
-      depositor: string;
-      recipient: string;
-      inputToken: string;
-      outputToken: string;
-      exclusiveRelayer: string;
-      relayer: string;
-      relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
-    };
-    const originChainId = eventData.originChainId;
     const parsedFillEvent = {
-      ...eventData,
       transactionHash: rawFillEvent.signature,
       blockNumber: Number(rawFillEvent.slot),
       transactionIndex: 0,
       logIndex: 0,
       destinationChainId,
-      inputToken: toAddressType(eventData.inputToken, originChainId),
-      outputToken: toAddressType(eventData.outputToken, destinationChainId),
-      relayer: toAddressType(eventData.relayer, destinationChainId),
-      exclusiveRelayer: toAddressType(eventData.exclusiveRelayer, destinationChainId),
-      depositor: toAddressType(eventData.depositor, originChainId),
-      recipient: toAddressType(eventData.recipient, destinationChainId),
-      relayExecutionInfo: {
-        ...eventData.relayExecutionInfo,
-        updatedRecipient: eventData.relayExecutionInfo.updatedRecipient,
-      },
-    } as FillWithBlock;
+      ...(unwrapEventData(rawFillEvent.data) as Record<string, unknown>),
+    } as unknown as FillWithBlock;
     return parsedFillEvent;
   }
 
@@ -390,7 +357,7 @@ export async function fillRelayInstruction(
     deposit.exclusiveRelayer,
     deposit.inputToken,
     deposit.outputToken,
-  ].map((addr) => addr.forceSvmAddress());
+  ].map((addr) => toAddressType(addr).forceSvmAddress());
 
   const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
   const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
@@ -401,7 +368,7 @@ export async function fillRelayInstruction(
   const [statePda, fillStatusPda, eventAuthority] = await Promise.all([
     getStatePda(spokePool.toV2Address()),
     getFillStatusPda(spokePool.toV2Address(), deposit, deposit.destinationChainId),
-    getEventAuthority(spokePool.toV2Address()),
+    getEventAuthority(),
   ]);
   const depositIdBuffer = new Uint8Array(32);
   const shortenedBuffer = new Uint8Array(Buffer.from(deposit.depositId.toHexString().slice(2), "hex"));
@@ -624,11 +591,11 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   assert(relayData.message.startsWith("0x"), "Message must be a hex string");
 
   const contentToHash = Buffer.concat([
-    Uint8Array.from(addressEncoder.encode(address(relayData.depositor.toBase58()))),
-    Uint8Array.from(addressEncoder.encode(address(relayData.recipient.toBase58()))),
-    Uint8Array.from(addressEncoder.encode(address(relayData.exclusiveRelayer.toBase58()))),
-    Uint8Array.from(addressEncoder.encode(address(relayData.inputToken.toBase58()))),
-    Uint8Array.from(addressEncoder.encode(address(relayData.outputToken.toBase58()))),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.depositor, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.recipient, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.exclusiveRelayer, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.inputToken, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.outputToken, "base16").toV2Address())),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.inputAmount.toString()))),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.outputAmount.toString()))),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.originChainId.toString()))),

package/src/arch/svm/utils.ts

@@ -273,13 +273,13 @@ export async function getInstructionParamsPda(programId: Address, signer: Addres
  * Returns the PDA for the Event Authority.
  * @returns The PDA for the Event Authority.
  */
-export async function getEventAuthority(programId: Address): Promise<Address> {
+export const getEventAuthority = async () => {
   const [eventAuthority] = await getProgramDerivedAddress({
-    programAddress: programId,
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
     seeds: ["__event_authority"],
   });
   return eventAuthority;
-}
+};
 
 /**
  * Returns a random SVM address.

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -5,7 +5,6 @@ import winston from "winston";
 import { isError } from "../../typeguards";
 import {
   EventSearchConfig,
-  EvmAddress,
   MakeOptional,
   isArrayOf,
   isDefined,
@@ -108,7 +107,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
   }
 
   getRateModelForBlockNumber(
-    l1Token: EvmAddress,
+    l1Token: string,
     originChainId: number | string,
     destinationChainId: number | string,
     blockNumber: number | undefined = undefined
@@ -122,9 +121,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
 
     const defaultRateModelUpdate = sortEventsDescending(this.cumulativeRateModelUpdates).find(
       (config) =>
-        config.blockNumber <= (blockNumber ?? 0) &&
-        config.l1Token === l1Token.toEvmAddress() &&
-        config.rateModel !== undefined
+        config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token && config.rateModel !== undefined
     );
     if (!defaultRateModelUpdate) {
       throw new Error(`Could not find TokenConfig update for ${l1Token} at block ${blockNumber}`);
@@ -133,12 +130,12 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
   }
 
   getRouteRateModelForBlockNumber(
-    l1Token: EvmAddress,
+    l1Token: string,
     route: string,
     blockNumber: number | undefined = undefined
   ): RateModel | undefined {
     const config = (sortEventsDescending(this.cumulativeRouteRateModelUpdates) as RouteRateModelUpdate[]).find(
-      (config) => config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token.toEvmAddress()
+      (config) => config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token
     );
     if (config?.routeRateModel[route] === undefined) {
       return undefined;

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -40,9 +40,9 @@ import {
   isZeroValueDeposit,
   isZeroValueFillOrSlowFillRequest,
   chainIsEvm,
+  isValidEvmAddress,
   duplicateEvent,
   invalidOutputToken,
-  Address,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -67,20 +67,22 @@ type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 // V3 dictionary helper functions
 function updateExpiredDepositsV3(dict: ExpiredDepositsToRefundV3, deposit: V3DepositWithBlock): void {
   // A deposit refund for a deposit is invalid if the depositor has a bytes32 address input for an EVM chain. It is valid otherwise.
-  if (chainIsEvm(deposit.originChainId) && !deposit.depositor.isValidEvmAddress()) {
+  if (chainIsEvm(deposit.originChainId) && !isValidEvmAddress(deposit.depositor)) {
     return;
   }
   const { originChainId, inputToken } = deposit;
-  dict[originChainId] ??= {};
-  dict[originChainId][inputToken.toBytes32()] ??= [];
-  dict[originChainId][inputToken.toBytes32()].push(deposit);
+  if (!dict?.[originChainId]?.[inputToken]) {
+    assign(dict, [originChainId, inputToken], []);
+  }
+  dict[originChainId][inputToken].push(deposit);
 }
 
 function updateBundleDepositsV3(dict: BundleDepositsV3, deposit: V3DepositWithBlock): void {
   const { originChainId, inputToken } = deposit;
-  dict[originChainId] ??= {};
-  dict[originChainId][inputToken.toBytes32()] ??= [];
-  dict[originChainId][inputToken.toBytes32()].push(deposit);
+  if (!dict?.[originChainId]?.[inputToken]) {
+    assign(dict, [originChainId, inputToken], []);
+  }
+  dict[originChainId][inputToken].push(deposit);
 }
 
 function updateBundleFillsV3(
@@ -88,28 +90,29 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: Address,
-  repaymentAddress: Address
+  repaymentToken: string,
+  repaymentAddress: string
 ): void {
   // We shouldn't pass any unrepayable fills into this function, so we perform an extra safety check.
-  if (chainIsEvm(repaymentChainId) && !fill.relayer.isValidEvmAddress()) {
+  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
     return;
   }
-  dict[repaymentChainId] ??= {};
-  dict[repaymentChainId][repaymentToken.toBytes32()] ??= {
-    fills: [],
-    totalRefundAmount: bnZero,
-    realizedLpFees: bnZero,
-    refunds: {},
-  };
+  if (!dict?.[repaymentChainId]?.[repaymentToken]) {
+    assign(dict, [repaymentChainId, repaymentToken], {
+      fills: [],
+      totalRefundAmount: bnZero,
+      realizedLpFees: bnZero,
+      refunds: {},
+    });
+  }
 
   const bundleFill: BundleFillV3 = { ...fill, lpFeePct, relayer: repaymentAddress };
 
   // Add all fills, slow and fast, to dictionary.
-  assign(dict, [repaymentChainId, repaymentToken.toBytes32(), "fills"], [bundleFill]);
+  assign(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
 
   // All fills update the bundle LP fees.
-  const refundObj = dict[repaymentChainId][repaymentToken.toBytes32()];
+  const refundObj = dict[repaymentChainId][repaymentToken];
   const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
@@ -123,11 +126,10 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[bundleFill.relayer.toBytes32()]) {
-      refundObj.refunds[bundleFill.relayer.toBytes32()] =
-        refundObj.refunds[bundleFill.relayer.toBytes32()].add(refundAmount);
+    if (refundObj.refunds[bundleFill.relayer]) {
+      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
     } else {
-      refundObj.refunds[bundleFill.relayer.toBytes32()] = refundAmount;
+      refundObj.refunds[bundleFill.relayer] = refundAmount;
     }
   }
 }
@@ -137,19 +139,21 @@ function updateBundleExcessSlowFills(
   deposit: V3DepositWithBlock & { lpFeePct: BigNumber }
 ): void {
   const { destinationChainId, outputToken } = deposit;
-  dict[destinationChainId] ??= {};
-  dict[destinationChainId][outputToken.toBytes32()] ??= [];
-  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
+  if (!dict?.[destinationChainId]?.[outputToken]) {
+    assign(dict, [destinationChainId, outputToken], []);
+  }
+  dict[destinationChainId][outputToken].push(deposit);
 }
 
 function updateBundleSlowFills(dict: BundleSlowFills, deposit: V3DepositWithBlock & { lpFeePct: BigNumber }): void {
-  if (chainIsEvm(deposit.destinationChainId) && !deposit.recipient.isValidEvmAddress()) {
+  if (chainIsEvm(deposit.destinationChainId) && !isValidEvmAddress(deposit.recipient)) {
     return;
   }
   const { destinationChainId, outputToken } = deposit;
-  dict[destinationChainId] ??= {};
-  dict[destinationChainId][outputToken.toBytes32()] ??= [];
-  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
+  if (!dict?.[destinationChainId]?.[outputToken]) {
+    assign(dict, [destinationChainId, outputToken], []);
+  }
+  dict[destinationChainId][outputToken].push(deposit);
 }
 
 // @notice Shared client for computing data needed to construct or validate a bundle.
@@ -485,23 +489,21 @@ export class BundleDataClient {
         // worst from the relayer's perspective.
         const { relayer, inputAmount: refundAmount } = fill;
         refundsForChain[chainToSendRefundTo] ??= {};
-        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()] ??= {};
-        const existingRefundAmount =
-          refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] ?? bnZero;
-        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] =
-          existingRefundAmount.add(refundAmount);
+        refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
+        const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
+        refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
       });
     }
     return refundsForChain;
   }
 
-  getUpcomingDepositAmount(chainId: number, l2Token: Address, latestBlockToSearch: number): BigNumber {
+  getUpcomingDepositAmount(chainId: number, l2Token: string, latestBlockToSearch: number): BigNumber {
     if (this.spokePoolClients[chainId] === undefined) {
       return toBN(0);
     }
     return this.spokePoolClients[chainId]
       .getDeposits()
-      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken.eq(l2Token))
+      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken === l2Token)
       .reduce((acc, deposit) => {
         return acc.add(deposit.inputAmount);
       }, toBN(0));
@@ -624,18 +626,18 @@ export class BundleDataClient {
     const executedRefunds: { [tokenAddress: string]: { [relayer: string]: BigNumber } } = {};
     for (const refundLeaf of executedRefundLeaves) {
       const tokenAddress = refundLeaf.l2TokenAddress;
-      if (executedRefunds[tokenAddress.toBytes32()] === undefined) {
-        executedRefunds[tokenAddress.toBytes32()] = {};
+      if (executedRefunds[tokenAddress] === undefined) {
+        executedRefunds[tokenAddress] = {};
       }
-      const executedTokenRefunds = executedRefunds[tokenAddress.toBytes32()];
+      const executedTokenRefunds = executedRefunds[tokenAddress];
 
       for (let i = 0; i < refundLeaf.refundAddresses.length; i++) {
         const relayer = refundLeaf.refundAddresses[i];
         const refundAmount = refundLeaf.refundAmounts[i];
-        if (executedTokenRefunds[relayer.toBytes32()] === undefined) {
-          executedTokenRefunds[relayer.toBytes32()] = bnZero;
+        if (executedTokenRefunds[relayer] === undefined) {
+          executedTokenRefunds[relayer] = bnZero;
         }
-        executedTokenRefunds[relayer.toBytes32()] = executedTokenRefunds[relayer.toBytes32()].add(refundAmount);
+        executedTokenRefunds[relayer] = executedTokenRefunds[relayer].add(refundAmount);
       }
     }
     return executedRefunds;
@@ -676,15 +678,15 @@ export class BundleDataClient {
     return allRefunds;
   }
 
-  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: Address, chainId: number, token: Address): BigNumber {
-    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token.toBytes32()]) {
+  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: string, chainId: number, token: string): BigNumber {
+    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token]) {
       return BigNumber.from(0);
     }
-    const allRefunds = bundleRefunds[chainId][token.toBytes32()];
-    return allRefunds && allRefunds[relayer.toBytes32()] ? allRefunds[relayer.toBytes32()] : BigNumber.from(0);
+    const allRefunds = bundleRefunds[chainId][token];
+    return allRefunds && allRefunds[relayer] ? allRefunds[relayer] : BigNumber.from(0);
   }
 
-  getTotalRefund(refunds: CombinedRefunds[], relayer: Address, chainId: number, refundToken: Address): BigNumber {
+  getTotalRefund(refunds: CombinedRefunds[], relayer: string, chainId: number, refundToken: string): BigNumber {
     return refunds.reduce((totalRefund, refunds) => {
       return totalRefund.add(this.getRefundsFor(refunds, relayer, chainId, refundToken));
     }, bnZero);
@@ -897,11 +899,7 @@ export class BundleDataClient {
             "Not using correct bundle deposit hash key"
           );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
-            if (
-              bundleDepositsV3?.[originChainId]?.[deposit.inputToken.toBytes32()]?.find((d) =>
-                duplicateEvent(deposit, d)
-              )
-            ) {
+            if (bundleDepositsV3?.[originChainId]?.[deposit.inputToken]?.find((d) => duplicateEvent(deposit, d))) {
               this.logger.debug({
                 at: "BundleDataClient#loadData",
                 message: "Duplicate deposit detected",

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

@@ -17,7 +17,6 @@ import {
   fixedPointAdjustment,
   count2DDictionaryValues,
   count3DDictionaryValues,
-  toAddressType,
 } from "../../../utils";
 import {
   addLastRunningBalance,
@@ -66,10 +65,10 @@ export function getRefundsFromBundle(
     Object.entries(depositsForChain).forEach(([l2TokenAddress, deposits]) => {
       deposits.forEach((deposit) => {
         if (combinedRefunds[originChainId][l2TokenAddress] === undefined) {
-          combinedRefunds[originChainId][l2TokenAddress] = { [deposit.depositor.toBytes32()]: deposit.inputAmount };
+          combinedRefunds[originChainId][l2TokenAddress] = { [deposit.depositor]: deposit.inputAmount };
         } else {
-          const existingRefundAmount = combinedRefunds[originChainId][l2TokenAddress][deposit.depositor.toBytes32()];
-          combinedRefunds[originChainId][l2TokenAddress][deposit.depositor.toBytes32()] = deposit.inputAmount.add(
+          const existingRefundAmount = combinedRefunds[originChainId][l2TokenAddress][deposit.depositor];
+          combinedRefunds[originChainId][l2TokenAddress][deposit.depositor] = deposit.inputAmount.add(
             existingRefundAmount ?? bnZero
           );
         }
@@ -154,23 +153,19 @@ export function _buildPoolRebalanceRoot(
         // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
         // there are no relevant L1 running balances.
         if (
-          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
-            toAddressType(l2TokenAddress, repaymentChainId),
-            repaymentChainId,
-            mainnetBundleEndBlock
-          )
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(l2TokenAddress, repaymentChainId, mainnetBundleEndBlock)
         ) {
           chainWithRefundsOnly.add(repaymentChainId);
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(l2TokenAddress, repaymentChainId),
+          l2TokenAddress,
           repaymentChainId,
           mainnetBundleEndBlock
         );
 
-        updateRunningBalance(runningBalances, repaymentChainId, l1TokenCounterpart.toEvmAddress(), totalRefundAmount);
-        updateRunningBalance(realizedLpFees, repaymentChainId, l1TokenCounterpart.toEvmAddress(), totalRealizedLpFee);
+        updateRunningBalance(runningBalances, repaymentChainId, l1TokenCounterpart, totalRefundAmount);
+        updateRunningBalance(realizedLpFees, repaymentChainId, l1TokenCounterpart, totalRealizedLpFee);
       }
     );
   });
@@ -187,17 +182,12 @@ export function _buildPoolRebalanceRoot(
     Object.entries(depositsForChain).forEach(([outputToken, deposits]) => {
       deposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(outputToken, destinationChainId),
+          outputToken,
           destinationChainId,
           mainnetBundleEndBlock
         );
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
-        updateRunningBalance(
-          runningBalances,
-          destinationChainId,
-          l1TokenCounterpart.toEvmAddress(),
-          deposit.inputAmount.sub(lpFee)
-        );
+        updateRunningBalance(runningBalances, destinationChainId, l1TokenCounterpart, deposit.inputAmount.sub(lpFee));
         // Slow fill LP fees are accounted for when the slow fill executes and a V3FilledRelay is emitted. i.e. when
         // the slow fill execution is included in bundleFillsV3.
       });
@@ -216,17 +206,12 @@ export function _buildPoolRebalanceRoot(
     Object.entries(slowFilledDepositsForChain).forEach(([outputToken, slowFilledDeposits]) => {
       slowFilledDeposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(outputToken, destinationChainId),
+          outputToken,
           destinationChainId,
           mainnetBundleEndBlock
         );
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
-        updateRunningBalance(
-          runningBalances,
-          destinationChainId,
-          l1TokenCounterpart.toEvmAddress(),
-          lpFee.sub(deposit.inputAmount)
-        );
+        updateRunningBalance(runningBalances, destinationChainId, l1TokenCounterpart, lpFee.sub(deposit.inputAmount));
         // Slow fills don't add to lpFees, only when the slow fill is executed and a V3FilledRelay is emitted, so
         // we don't need to subtract it here. Moreover, the HubPoole expects bundleLpFees to be > 0.
       });
@@ -286,11 +271,11 @@ export function _buildPoolRebalanceRoot(
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(inputToken, originChainId),
+          inputToken,
           originChainId,
           mainnetBundleEndBlock
         );
-        updateRunningBalance(runningBalances, originChainId, l1TokenCounterpart.toEvmAddress(), deposit.inputAmount);
+        updateRunningBalance(runningBalances, originChainId, l1TokenCounterpart, deposit.inputAmount);
       });
     });
   });

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

@@ -2,7 +2,7 @@ import _ from "lodash";
 import assert from "assert";
 import { providers } from "ethers";
 import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
-import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm, Address, toAddressType } from "../../../utils";
+import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 import { SVMProvider } from "../../../arch/svm";
 
@@ -25,7 +25,7 @@ export function getRefundInformationFromFill(
   bundleEndBlockForMainnet: number
 ): {
   chainToSendRefundTo: number;
-  repaymentToken: Address;
+  repaymentToken: string;
 } {
   const chainToSendRefundTo = _getRepaymentChainId(relayData, hubPoolClient, bundleEndBlockForMainnet);
   if (chainToSendRefundTo === relayData.originChainId) {
@@ -49,7 +49,6 @@ export function getRefundInformationFromFill(
     chainToSendRefundTo,
     bundleEndBlockForMainnet
   );
-
   return {
     chainToSendRefundTo,
     repaymentToken,
@@ -126,8 +125,7 @@ export async function verifyFillRepayment(
           return undefined;
         }
       }
-      fill.relayer = toAddressType(destinationRelayer);
-      assert(fill.relayer.isValidEvmAddress(), `Cannot re-assign fill to msg.sender: ${destinationRelayer}`);
+      fill.relayer = destinationRelayer;
     } else {
       return undefined;
     }
@@ -202,5 +200,5 @@ function _repaymentAddressNeedsToBeOverwritten(fill: Fill): boolean {
   // - i.e. If chainIsSvm && !isValidSvmAddress(fill.relayer) then return false
   //        If chainIsEvm && !isValidEvmAddress(fill.relayer) then return false
   //        If chainIsEvm && isValidEvmAddress(fill.relayer) then return true
-  return chainIsEvm(fill.repaymentChainId) && !fill.relayer.isValidEvmAddress();
+  return !isValidEvmAddress(fill.relayer);
 }

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

@@ -21,12 +21,6 @@ export function buildPoolRebalanceLeafTree(poolRebalanceLeaves: PoolRebalanceLea
   }
 
   const paramType = getParamType("MerkleLibTest", "verifyPoolRebalance", "rebalance");
-  const hashFn = (input: PoolRebalanceLeaf) => {
-    const ethersLeaf = {
-      ...input,
-      l1Tokens: input.l1Tokens.map((l1Token) => l1Token.toEvmAddress()),
-    };
-    return utils.keccak256(utils.defaultAbiCoder.encode([paramType], [ethersLeaf]));
-  };
+  const hashFn = (input: PoolRebalanceLeaf) => utils.keccak256(utils.defaultAbiCoder.encode([paramType], [input]));
   return new MerkleTree<PoolRebalanceLeaf>(poolRebalanceLeaves, hashFn);
 }