@across-protocol/sdk 4.2.16 → 4.3.1

package/src/arch/svm/SpokeUtils.ts

@@ -24,13 +24,13 @@ import {
 import assert from "assert";
 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 } from "../../interfaces";
+import { DepositWithBlock, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
 import {
   BigNumber,
   EvmAddress,
   SvmAddress,
+  Address as SdkAddress,
   chainIsSvm,
   chunk,
   isUnsafeDepositId,
@@ -46,6 +46,7 @@ import {
   toAddress,
   unwrapEventData,
 } from "./";
+import { CHAIN_IDs } from "../../constants";
 import { SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -54,6 +55,12 @@ import { SVMEventNames, SVMProvider } from "./types";
  */
 export const SLOT_DURATION_MS = 400;
 
+type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
+  destinationChainId: number;
+  recipient: SvmAddress;
+  outputToken: SvmAddress;
+};
+
 /**
  * Retrieves the chain time at a particular slot.
  */
@@ -145,13 +152,20 @@ export async function findDeposit(
     return undefined;
   }
 
+  const unwrappedDepositEvent = unwrapEventData(depositEvent.data) as Record<string, unknown>;
+  const destinationChainId = unwrappedDepositEvent.destinationChainId as number;
   // Return the deposit event with block info
   return {
     txnRef: depositEvent.signature.toString(),
     blockNumber: Number(depositEvent.slot),
     txnIndex: 0,
     logIndex: 0,
-    ...(unwrapEventData(depositEvent.data) as Record<string, unknown>),
+    ...unwrappedDepositEvent,
+    depositor: toAddressType(unwrappedDepositEvent.depositor as string, CHAIN_IDs.SOLANA),
+    recipient: toAddressType(unwrappedDepositEvent.recipient as string, destinationChainId),
+    inputToken: toAddressType(unwrappedDepositEvent.inputToken as string, CHAIN_IDs.SOLANA),
+    outputToken: toAddressType(unwrappedDepositEvent.outputToken as string, destinationChainId),
+    exclusiveRelayer: toAddressType(unwrappedDepositEvent.exclusiveRelayer as string, destinationChainId),
   } as DepositWithBlock;
 }
 
@@ -327,14 +341,34 @@ 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,
-      ...(unwrapEventData(rawFillEvent.data) as Record<string, unknown>),
-    } as unknown as FillWithBlock;
+      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;
     return parsedFillEvent;
   }
 
@@ -343,18 +377,18 @@ export async function findFillEvent(
 
 /**
  * @param spokePool Address (program ID) of the SvmSpoke.
- * @param deposit V3Deopsit instance.
+ * @param relayData RelayData instance, supplemented with destinationChainId
  * @param relayer Address of the relayer filling the deposit.
  * @param repaymentChainId Optional repaymentChainId (defaults to destinationChainId).
  * @returns An Ethers UnsignedTransaction instance.
  */
 export async function fillRelayInstruction(
   spokePool: SvmAddress,
-  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain">,
+  relayData: ProtoFill,
   signer: TransactionSigner<string>,
   recipientTokenAccount: Address<string>,
   repaymentAddress: EvmAddress | SvmAddress = SvmAddress.from(signer.address),
-  repaymentChainId = deposit.destinationChainId
+  repaymentChainId = relayData.destinationChainId
 ) {
   const program = toAddress(spokePool);
 
@@ -363,25 +397,22 @@ export async function fillRelayInstruction(
     `Invalid repayment address for chain ${repaymentChainId}: ${repaymentAddress.toNative()}.`
   );
 
-  const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
+  const _relayDataHash = getRelayDataHash(relayData, relayData.destinationChainId);
   const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
   const relayer = SvmAddress.from(signer.address);
-  const outputTokenAddress = toAddressType(deposit.outputToken, deposit.destinationChainId);
-  if (!(outputTokenAddress instanceof SvmAddress)) {
-    return undefined;
-  }
 
   // Create ATA for the relayer and recipient token accounts
-  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, outputTokenAddress);
+  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, relayData.outputToken);
 
   const [statePda, fillStatusPda, eventAuthority] = await Promise.all([
     getStatePda(program),
-    getFillStatusPda(program, deposit, deposit.destinationChainId),
-    getEventAuthority(),
+    getFillStatusPda(program, relayData, relayData.destinationChainId),
+    getEventAuthority(program),
   ]);
+
   const depositIdBuffer = new Uint8Array(32);
-  const shortenedBuffer = new Uint8Array(Buffer.from(deposit.depositId.toHexString().slice(2), "hex"));
+  const shortenedBuffer = new Uint8Array(Buffer.from(relayData.depositId.toHexString().slice(2), "hex"));
   depositIdBuffer.set(shortenedBuffer, 32 - shortenedBuffer.length);
 
   const delegatePda = await getFillRelayDelegatePda(
@@ -391,26 +422,14 @@ export async function fillRelayInstruction(
     program
   );
 
-  // @todo we need to convert the deposit's relayData to svm-like since the interface assumes the data originates
-  // from an EVM Spoke pool. Once we migrate to `Address` types, this can be modified/removed.
-  const [depositor, inputToken] = [deposit.depositor, deposit.inputToken].map((addr: string) => {
-    const addressObj = toAddressType(addr, deposit.originChainId);
-    // @dev we don't really care for correctness of format of depositor / inputToken, so we're fine converting to Solana
-    // SDK `Address<string>` type even if our `toAddressType` function returned a raw address.
-    return addressObj.toBase58() as Address<string>;
-  });
-
-  const [recipient, exclusiveRelayer] = [deposit.recipient, deposit.exclusiveRelayer].map((addr) => {
-    const addressObj = toAddressType(addr, deposit.originChainId);
-    if (!(addressObj instanceof SvmAddress)) {
-      return undefined;
-    }
-    return toAddress(addressObj);
-  });
-
-  if (!recipient || !exclusiveRelayer) return undefined;
+  const [recipient, outputToken, exclusiveRelayer, depositor, inputToken] = [
+    relayData.recipient,
+    relayData.outputToken,
+    relayData.exclusiveRelayer,
+    relayData.depositor,
+    relayData.inputToken,
+  ].map(toAddress);
 
-  const outputToken = toAddress(outputTokenAddress);
   return SvmSpokeClient.getFillRelayInstruction({
     signer,
     state: statePda,
@@ -428,13 +447,13 @@ export async function fillRelayInstruction(
       exclusiveRelayer,
       inputToken,
       outputToken,
-      inputAmount: deposit.inputAmount.toBigInt(),
-      outputAmount: deposit.outputAmount.toBigInt(),
-      originChainId: BigInt(deposit.originChainId),
-      fillDeadline: deposit.fillDeadline,
-      exclusivityDeadline: deposit.exclusivityDeadline,
+      inputAmount: relayData.inputAmount.toBigInt(),
+      outputAmount: relayData.outputAmount.toBigInt(),
+      originChainId: BigInt(relayData.originChainId),
+      fillDeadline: relayData.fillDeadline,
+      exclusivityDeadline: relayData.exclusivityDeadline,
       depositId: depositIdBuffer,
-      message: new Uint8Array(Buffer.from(deposit.message.slice(2), "hex")),
+      message: new Uint8Array(Buffer.from(relayData.message.slice(2), "hex")),
     }),
     repaymentChainId: some(BigInt(repaymentChainId)),
     repaymentAddress: toAddress(repaymentAddress),
@@ -616,19 +635,14 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   const uint32Encoder = getU32Encoder();
 
   assert(relayData.message.startsWith("0x"), "Message must be a hex string");
-  const encodeAddress = (addr: string, chainId: number) => {
-    const addrObj = toAddressType(addr, chainId);
-    // @dev even if `addrObj` is of type `Address` here, we still want to calculate the relayHash
-    // based on `base58` representation of the `Address`
-    return Uint8Array.from(addressEncoder.encode(addrObj.toBase58() as Address<string>));
-  };
+  const encodeAddress = (data: SdkAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
 
   const contentToHash = Buffer.concat([
-    encodeAddress(relayData.depositor, relayData.originChainId),
-    encodeAddress(relayData.recipient, destinationChainId),
-    encodeAddress(relayData.exclusiveRelayer, destinationChainId),
-    encodeAddress(relayData.inputToken, relayData.originChainId),
-    encodeAddress(relayData.outputToken, destinationChainId),
+    encodeAddress(relayData.depositor),
+    encodeAddress(relayData.recipient),
+    encodeAddress(relayData.exclusiveRelayer),
+    encodeAddress(relayData.inputToken),
+    encodeAddress(relayData.outputToken),
     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/eventsClient.ts

@@ -10,7 +10,7 @@ import {
   GetTransactionApi,
   Signature,
 } from "@solana/kit";
-import { bs58, chainIsSvm, getMessageHash } from "../../utils";
+import { bs58, chainIsSvm, getMessageHash, toAddressType } from "../../utils";
 import { EventName, EventWithData, SVMProvider } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
 import { Deposit, DepositWithTime, Fill, FillWithTime } from "../../interfaces";
@@ -252,7 +252,6 @@ export class SvmCpiEventsClient {
 
     // Filter for FundsDeposited events only
     const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
-
     if (!txDetails || !depositEvents?.length) {
       return;
     }
@@ -261,13 +260,29 @@ export class SvmCpiEventsClient {
       const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, ["depositId"]) as Record<
         "data",
         Deposit
-      >;
-
+      > &
+        Record<
+          "data",
+          {
+            depositor: string;
+            recipient: string;
+            exclusiveRelayer: string;
+            inputToken: string;
+            outputToken: string;
+          }
+        >;
+
+      const { data } = unwrappedEventArgs;
       return {
-        ...unwrappedEventArgs.data,
+        ...data,
+        depositor: toAddressType(data.depositor, data.originChainId),
+        recipient: toAddressType(data.recipient, data.destinationChainId),
+        exclusiveRelayer: toAddressType(data.exclusiveRelayer, data.destinationChainId),
+        inputToken: toAddressType(data.inputToken, data.originChainId),
+        outputToken: toAddressType(data.outputToken, data.destinationChainId),
         depositTimestamp: Number(txDetails.blockTime),
         originChainId,
-        messageHash: getMessageHash(unwrappedEventArgs.data.message),
+        messageHash: getMessageHash(data.message),
         blockNumber: Number(txDetails.slot),
         txnIndex: 0,
         txnRef: txSignature,
@@ -309,9 +324,26 @@ export class SvmCpiEventsClient {
     }
 
     return fillEvents.map((event) => {
-      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<"data", Fill>;
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<"data", Fill> &
+        Record<
+          "data",
+          {
+            depositor: string;
+            recipient: string;
+            exclusiveRelayer: string;
+            inputToken: string;
+            outputToken: string;
+          }
+        >;
+
+      const { data } = unwrappedEventData;
       return {
-        ...unwrappedEventData.data,
+        ...data,
+        depositor: toAddressType(data.depositor, data.originChainId),
+        recipient: toAddressType(data.recipient, data.destinationChainId),
+        exclusiveRelayer: toAddressType(data.exclusiveRelayer, data.destinationChainId),
+        inputToken: toAddressType(data.inputToken, data.originChainId),
+        outputToken: toAddressType(data.outputToken, data.destinationChainId),
         fillTimestamp: Number(txDetails.blockTime),
         blockNumber: Number(txDetails.slot),
         txnRef: txSignature,

package/src/arch/svm/utils.ts

@@ -17,7 +17,7 @@ import {
 } from "@solana/kit";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { FillType, RelayData } from "../../interfaces";
-import { BigNumber, EvmAddress, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
+import { BigNumber, getRelayDataHash, isUint8Array, Address as SdkAddress } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -45,7 +45,7 @@ export async function isDevnet(rpc: SVMProvider): Promise<boolean> {
 /**
  * Small utility to convert an Address to a Solana Kit branded type.
  */
-export function toAddress(address: EvmAddress | SvmAddress): Address<string> {
+export function toAddress(address: SdkAddress): Address<string> {
   return address.toBase58() as Address<string>;
 }
 
@@ -144,7 +144,7 @@ export function unwrapEventData(
   }
   // Handle strings (potential addresses)
   if (typeof data === "string" && isAddress(data)) {
-    return SvmAddress.from(data).toBytes32();
+    return ethers.utils.hexlify(bs58.decode(data));
   }
   // Handle objects
   if (typeof data === "object") {
@@ -280,13 +280,13 @@ export async function getInstructionParamsPda(programId: Address, signer: Addres
  * Returns the PDA for the Event Authority.
  * @returns The PDA for the Event Authority.
  */
-export const getEventAuthority = async () => {
+export async function getEventAuthority(programId: Address): Promise<Address> {
   const [eventAuthority] = await getProgramDerivedAddress({
-    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    programAddress: programId,
     seeds: ["__event_authority"],
   });
   return eventAuthority;
-};
+}
 
 /**
  * Returns a random SVM address.

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

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

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -39,10 +39,9 @@ import {
   bnUint32Max,
   isZeroValueDeposit,
   isZeroValueFillOrSlowFillRequest,
-  chainIsEvm,
-  isValidEvmAddress,
   duplicateEvent,
   invalidOutputToken,
+  Address,
   getNetworkName,
 } from "../../utils";
 import winston from "winston";
@@ -69,22 +68,21 @@ 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) && !isValidEvmAddress(deposit.depositor)) {
+  if (!deposit.depositor.isValidOn(deposit.originChainId)) {
     return;
   }
+
   const { originChainId, inputToken } = deposit;
-  if (!dict?.[originChainId]?.[inputToken]) {
-    assign(dict, [originChainId, inputToken], []);
-  }
-  dict[originChainId][inputToken].push(deposit);
+  dict[originChainId] ??= {};
+  dict[originChainId][inputToken.toBytes32()] ??= [];
+  dict[originChainId][inputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleDepositsV3(dict: BundleDepositsV3, deposit: V3DepositWithBlock): void {
   const { originChainId, inputToken } = deposit;
-  if (!dict?.[originChainId]?.[inputToken]) {
-    assign(dict, [originChainId, inputToken], []);
-  }
-  dict[originChainId][inputToken].push(deposit);
+  dict[originChainId] ??= {};
+  dict[originChainId][inputToken.toBytes32()] ??= [];
+  dict[originChainId][inputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleFillsV3(
@@ -92,29 +90,29 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: string,
-  repaymentAddress: string
+  repaymentToken: Address,
+  repaymentAddress: Address
 ): void {
   // We shouldn't pass any unrepayable fills into this function, so we perform an extra safety check.
-  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
+  if (!fill.relayer.isValidOn(repaymentChainId)) {
     return;
   }
-  if (!dict?.[repaymentChainId]?.[repaymentToken]) {
-    assign(dict, [repaymentChainId, repaymentToken], {
-      fills: [],
-      totalRefundAmount: bnZero,
-      realizedLpFees: bnZero,
-      refunds: {},
-    });
-  }
+
+  dict[repaymentChainId] ??= {};
+  dict[repaymentChainId][repaymentToken.toBytes32()] ??= {
+    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, "fills"], [bundleFill]);
+  assign(dict, [repaymentChainId, repaymentToken.toBytes32(), "fills"], [bundleFill]);
 
   // All fills update the bundle LP fees.
-  const refundObj = dict[repaymentChainId][repaymentToken];
+  const refundObj = dict[repaymentChainId][repaymentToken.toBytes32()];
   const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
@@ -128,10 +126,11 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[bundleFill.relayer]) {
-      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
+    if (refundObj.refunds[bundleFill.relayer.toBytes32()]) {
+      refundObj.refunds[bundleFill.relayer.toBytes32()] =
+        refundObj.refunds[bundleFill.relayer.toBytes32()].add(refundAmount);
     } else {
-      refundObj.refunds[bundleFill.relayer] = refundAmount;
+      refundObj.refunds[bundleFill.relayer.toBytes32()] = refundAmount;
     }
   }
 }
@@ -141,21 +140,20 @@ function updateBundleExcessSlowFills(
   deposit: V3DepositWithBlock & { lpFeePct: BigNumber }
 ): void {
   const { destinationChainId, outputToken } = deposit;
-  if (!dict?.[destinationChainId]?.[outputToken]) {
-    assign(dict, [destinationChainId, outputToken], []);
-  }
-  dict[destinationChainId][outputToken].push(deposit);
+  dict[destinationChainId] ??= {};
+  dict[destinationChainId][outputToken.toBytes32()] ??= [];
+  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleSlowFills(dict: BundleSlowFills, deposit: V3DepositWithBlock & { lpFeePct: BigNumber }): void {
-  if (chainIsEvm(deposit.destinationChainId) && !isValidEvmAddress(deposit.recipient)) {
+  if (!deposit.recipient.isValidOn(deposit.destinationChainId)) {
     return;
   }
+
   const { destinationChainId, outputToken } = deposit;
-  if (!dict?.[destinationChainId]?.[outputToken]) {
-    assign(dict, [destinationChainId, outputToken], []);
-  }
-  dict[destinationChainId][outputToken].push(deposit);
+  dict[destinationChainId] ??= {};
+  dict[destinationChainId][outputToken.toBytes32()] ??= [];
+  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
 }
 
 // @notice Shared client for computing data needed to construct or validate a bundle.
@@ -507,22 +505,24 @@ export class BundleDataClient {
         // worst from the relayer's perspective.
         const { relayer, inputAmount: refundAmount } = fill;
         refundsForChain[chainToSendRefundTo] ??= {};
-        refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
-        const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
-        refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
+        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()] ??= {};
+        const existingRefundAmount =
+          refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] ?? bnZero;
+        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] =
+          existingRefundAmount.add(refundAmount);
       });
     }
     return refundsForChain;
   }
 
-  getUpcomingDepositAmount(chainId: number, l2Token: string, latestBlockToSearch: number): BigNumber {
+  getUpcomingDepositAmount(chainId: number, l2Token: Address, latestBlockToSearch: number): BigNumber {
     const spokePoolClient = this.spokePoolClientManager.getClient(chainId);
     if (!isDefined(spokePoolClient)) {
       return toBN(0);
     }
     return spokePoolClient
       .getDeposits()
-      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken === l2Token)
+      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken.eq(l2Token))
       .reduce((acc, deposit) => {
         return acc.add(deposit.inputAmount);
       }, toBN(0));
@@ -644,18 +644,14 @@ export class BundleDataClient {
       .filter((leaf) => leaf.rootBundleId === bundle.rootBundleId);
     const executedRefunds: { [tokenAddress: string]: { [relayer: string]: BigNumber } } = {};
     for (const refundLeaf of executedRefundLeaves) {
-      const tokenAddress = refundLeaf.l2TokenAddress;
-      if (executedRefunds[tokenAddress] === undefined) {
-        executedRefunds[tokenAddress] = {};
-      }
-      const executedTokenRefunds = executedRefunds[tokenAddress];
+      const tokenAddress = refundLeaf.l2TokenAddress.toBytes32();
+      const executedTokenRefunds = (executedRefunds[tokenAddress] ??= {});
 
       for (let i = 0; i < refundLeaf.refundAddresses.length; i++) {
-        const relayer = refundLeaf.refundAddresses[i];
+        const relayer = refundLeaf.refundAddresses[i].toBytes32();
         const refundAmount = refundLeaf.refundAmounts[i];
-        if (executedTokenRefunds[relayer] === undefined) {
-          executedTokenRefunds[relayer] = bnZero;
-        }
+
+        executedTokenRefunds[relayer] ??= bnZero;
         executedTokenRefunds[relayer] = executedTokenRefunds[relayer].add(refundAmount);
       }
     }
@@ -695,15 +691,15 @@ export class BundleDataClient {
     return allRefunds;
   }
 
-  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: string, chainId: number, token: string): BigNumber {
-    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token]) {
+  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: Address, chainId: number, token: Address): BigNumber {
+    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token.toBytes32()]) {
       return BigNumber.from(0);
     }
-    const allRefunds = bundleRefunds[chainId][token];
-    return allRefunds && allRefunds[relayer] ? allRefunds[relayer] : BigNumber.from(0);
+    const allRefunds = bundleRefunds[chainId][token.toBytes32()];
+    return allRefunds && allRefunds[relayer.toBytes32()] ? allRefunds[relayer.toBytes32()] : BigNumber.from(0);
   }
 
-  getTotalRefund(refunds: CombinedRefunds[], relayer: string, chainId: number, refundToken: string): BigNumber {
+  getTotalRefund(refunds: CombinedRefunds[], relayer: Address, chainId: number, refundToken: Address): BigNumber {
     return refunds.reduce((totalRefund, refunds) => {
       return totalRefund.add(this.getRefundsFor(refunds, relayer, chainId, refundToken));
     }, bnZero);
@@ -916,7 +912,11 @@ export class BundleDataClient {
             "Not using correct bundle deposit hash key"
           );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
-            if (bundleDepositsV3?.[originChainId]?.[deposit.inputToken]?.find((d) => duplicateEvent(deposit, d))) {
+            if (
+              bundleDepositsV3?.[originChainId]?.[deposit.inputToken.toBytes32()]?.find((d) =>
+                duplicateEvent(deposit, d)
+              )
+            ) {
               this.logger.debug({
                 at: "BundleDataClient#loadData",
                 message: "Duplicate deposit detected",