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

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

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";
@@ -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/BundleDataClient/BundleDataClient.ts

@@ -676,15 +676,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);

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

@@ -155,7 +155,7 @@ export function _buildPoolRebalanceRoot(
         // there are no relevant L1 running balances.
         if (
           !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
-            toAddressType(l2TokenAddress),
+            toAddressType(l2TokenAddress, repaymentChainId),
             repaymentChainId,
             mainnetBundleEndBlock
           )
@@ -164,7 +164,7 @@ export function _buildPoolRebalanceRoot(
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(l2TokenAddress),
+          toAddressType(l2TokenAddress, repaymentChainId),
           repaymentChainId,
           mainnetBundleEndBlock
         );
@@ -187,7 +187,7 @@ export function _buildPoolRebalanceRoot(
     Object.entries(depositsForChain).forEach(([outputToken, deposits]) => {
       deposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(outputToken),
+          toAddressType(outputToken, destinationChainId),
           destinationChainId,
           mainnetBundleEndBlock
         );
@@ -216,7 +216,7 @@ export function _buildPoolRebalanceRoot(
     Object.entries(slowFilledDepositsForChain).forEach(([outputToken, slowFilledDeposits]) => {
       slowFilledDeposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(outputToken),
+          toAddressType(outputToken, destinationChainId),
           destinationChainId,
           mainnetBundleEndBlock
         );
@@ -286,7 +286,7 @@ export function _buildPoolRebalanceRoot(
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          toAddressType(inputToken),
+          toAddressType(inputToken, originChainId),
           originChainId,
           mainnetBundleEndBlock
         );

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

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

package/src/clients/HubPoolClient.ts

@@ -533,8 +533,8 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.l1Tokens.find((token) => token.address.eq(l1Token));
   }
 
-  getLpTokenInfoForL1Token(l1Token: string): LpToken | undefined {
-    return this.lpTokens[l1Token];
+  getLpTokenInfoForL1Token(l1Token: EvmAddress): LpToken | undefined {
+    return this.lpTokens[l1Token.toEvmAddress()];
   }
 
   areTokensEquivalent(
@@ -920,7 +920,7 @@ export class HubPoolClient extends BaseAbstractClient {
       for (const event of events["CrossChainContractsSet"]) {
         const args = spreadEventWithBlockNumber(event) as CrossChainContractsSet & { spokePool: string };
         const dataToAdd: CrossChainContractsSet = {
-          spokePool: toAddressType(args.spokePool),
+          spokePool: toAddressType(args.spokePool, this.chainId),
           blockNumber: args.blockNumber,
           txnRef: args.txnRef,
           logIndex: args.logIndex,
@@ -960,7 +960,7 @@ export class HubPoolClient extends BaseAbstractClient {
         // If the destination chain is SVM, then we need to convert the destination token to the Solana address.
         // This is because the HubPool contract only holds a truncated address for the USDC token and currently
         // only supports USDC as a destination token for Solana.
-        let destinationToken = toAddressType(args.destinationToken);
+        let destinationToken = toAddressType(args.destinationToken, this.chainId);
         if (chainIsSvm(args.destinationChainId)) {
           const usdcTokenSol = TOKEN_SYMBOLS_MAP.USDC.addresses[args.destinationChainId];
           const svmUsdc = SvmAddress.from(usdcTokenSol);
@@ -982,7 +982,7 @@ export class HubPoolClient extends BaseAbstractClient {
             [args.l1Token, args.destinationChainId],
             [
               {
-                l1Token: toAddressType(args.l1Token),
+                l1Token: toAddressType(args.l1Token, this.chainId),
                 l2Token: destinationToken,
                 blockNumber: args.blockNumber,
                 txnIndex: args.txnIndex,
@@ -1041,7 +1041,13 @@ export class HubPoolClient extends BaseAbstractClient {
       this.proposedRootBundles.push(
         ...events["ProposeRootBundle"]
           .filter((event) => !this.configOverride.ignoredHubProposedBundles.includes(event.blockNumber))
-          .map((event) => spreadEventWithBlockNumber(event) as ProposedRootBundle)
+          .map((_event) => {
+            const args = spreadEventWithBlockNumber(_event) as ProposedRootBundle & { proposer: string };
+            return {
+              ...args,
+              proposer: toAddressType(args.proposer, this.chainId),
+            };
+          })
       );
     }
 
@@ -1078,7 +1084,7 @@ export class HubPoolClient extends BaseAbstractClient {
         executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
         const executedRootBundleWithL1Tokens = {
           ...executedRootBundle,
-          l1Tokens: executedRootBundle.l1Tokens.map(toAddressType),
+          l1Tokens: executedRootBundle.l1Tokens.map(toAddressType, this.chainId),
         };
         this.executedRootBundles.push(executedRootBundleWithL1Tokens);
       }

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -195,11 +195,11 @@ export class EVMSpokePoolClient extends SpokePoolClient {
 
     deposit = {
       ...spreadEventWithBlockNumber(event),
-      inputToken: toAddressType(event.args.inputToken),
-      outputToken: toAddressType(event.args.outputToken),
-      depositor: toAddressType(event.args.depositor),
-      recipient: toAddressType(event.args.recipient),
-      exclusiveRelayer: toAddressType(event.args.exclusiveRelayer),
+      inputToken: toAddressType(event.args.inputToken, this.chainId),
+      outputToken: toAddressType(event.args.outputToken, event.args.destinationChainId),
+      depositor: toAddressType(event.args.depositor, this.chainId),
+      recipient: toAddressType(event.args.recipient, event.args.destinationChainId),
+      exclusiveRelayer: toAddressType(event.args.exclusiveRelayer, event.args.destinationChainId),
       originChainId: this.chainId,
       quoteBlockNumber: await this.getBlockNumber(Number(event.args["quoteTimestamp"])),
       fromLiteChain: true, // To be updated immediately afterwards.

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -508,8 +508,8 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         };
         this.tokensBridged.push({
           ...event,
-          l2TokenAddress: toAddressType(event.l2TokenAddress),
-        } as TokensBridged);
+          l2TokenAddress: toAddressType(event.l2TokenAddress, this.chainId),
+        });
       }
     }
 
@@ -525,13 +525,13 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         };
         return {
           ...event,
-          depositor: toAddressType(event.depositor),
-          recipient: toAddressType(event.recipient),
-          inputToken: toAddressType(event.inputToken),
-          outputToken: toAddressType(event.outputToken),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
+          depositor: toAddressType(event.depositor, this.chainId),
+          recipient: toAddressType(event.recipient, event.destinationChainId),
+          inputToken: toAddressType(event.inputToken, this.chainId),
+          outputToken: toAddressType(event.outputToken, event.destinationChainId),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer, event.destinationChainId),
         } as DepositWithBlock;
-      }) as DepositWithBlock[];
+      });
       if (depositEvents.length > 0) {
         this.log(
           "debug",
@@ -592,7 +592,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         const event = _event as SpeedUpWithBlock & { depositor: string; updatedRecipient: string };
         return {
           ...event,
-          depositor: toAddressType(event.depositor),
+          depositor: toAddressType(event.depositor, this.chainId),
           updatedRecipient: toAddressType(event.updatedRecipient),
         } as SpeedUpWithBlock;
       });
@@ -636,13 +636,13 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         };
         return {
           ...event,
-          depositor: toAddressType(event.depositor),
-          recipient: toAddressType(event.recipient),
-          inputToken: toAddressType(event.inputToken),
-          outputToken: toAddressType(event.outputToken),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
+          depositor: toAddressType(event.depositor, event.originChainId),
+          recipient: toAddressType(event.recipient, this.chainId),
+          inputToken: toAddressType(event.inputToken, event.originChainId),
+          outputToken: toAddressType(event.outputToken, this.chainId),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer, this.chainId),
         } as SlowFillRequestWithBlock;
-      }) as SlowFillRequestWithBlock[];
+      });
       for (const event of slowFillRequests) {
         const slowFillRequest = {
           ...event,
@@ -681,18 +681,18 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         };
         return {
           ...event,
-          depositor: toAddressType(event.depositor),
-          recipient: toAddressType(event.recipient),
-          inputToken: toAddressType(event.inputToken),
-          outputToken: toAddressType(event.outputToken),
-          exclusiveRelayer: toAddressType(event.exclusiveRelayer),
-          relayer: toAddressType(event.relayer),
+          depositor: toAddressType(event.depositor, event.originChainId),
+          recipient: toAddressType(event.recipient, this.chainId),
+          inputToken: toAddressType(event.inputToken, event.originChainId),
+          outputToken: toAddressType(event.outputToken, this.chainId),
+          exclusiveRelayer: toAddressType(event.exclusiveRelayer, this.chainId),
+          relayer: toAddressType(event.relayer, this.chainId),
           relayExecutionInfo: {
             ...event.relayExecutionInfo,
-            updatedRecipient: toAddressType(event.relayExecutionInfo.updatedRecipient),
+            updatedRecipient: toAddressType(event.relayExecutionInfo.updatedRecipient, this.chainId),
           },
         } as FillWithBlock;
-      }) as FillWithBlock[];
+      });
 
       if (fillEvents.length > 0) {
         this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
@@ -728,8 +728,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     });
 
     if (eventsToQuery.includes("EnabledDepositRoute")) {
-      const enableDepositsEvents = (queryResults[eventsToQuery.indexOf("EnabledDepositRoute")] ??
-        []) as EnabledDepositRouteWithBlock[];
+      const enableDepositsEvents = queryResults[
+        eventsToQuery.indexOf("EnabledDepositRoute")
+      ] as EnabledDepositRouteWithBlock[];
 
       for (const event of enableDepositsEvents) {
         assign(this.depositRoutes, [event.originToken, event.destinationChainId], event.enabled);
@@ -737,16 +738,18 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     }
 
     if (eventsToQuery.includes("RelayedRootBundle")) {
-      const relayedRootBundleEvents = (queryResults[eventsToQuery.indexOf("RelayedRootBundle")] ??
-        []) as RootBundleRelayWithBlock[];
+      const relayedRootBundleEvents = queryResults[
+        eventsToQuery.indexOf("RelayedRootBundle")
+      ] as RootBundleRelayWithBlock[];
       for (const event of relayedRootBundleEvents) {
         this.rootBundleRelays.push(event);
       }
     }
 
     if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
-      const refundEvents = (queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")] ??
-        []) as RelayerRefundExecutionWithBlock[];
+      const refundEvents = queryResults[
+        eventsToQuery.indexOf("ExecutedRelayerRefundRoot")
+      ] as RelayerRefundExecutionWithBlock[];
       for (const event of refundEvents) {
         this.relayerRefundExecutions.push(event);
       }

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -67,7 +67,9 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
 
   getDestinationTokenForDeposit(deposit: DepositWithBlock): Address {
     const override = this.destinationTokenForChainOverride[deposit.originChainId];
-    return isDefined(override) ? toAddressType(override) : super.getDestinationTokenForDeposit(deposit);
+    return isDefined(override)
+      ? toAddressType(override, deposit.destinationChainId)
+      : super.getDestinationTokenForDeposit(deposit);
   }
 
   setLatestBlockNumber(blockNumber: number): void {

package/src/interfaces/HubPool.ts

@@ -27,7 +27,7 @@ export interface ProposedRootBundle extends SortableEvent {
   poolRebalanceRoot: string;
   relayerRefundRoot: string;
   slowRelayRoot: string;
-  proposer: string;
+  proposer: EvmAddress;
 }
 
 export type RealizedLpFee = {

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -74,7 +74,7 @@ export class QueryBase implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId)),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -124,7 +124,7 @@ export class QueryBase implements QueryInterface {
    */
   getUnsignedTxFromDeposit(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId))
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
   }
@@ -137,7 +137,7 @@ export class QueryBase implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId))
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
     const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
@@ -154,7 +154,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(unsignedTx.chainId)),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(unsignedTx.chainId), unsignedTx.chainId),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;