@across-protocol/sdk 4.2.16-alpha.0 → 4.2.16-alpha.3

package/src/arch/evm/SpokeUtils.ts

@@ -1,8 +1,9 @@
 import assert from "assert";
 import { BytesLike, Contract, PopulatedTransaction, providers } from "ethers";
 import { CHAIN_IDs } from "../../constants";
-import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { Deposit, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
 import {
+  EvmAddress,
   bnUint32Max,
   BigNumber,
   toBN,
@@ -13,11 +14,11 @@ import {
   isDefined,
   isUnsafeDepositId,
   isZeroAddress,
-  getDepositRelayData,
   getNetworkName,
   paginatedEventQuery,
   spreadEventWithBlockNumber,
-  toBytes32,
+  Address,
+  toAddressType,
 } from "../../utils";
 
 type BlockTag = providers.BlockTag;
@@ -30,11 +31,32 @@ type BlockTag = providers.BlockTag;
  */
 export function populateV3Relay(
   spokePool: Contract,
-  deposit: Omit<Deposit, "messageHash">,
-  relayer: string,
+  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain"> & {
+    recipient: EvmAddress;
+    outputToken: EvmAddress;
+    exclusiveRelayer: EvmAddress;
+  },
+  repaymentAddress: Address,
   repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {
-  const relayData = getDepositRelayData(deposit);
+  assert(
+    repaymentAddress.isValidOn(repaymentChainId),
+    `Invalid repayment address for chain ${repaymentChainId}: ${repaymentAddress.toNative()}.`
+  );
+  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(),
+  };
 
   if (isDefined(deposit.speedUpSignature)) {
     assert(isDefined(deposit.updatedRecipient) && !isZeroAddress(deposit.updatedRecipient));
@@ -43,16 +65,15 @@ export function populateV3Relay(
     return spokePool.populateTransaction.fillRelayWithUpdatedDeposit(
       relayData,
       repaymentChainId,
-      toBytes32(relayer),
+      repaymentAddress.toBytes32(),
       deposit.updatedOutputAmount,
-      toBytes32(deposit.updatedRecipient),
+      deposit.updatedRecipient.toBytes32(),
       deposit.updatedMessage,
-      deposit.speedUpSignature,
-      { from: relayer }
+      deposit.speedUpSignature
     );
   }
 
-  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, toBytes32(relayer), { from: relayer });
+  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, repaymentAddress.toBytes32());
 }
 
 /**
@@ -315,8 +336,27 @@ 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 = {
-    ...spreadEventWithBlockNumber(event),
+    ...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),
+    },
     destinationChainId,
     messageHash: getMessageHash(event.args.message),
   } as FillWithBlock;

package/src/arch/svm/SpokeUtils.ts

@@ -10,7 +10,6 @@ import {
 } from "@solana-program/token";
 import {
   Address,
-  address,
   appendTransactionMessageInstruction,
   fetchEncodedAccount,
   fetchEncodedAccounts,
@@ -19,26 +18,41 @@ import {
   getU32Encoder,
   getU64Encoder,
   pipe,
-  ReadonlyUint8Array,
   some,
   type TransactionSigner,
 } from "@solana/kit";
 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 { BigNumber, SvmAddress, chainIsSvm, chunk, isUnsafeDepositId, keccak256, toAddressType } from "../../utils";
+import {
+  Deposit,
+  DepositWithBlock,
+  FillStatus,
+  FillWithBlock,
+  RelayData,
+  RelayExecutionEventInfo,
+} from "../../interfaces";
+import {
+  BigNumber,
+  EvmAddress,
+  SvmAddress,
+  chainIsSvm,
+  chunk,
+  isUnsafeDepositId,
+  keccak256,
+  toAddressType,
+} from "../../utils";
 import {
   SvmCpiEventsClient,
-  bigToU8a32,
   createDefaultTransaction,
   getEventAuthority,
   getFillStatusPda,
   getStatePda,
+  toAddress,
   unwrapEventData,
 } from "./";
+import { CHAIN_IDs } from "../../constants";
 import { SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -138,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;
 }
 
@@ -320,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,35 +384,36 @@ export async function findFillEvent(
  */
 export async function fillRelayInstruction(
   spokePool: SvmAddress,
-  deposit: Omit<Deposit, "messageHash">,
-  relayer: TransactionSigner<string>,
+  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain"> & {
+    recipient: SvmAddress;
+    outputToken: SvmAddress;
+    exclusiveRelayer: SvmAddress;
+  },
+  signer: TransactionSigner<string>,
   recipientTokenAccount: Address<string>,
+  repaymentAddress: EvmAddress | SvmAddress = SvmAddress.from(signer.address),
   repaymentChainId = deposit.destinationChainId
 ) {
-  const programId = spokePool.toBase58();
-  const relayerAddress = SvmAddress.from(relayer.address);
+  const program = toAddress(spokePool);
 
-  // @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, recipient, exclusiveRelayer, inputToken, outputToken] = [
-    deposit.depositor,
-    deposit.recipient,
-    deposit.exclusiveRelayer,
-    deposit.inputToken,
-    deposit.outputToken,
-  ].map((addr) => toAddressType(addr).forceSvmAddress());
+  assert(
+    repaymentAddress.isValidOn(repaymentChainId),
+    `Invalid repayment address for chain ${repaymentChainId}: ${repaymentAddress.toNative()}.`
+  );
 
   const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
   const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
+  const relayer = SvmAddress.from(signer.address);
   // Create ATA for the relayer and recipient token accounts
-  const relayerTokenAccount = await getAssociatedTokenAddress(relayerAddress, outputToken);
+  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, deposit.outputToken);
 
   const [statePda, fillStatusPda, eventAuthority] = await Promise.all([
-    getStatePda(spokePool.toV2Address()),
-    getFillStatusPda(spokePool.toV2Address(), deposit, deposit.destinationChainId),
-    getEventAuthority(),
+    getStatePda(program),
+    getFillStatusPda(program, deposit, deposit.destinationChainId),
+    getEventAuthority(program),
   ]);
+
   const depositIdBuffer = new Uint8Array(32);
   const shortenedBuffer = new Uint8Array(Buffer.from(deposit.depositId.toHexString().slice(2), "hex"));
   depositIdBuffer.set(shortenedBuffer, 32 - shortenedBuffer.length);
@@ -379,28 +421,37 @@ export async function fillRelayInstruction(
   const delegatePda = await getFillRelayDelegatePda(
     relayDataHash,
     BigInt(repaymentChainId),
-    relayerAddress.toV2Address(),
-    spokePool.toV2Address()
+    toAddress(relayer),
+    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(toAddress);
+  const [recipient, outputToken, exclusiveRelayer] = [
+    deposit.recipient,
+    deposit.outputToken,
+    deposit.exclusiveRelayer,
+  ].map(toAddress);
+
   return SvmSpokeClient.getFillRelayInstruction({
-    signer: relayer,
+    signer,
     state: statePda,
-    delegate: SvmAddress.from(delegatePda.toString()).toV2Address(),
-    mint: outputToken.toV2Address(),
+    delegate: toAddress(SvmAddress.from(delegatePda.toString())),
+    mint: outputToken,
     relayerTokenAccount: relayerTokenAccount,
     recipientTokenAccount: recipientTokenAccount,
     fillStatus: fillStatusPda,
     eventAuthority,
-    program: address(programId),
+    program,
     relayHash: relayDataHash,
     relayData: some({
-      depositor: depositor.toV2Address(),
-      recipient: recipient.toV2Address(),
-      exclusiveRelayer: exclusiveRelayer.toV2Address(),
-      inputToken: inputToken.toV2Address(),
-      outputToken: outputToken.toV2Address(),
-      inputAmount: bigToU8a32(deposit.inputAmount),
+      depositor,
+      recipient,
+      exclusiveRelayer,
+      inputToken,
+      outputToken,
+      inputAmount: deposit.inputAmount.toBigInt(),
       outputAmount: deposit.outputAmount.toBigInt(),
       originChainId: BigInt(deposit.originChainId),
       fillDeadline: deposit.fillDeadline,
@@ -409,7 +460,7 @@ export async function fillRelayInstruction(
       message: new Uint8Array(Buffer.from(deposit.message.slice(2), "hex")),
     }),
     repaymentChainId: some(BigInt(repaymentChainId)),
-    repaymentAddress: some(relayerAddress.toV2Address()),
+    repaymentAddress: toAddress(repaymentAddress),
   });
 }
 
@@ -424,7 +475,7 @@ export function createTokenAccountsInstruction(
 ): SvmSpokeClient.CreateTokenAccountsInstruction {
   return SvmSpokeClient.getCreateTokenAccountsInstruction({
     signer: relayer,
-    mint: mint.toV2Address(),
+    mint: toAddress(mint),
   });
 }
 
@@ -469,7 +520,7 @@ export const createFillInstruction = async (
       tokenProgram: fillInput.tokenProgram,
     });
 
-  const createFillIx = await SvmSpokeClient.getFillRelayInstruction(fillInput);
+  const createFillIx = SvmSpokeClient.getFillRelayInstruction(fillInput);
 
   return pipe(
     await createDefaultTransaction(solanaClient, signer),
@@ -519,7 +570,7 @@ export const createDepositInstruction = async (
       programAddress: mintInfo.programAddress,
     }
   );
-  const depositIx = await SvmSpokeClient.getDepositInstruction(depositInput);
+  const depositIx = SvmSpokeClient.getDepositInstruction(depositInput);
   return pipe(
     await createDefaultTransaction(solanaClient, signer),
     (tx) =>
@@ -541,7 +592,7 @@ export const createRequestSlowFillInstruction = async (
   solanaClient: SVMProvider,
   depositInput: SvmSpokeClient.RequestSlowFillInput
 ) => {
-  const requestSlowFillIx = await SvmSpokeClient.getRequestSlowFillInstruction(depositInput);
+  const requestSlowFillIx = SvmSpokeClient.getRequestSlowFillInstruction(depositInput);
 
   return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
     appendTransactionMessageInstruction(requestSlowFillIx, tx)
@@ -560,7 +611,7 @@ export const createCloseFillPdaInstruction = async (
   solanaClient: SVMProvider,
   fillStatusPda: Address
 ) => {
-  const closeFillPdaIx = await SvmSpokeClient.getCloseFillPdaInstruction({
+  const closeFillPdaIx = SvmSpokeClient.getCloseFillPdaInstruction({
     signer,
     state: await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
     fillStatus: fillStatusPda,
@@ -574,13 +625,10 @@ export async function getAssociatedTokenAddress(
   mint: SvmAddress,
   tokenProgramId: Address<string> = TOKEN_PROGRAM_ADDRESS
 ): Promise<Address<string>> {
+  const encoder = getAddressEncoder();
   const [associatedToken] = await getProgramDerivedAddress({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    seeds: [
-      new Uint8Array(owner.toBuffer()),
-      new Uint8Array(SvmAddress.from(tokenProgramId).toBuffer()),
-      new Uint8Array(mint.toBuffer()),
-    ],
+    seeds: [encoder.encode(toAddress(owner)), encoder.encode(tokenProgramId), encoder.encode(toAddress(mint))],
   });
   return associatedToken;
 }
@@ -591,14 +639,15 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   const uint32Encoder = getU32Encoder();
 
   assert(relayData.message.startsWith("0x"), "Message must be a hex string");
+  const encodeAddress = (data: SvmAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
 
   const contentToHash = Buffer.concat([
-    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())),
-    arrayify(hexZeroPad(hexlify(relayData.inputAmount), 32)),
+    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()))),
     arrayify(hexZeroPad(hexlify(relayData.depositId), 32)),
@@ -706,7 +755,7 @@ export async function getDepositDelegatePda(
     inputToken: Address<string>;
     outputToken: Address<string>;
     inputAmount: bigint;
-    outputAmount: ReadonlyUint8Array;
+    outputAmount: bigint;
     destinationChainId: bigint;
     exclusiveRelayer: Address<string>;
     quoteTimestamp: bigint;
@@ -726,7 +775,7 @@ export async function getDepositDelegatePda(
     Uint8Array.from(addrEnc.encode(depositData.inputToken)),
     Uint8Array.from(addrEnc.encode(depositData.outputToken)),
     Uint8Array.from(u64.encode(depositData.inputAmount)),
-    Uint8Array.from(depositData.outputAmount),
+    Uint8Array.from(u64.encode(depositData.outputAmount)),
     Uint8Array.from(u64.encode(depositData.destinationChainId)),
     Uint8Array.from(addrEnc.encode(depositData.exclusiveRelayer)),
     Uint8Array.from(u32.encode(depositData.quoteTimestamp)),
@@ -756,7 +805,7 @@ export async function getDepositNowDelegatePda(
     inputToken: Address<string>;
     outputToken: Address<string>;
     inputAmount: bigint;
-    outputAmount: ReadonlyUint8Array;
+    outputAmount: bigint;
     destinationChainId: bigint;
     exclusiveRelayer: Address<string>;
     fillDeadlineOffset: bigint;
@@ -775,7 +824,7 @@ export async function getDepositNowDelegatePda(
     Uint8Array.from(addrEnc.encode(depositData.inputToken)),
     Uint8Array.from(addrEnc.encode(depositData.outputToken)),
     Uint8Array.from(u64.encode(depositData.inputAmount)),
-    Uint8Array.from(depositData.outputAmount),
+    Uint8Array.from(u64.encode(depositData.outputAmount)),
     Uint8Array.from(u64.encode(depositData.destinationChainId)),
     Uint8Array.from(addrEnc.encode(depositData.exclusiveRelayer)),
     Uint8Array.from(u32.encode(depositData.fillDeadlineOffset)),

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, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
+import { BigNumber, EvmAddress, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -42,6 +42,13 @@ export async function isDevnet(rpc: SVMProvider): Promise<boolean> {
   return genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
 }
 
+/**
+ * Small utility to convert an Address to a Solana Kit branded type.
+ */
+export function toAddress(address: EvmAddress | SvmAddress): Address<string> {
+  return address.toBase58() as Address<string>;
+}
+
 /**
  * Parses event data from a transaction.
  */
@@ -273,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.
@@ -304,19 +311,3 @@ export const createDefaultTransaction = async (rpcClient: SVMProvider, signer: T
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)
   );
 };
-
-/**
- * Convert a bigint (0 ≤ n < 2^256) to a 32-byte Uint8Array (big-endian).
- */
-export function bigintToU8a32(n: bigint): Uint8Array {
-  if (n < BigInt(0) || n > ethers.constants.MaxUint256.toBigInt()) {
-    throw new RangeError("Value must fit in 256 bits");
-  }
-  const hexPadded = ethers.utils.hexZeroPad("0x" + n.toString(16), 32);
-  return ethers.utils.arrayify(hexPadded);
-}
-
-export const bigToU8a32 = (bn: bigint | BigNumber) =>
-  bigintToU8a32(typeof bn === "bigint" ? bn : BigInt(bn.toString()));
-
-export const numberToU8a32 = (n: number) => bigintToU8a32(BigInt(n));

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;