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

package/src/arch/evm/SpokeUtils.ts

@@ -13,10 +13,11 @@ import {
   isDefined,
   isUnsafeDepositId,
   isZeroAddress,
+  getDepositRelayData,
   getNetworkName,
   paginatedEventQuery,
   spreadEventWithBlockNumber,
-  Address,
+  toBytes32,
 } from "../../utils";
 
 type BlockTag = providers.BlockTag;
@@ -30,23 +31,10 @@ type BlockTag = providers.BlockTag;
 export function populateV3Relay(
   spokePool: Contract,
   deposit: Omit<Deposit, "messageHash">,
-  relayer: Address,
+  relayer: string,
   repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {
-  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));
@@ -55,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 });
 }
 
 /**

package/src/arch/svm/SpokeUtils.ts

@@ -4,17 +4,21 @@ import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
   TOKEN_PROGRAM_ADDRESS,
+  fetchMint,
   getApproveCheckedInstruction,
+  getCreateAssociatedTokenIdempotentInstruction,
 } from "@solana-program/token";
 import {
   Address,
   address,
+  appendTransactionMessageInstruction,
   fetchEncodedAccount,
   fetchEncodedAccounts,
   getAddressEncoder,
   getProgramDerivedAddress,
   getU32Encoder,
   getU64Encoder,
+  pipe,
   some,
   type TransactionSigner,
 } from "@solana/kit";
@@ -22,19 +26,17 @@ import assert from "assert";
 import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
 
-import { CHAIN_IDs } from "../../constants";
+import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import { Deposit, DepositWithBlock, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { BigNumber, SvmAddress, chainIsSvm, chunk, isUnsafeDepositId, keccak256, toAddressType } from "../../utils";
 import {
-  BigNumber,
-  SvmAddress,
-  chainIsSvm,
-  chunk,
-  getTokenInfo,
-  isDefined,
-  isUnsafeDepositId,
-  keccak256,
-} from "../../utils";
-import { SvmCpiEventsClient, getEventAuthority, getFillStatusPda, getStatePda, unwrapEventData } from "./";
+  SvmCpiEventsClient,
+  createDefaultTransaction,
+  getEventAuthority,
+  getFillStatusPda,
+  getStatePda,
+  unwrapEventData,
+} from "./";
 import { SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -355,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"));
@@ -366,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"));
@@ -425,41 +427,146 @@ export function createTokenAccountsInstruction(
 }
 
 /**
- * @param mint Address of the token corresponding to the account being made.
- * @param amount Amount of the token to approve.
- * @param relayer Address of the relayer filling the deposit.
- * @param spokePool Address (program ID) of the SvmSpoke.
- * @returns A token approval instruction.
+ * Creates a fill instruction.
+ * @param signer - The signer of the transaction.
+ * @param solanaClient - The Solana client.
+ * @param fillInput - The fill input.
+ * @param tokenDecimals - The token decimals.
+ * @param createRecipientAtaIfNeeded - Whether to create a recipient token account.
+ * @returns The fill instruction.
  */
-export async function createApproveInstruction(
-  mint: SvmAddress,
-  amount: BigNumber,
-  relayer: SvmAddress,
-  spokePool: SvmAddress,
-  mintDecimals?: number
-) {
-  const [relayerTokenAccount, statePda] = await Promise.all([
-    getAssociatedTokenAddress(relayer, mint, TOKEN_PROGRAM_ADDRESS),
-    getStatePda(spokePool.toV2Address()),
-  ]);
+export const createFillInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  fillInput: SvmSpokeClient.FillRelayInput,
+  tokenDecimals: number,
+  createRecipientAtaIfNeeded: boolean = true
+) => {
+  const mintInfo = await fetchMint(solanaClient, fillInput.mint);
+  const approveIx = getApproveCheckedInstruction(
+    {
+      source: fillInput.relayerTokenAccount,
+      mint: fillInput.mint,
+      delegate: fillInput.delegate,
+      owner: fillInput.signer,
+      amount: (fillInput.relayData as SvmSpokeClient.RelayDataArgs).outputAmount,
+      decimals: tokenDecimals,
+    },
+    {
+      programAddress: mintInfo.programAddress,
+    }
+  );
 
-  // If no mint decimals were supplied, then assign it to whatever value we have in TOKEN_SYMBOLS_MAP.
-  // If this token is not in TOKEN_SYMBOLS_MAP, then throw an error.
-  mintDecimals ??= getTokenInfo(mint.toBase58(), CHAIN_IDs.SOLANA)?.decimals;
-  if (!isDefined(mintDecimals)) {
-    throw new Error(`No mint decimals found for token ${mint.toBase58()}`);
-  }
+  const getCreateAssociatedTokenIdempotentIx = () =>
+    getCreateAssociatedTokenIdempotentInstruction({
+      payer: signer,
+      owner: (fillInput.relayData as SvmSpokeClient.RelayDataArgs).recipient,
+      mint: fillInput.mint,
+      ata: fillInput.recipientTokenAccount,
+      systemProgram: SYSTEM_PROGRAM_ADDRESS,
+      tokenProgram: fillInput.tokenProgram,
+    });
 
-  return getApproveCheckedInstruction({
-    source: relayerTokenAccount,
-    mint: mint.toV2Address(),
-    delegate: statePda,
-    owner: relayer.toV2Address(),
-    amount: amount.toBigInt(),
-    decimals: mintDecimals,
-  });
-}
+  const createFillIx = await SvmSpokeClient.getFillRelayInstruction(fillInput);
+
+  return pipe(
+    await createDefaultTransaction(solanaClient, signer),
+    (tx) =>
+      createRecipientAtaIfNeeded ? appendTransactionMessageInstruction(getCreateAssociatedTokenIdempotentIx(), tx) : tx,
+    (tx) => appendTransactionMessageInstruction(approveIx, tx),
+    (tx) => appendTransactionMessageInstruction(createFillIx, tx)
+  );
+};
 
+/**
+ * Creates a deposit instruction.
+ * @param signer - The signer of the transaction.
+ * @param solanaClient - The Solana client.
+ * @param depositInput - The deposit input.
+ * @param tokenDecimals - The token decimals.
+ * @param createVaultAtaIfNeeded - Whether to create a vault token account.
+ * @returns The deposit instruction.
+ */
+export const createDepositInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  depositInput: SvmSpokeClient.DepositInput,
+  tokenDecimals: number,
+  createVaultAtaIfNeeded: boolean = true
+) => {
+  const getCreateAssociatedTokenIdempotentIx = () =>
+    getCreateAssociatedTokenIdempotentInstruction({
+      payer: signer,
+      owner: depositInput.state,
+      mint: depositInput.mint,
+      ata: depositInput.vault,
+      systemProgram: depositInput.systemProgram,
+      tokenProgram: depositInput.tokenProgram,
+    });
+  const mintInfo = await fetchMint(solanaClient, depositInput.mint);
+  const approveIx = getApproveCheckedInstruction(
+    {
+      source: depositInput.depositorTokenAccount,
+      mint: depositInput.mint,
+      delegate: depositInput.delegate,
+      owner: depositInput.depositor,
+      amount: depositInput.inputAmount,
+      decimals: tokenDecimals,
+    },
+    {
+      programAddress: mintInfo.programAddress,
+    }
+  );
+  const depositIx = await SvmSpokeClient.getDepositInstruction(depositInput);
+  return pipe(
+    await createDefaultTransaction(solanaClient, signer),
+    (tx) =>
+      createVaultAtaIfNeeded ? appendTransactionMessageInstruction(getCreateAssociatedTokenIdempotentIx(), tx) : tx,
+    (tx) => appendTransactionMessageInstruction(approveIx, tx),
+    (tx) => appendTransactionMessageInstruction(depositIx, tx)
+  );
+};
+
+/**
+ * Creates a request slow fill instruction.
+ * @param signer - The signer of the transaction.
+ * @param solanaClient - The Solana client.
+ * @param depositInput - The deposit input.
+ * @returns The request slow fill instruction.
+ */
+export const createRequestSlowFillInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  depositInput: SvmSpokeClient.RequestSlowFillInput
+) => {
+  const requestSlowFillIx = await SvmSpokeClient.getRequestSlowFillInstruction(depositInput);
+
+  return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
+    appendTransactionMessageInstruction(requestSlowFillIx, tx)
+  );
+};
+
+/**
+ * Creates a close fill PDA instruction.
+ * @param signer - The signer of the transaction.
+ * @param solanaClient - The Solana client.
+ * @param fillStatusPda - The fill status PDA.
+ * @returns The close fill PDA instruction.
+ */
+export const createCloseFillPdaInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  fillStatusPda: Address
+) => {
+  const closeFillPdaIx = await SvmSpokeClient.getCloseFillPdaInstruction({
+    signer,
+    state: await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    fillStatus: fillStatusPda,
+  });
+  return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
+    appendTransactionMessageInstruction(closeFillPdaIx, tx)
+  );
+};
 export async function getAssociatedTokenAddress(
   owner: SvmAddress,
   mint: SvmAddress,
@@ -484,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

@@ -10,6 +10,10 @@ import {
   getU32Encoder,
   isAddress,
   type TransactionSigner,
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
 } from "@solana/kit";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { FillType, RelayData } from "../../interfaces";
@@ -264,13 +268,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.
@@ -280,3 +284,18 @@ export function getRandomSvmAddress() {
   const base58Address = bs58.encode(bytes);
   return address(base58Address);
 }
+
+/**
+ * Creates a default v0 transaction skeleton.
+ * @param rpcClient - The Solana client.
+ * @param signer - The signer of the transaction.
+ * @returns The default transaction.
+ */
+export const createDefaultTransaction = async (rpcClient: SVMProvider, signer: TransactionSigner) => {
+  const { value: latestBlockhash } = await rpcClient.getLatestBlockhash().send();
+  return pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)
+  );
+};

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;
@@ -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",