@across-protocol/sdk 4.1.46-beta.0 → 4.1.46-beta.2

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

@@ -146,6 +146,13 @@ export function _buildPoolRebalanceRoot(
     const repaymentChainId = Number(_repaymentChainId);
     Object.entries(fillsForChain).forEach(
       ([l2TokenAddress, { realizedLpFees: totalRealizedLpFee, totalRefundAmount }]) => {
+        // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
+        // there are no relevant L1 running balances.
+        if (
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(l2TokenAddress, repaymentChainId, mainnetBundleEndBlock)
+        ) {
+          return;
+        }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
           l2TokenAddress,
           repaymentChainId,
@@ -215,7 +222,24 @@ export function _buildPoolRebalanceRoot(
   Object.entries(bundleV3Deposits).forEach(([, depositsForChain]) => {
     Object.entries(depositsForChain).forEach(([, deposits]) => {
       deposits.forEach((deposit) => {
-        updateRunningBalanceForDeposit(runningBalances, clients.hubPoolClient, deposit, deposit.inputAmount.mul(-1));
+        // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
+        // there are no relevant L1 running balances.
+        if (
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
+            deposit.inputToken,
+            deposit.originChainId,
+            mainnetBundleEndBlock
+          )
+        ) {
+          return;
+        }
+        updateRunningBalanceForDeposit(
+          runningBalances,
+          clients.hubPoolClient,
+          deposit,
+          deposit.inputAmount.mul(-1),
+          mainnetBundleEndBlock
+        );
       });
     });
   });
@@ -229,6 +253,17 @@ export function _buildPoolRebalanceRoot(
     const originChainId = Number(_originChainId);
     Object.entries(depositsForChain).forEach(([inputToken, deposits]) => {
       deposits.forEach((deposit) => {
+        // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
+        // there are no relevant L1 running balances.
+        if (
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
+            deposit.inputToken,
+            deposit.originChainId,
+            mainnetBundleEndBlock
+          )
+        ) {
+          return;
+        }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
           inputToken,
           originChainId,

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

@@ -1,124 +1,118 @@
 import _ from "lodash";
+import assert from "assert";
 import { providers } from "ethers";
-import { Deposit, DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
-import { getBlockRangeForChain, isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
+import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
+import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 
+/**
+ * @notice FillRepaymentInformation is a fill with additional properties required to determine where it can
+ * be repaid.
+ */
+type FillRepaymentInformation = Fill & { fromLiteChain: boolean };
+
+/**
+ * @notice Return repayment chain and repayment token for a fill, but does not verify if the returned
+ * repayment information is valid for the desired repayment address.
+ * @dev The passed in fill should be verified first via verifyFillRepayment().
+ * @param fill The fill to get the repayment information for.
+ * @return The chain to send the refund to and the token to use for the refund.
+ */
 export function getRefundInformationFromFill(
-  fill: Fill,
+  relayData: FillRepaymentInformation,
   hubPoolClient: HubPoolClient,
-  blockRangesForChains: number[][],
-  chainIdListForBundleEvaluationBlockNumbers: number[],
-  fromLiteChain: boolean
+  bundleEndBlockForMainnet: number
 ): {
   chainToSendRefundTo: number;
   repaymentToken: string;
 } {
-  // Handle slow relay where repaymentChainId = 0. Slow relays always pay recipient on destination chain.
-  // So, save the slow fill under the destination chain, and save the fast fill under its repayment chain.
-  let chainToSendRefundTo = isSlowFill(fill) ? fill.destinationChainId : fill.repaymentChainId;
-  // If the fill is for a deposit originating from the lite chain, the repayment chain is the origin chain
-  // regardless of whether it is a slow or fast fill (we ignore slow fills but this is for posterity).
-  // @note fill.repaymentChainId should already be set to originChainId but reset it to be safe.
-  if (fromLiteChain) {
-    chainToSendRefundTo = fill.originChainId;
+  const chainToSendRefundTo = _getRepaymentChainId(relayData, hubPoolClient, bundleEndBlockForMainnet);
+  if (chainToSendRefundTo === relayData.originChainId) {
+    return {
+      chainToSendRefundTo,
+      repaymentToken: relayData.inputToken,
+    };
   }
 
-  // Save fill data and associate with repayment chain and L2 token refund should be denominated in.
-  const endBlockForMainnet = getBlockRangeForChain(
-    blockRangesForChains,
-    hubPoolClient.chainId,
-    chainIdListForBundleEvaluationBlockNumbers
-  )[1];
-
+  // Now figure out the equivalent L2 token for the repayment token. If the inputToken doesn't have a
+  // PoolRebalanceRoute, then the repayment chain would have been the originChainId after the getRepaymentChainId()
+  // call and we would have returned already, so the following call should always succeed.
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-    fill.inputToken,
-    fill.originChainId,
-    endBlockForMainnet
+    relayData.inputToken,
+    relayData.originChainId,
+    bundleEndBlockForMainnet
   );
 
   const repaymentToken = hubPoolClient.getL2TokenForL1TokenAtBlock(
     l1TokenCounterpart,
     chainToSendRefundTo,
-    endBlockForMainnet
+    bundleEndBlockForMainnet
   );
   return {
     chainToSendRefundTo,
     repaymentToken,
   };
 }
-
-export function getRepaymentChainId(fill: Fill, matchedDeposit: Deposit): number {
-  // Lite chain deposits force repayment on origin chain.
-  return matchedDeposit.fromLiteChain ? matchedDeposit.originChainId : fill.repaymentChainId;
-}
-
-export function forceDestinationRepayment(
-  repaymentChainId: number,
-  matchedDeposit: Deposit & { quoteBlockNumber: number },
-  hubPoolClient: HubPoolClient
-): boolean {
-  if (!matchedDeposit.fromLiteChain) {
-    try {
-      const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-        matchedDeposit.inputToken,
-        matchedDeposit.originChainId,
-        matchedDeposit.quoteBlockNumber
-      );
-      hubPoolClient.getL2TokenForL1TokenAtBlock(l1TokenCounterpart, repaymentChainId, matchedDeposit.quoteBlockNumber);
-      // Repayment token could be found, this is a valid repayment chain.
-      return false;
-    } catch {
-      // Repayment token doesn't exist on repayment chain via PoolRebalanceRoutes, impossible to repay filler there.
-      return true;
-    }
-  } else {
-    return false;
-  }
-}
-
-// Verify that a fill sent to an EVM chain has a 20 byte address. If the fill does not, then attempt
-// to repay the `msg.sender` of the relay transaction. Otherwise, return undefined.
+/**
+ * @notice Verifies that the fill can be repaid. If the repayment address is not
+ * valid for the requested repayment chain, then this function will attempt to change the fill's repayment chain
+ * to the destination chain and its repayment address to the  msg.sender and if this is possible,
+ * return the fill. Otherwise, return undefined.
+ * @param _fill Fill with a requested repayment chain and address
+ * @return Fill with the applied repayment chain (depends on the validity of the requested repayment address)
+ * and applied repayment address, or undefined if the applied repayment address is not valid for the
+ * applied repayment chain.
+ */
 export async function verifyFillRepayment(
   _fill: FillWithBlock,
   destinationChainProvider: providers.Provider,
   matchedDeposit: DepositWithBlock,
-  hubPoolClient: HubPoolClient
+  hubPoolClient: HubPoolClient,
+  bundleEndBlockForMainnet: number
 ): Promise<FillWithBlock | undefined> {
-  const fill = _.cloneDeep(_fill);
+  const fill = {
+    ..._.cloneDeep(_fill),
+    fromLiteChain: matchedDeposit.fromLiteChain,
+  };
 
   // Slow fills don't result in repayments so they're always valid.
   if (isSlowFill(fill)) {
     return fill;
   }
 
-  let repaymentChainId = getRepaymentChainId(fill, matchedDeposit);
-
-  // If repayment chain doesn't have a Pool Rebalance Route for the input token, then change the repayment
-  // chain to the destination chain.
-  if (forceDestinationRepayment(repaymentChainId, matchedDeposit, hubPoolClient)) {
-    repaymentChainId = fill.destinationChainId;
-  }
+  let repaymentChainId = _getRepaymentChainId(fill, hubPoolClient, bundleEndBlockForMainnet);
 
-  if (!isValidEvmAddress(fill.relayer)) {
+  // Repayments will always go to the fill.relayer address so check if its a valid EVM address. If its not, attempt
+  // to change it to the msg.sender of the FilledRelay.
+  if (_repaymentAddressNeedsToBeOverwritten(fill)) {
     // TODO: Handle case where fill was sent on non-EVM chain, in which case the following call would fail
     // or return something unexpected. We'd want to return undefined here.
-    const fillTransaction = await destinationChainProvider.getTransaction(fill.transactionHash);
+    const fillTransaction = await destinationChainProvider.getTransaction(fill.txnRef);
     const destinationRelayer = fillTransaction?.from;
     // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
     if (!isDefined(destinationRelayer) || !isValidEvmAddress(destinationRelayer)) {
       return undefined;
     }
-    if (!matchedDeposit.fromLiteChain) {
+    // If we can switch the repayment chain to the destination chain, then do so. We should only switch if the
+    // destination chain has a valid repayment token that is equivalent to the deposited input token. This would
+    // also be the same mapping as the repayment token on the repayment chain.
+    if (
+      !matchedDeposit.fromLiteChain &&
+      hubPoolClient.areTokensEquivalent(fill.inputToken, fill.originChainId, fill.outputToken, fill.destinationChainId)
+    ) {
       repaymentChainId = fill.destinationChainId;
-    } else {
-      // We can't switch repayment chain for a lite chain deposit so just check whether the repayment chain,
-      // which should be the origin chain, is an EVM chain.
+    }
+    // If we can't switch the chain, then we need to verify that the msg.sender is a valid address on the repayment chain.
+    // Because we already checked that the `destinationRelayer` was a valid EVM address above, we only need to check
+    // that the repayment chain is an EVM chain.
+    else {
       if (!chainIsEvm(repaymentChainId)) {
         return undefined;
       }
     }
     fill.relayer = destinationRelayer;
+
+    // @todo: If chainIsSvm:
   }
 
   // Repayment address is now valid and repayment chain is either origin chain for lite chain or the destination
@@ -126,3 +120,69 @@ export async function verifyFillRepayment(
   fill.repaymentChainId = repaymentChainId;
   return fill;
 }
+
+function _getRepaymentChainId(
+  relayData: FillRepaymentInformation,
+  hubPoolClient: HubPoolClient,
+  bundleEndBlockForMainnet: number
+): number {
+  if (relayData.fromLiteChain) {
+    assert(!isSlowFill(relayData), "getRepaymentChainId: fromLiteChain and slow fill are mutually exclusive");
+    return relayData.originChainId;
+  }
+
+  // Handle slow relay where FilledRelay.repaymentChainId = 0, as hardcoded in the SpokePool contract.
+  // Slow relays always pay recipient on destination chain.
+  if (isSlowFill(relayData)) {
+    return relayData.destinationChainId;
+  }
+
+  // Repayment chain is valid if the input token and repayment chain are mapped to the same PoolRebalanceRoute.
+  const repaymentTokenIsValid = _repaymentChainTokenIsValid(relayData, hubPoolClient, bundleEndBlockForMainnet);
+  if (repaymentTokenIsValid) {
+    return relayData.repaymentChainId;
+  }
+
+  // If repayment chain is not valid, default to origin chain since we always know the input token can be refunded.
+  return relayData.originChainId;
+}
+
+function _repaymentChainTokenIsValid(
+  relayData: FillRepaymentInformation,
+  hubPoolClient: HubPoolClient,
+  bundleEndBlockForMainnet: number
+): boolean {
+  if (
+    !hubPoolClient.l2TokenHasPoolRebalanceRoute(relayData.inputToken, relayData.originChainId, bundleEndBlockForMainnet)
+  ) {
+    return false;
+  }
+  const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
+    relayData.inputToken,
+    relayData.originChainId,
+    bundleEndBlockForMainnet
+  );
+  if (
+    !hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
+      l1TokenCounterpart,
+      relayData.repaymentChainId,
+      bundleEndBlockForMainnet
+    )
+  ) {
+    return false;
+  }
+  return true;
+}
+
+function _repaymentAddressNeedsToBeOverwritten(fill: Fill): boolean {
+  // Slow fills don't result in repayments so they're always valid.
+  if (isSlowFill(fill)) {
+    return false;
+  }
+
+  // @todo add Solana logic here:
+  // - i.e. If chainIsSvm && !isValidSvmAddress(fill.relayer) then return false
+  //        If chainIsEvm && !isValidEvmAddress(fill.relayer) then return false
+  //        If chainIsEvm && isValidEvmAddress(fill.relayer) then return true
+  return !isValidEvmAddress(fill.relayer);
+}

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

@@ -163,12 +163,13 @@ export function updateRunningBalanceForDeposit(
   runningBalances: RunningBalances,
   hubPoolClient: HubPoolClient,
   deposit: V3DepositWithBlock,
-  updateAmount: BigNumber
+  updateAmount: BigNumber,
+  mainnetBundleEndBlock: number
 ): void {
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
     deposit.inputToken,
     deposit.originChainId,
-    deposit.quoteBlockNumber
+    mainnetBundleEndBlock
   );
   updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart, updateAmount);
 }

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

@@ -48,11 +48,15 @@ const V3RelayDataSS = {
   message: string(),
 };
 
-const SortableEventSS = {
+export const SortableEventSS = {
   blockNumber: number(),
-  transactionIndex: number(),
   logIndex: number(),
-  transactionHash: string(),
+
+  txnRef: optional(string()),
+  txnIndex: optional(number()),
+
+  transactionHash: optional(string()),
+  transactionIndex: optional(number()),
 };
 
 const V3DepositSS = {

package/src/clients/HubPoolClient.ts

@@ -2,7 +2,7 @@ import assert from "assert";
 import { Contract, EventFilter } from "ethers";
 import _ from "lodash";
 import winston from "winston";
-import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL, ZERO_ADDRESS } from "../constants";
+import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL, TOKEN_SYMBOLS_MAP, ZERO_ADDRESS } from "../constants";
 import {
   CachingMechanismInterface,
   CancelledRootBundle,
@@ -44,6 +44,9 @@ import {
   getTokenInfo,
   getUsdcSymbol,
   compareAddressesSimple,
+  chainIsSvm,
+  getDeployedAddress,
+  SvmAddress,
 } from "../utils";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "./AcrossConfigStoreClient/AcrossConfigStoreClient";
 import { BaseAbstractClient, isUpdateFailureReason, UpdateFailureReason } from "./BaseAbstractClient";
@@ -230,40 +233,41 @@ export class HubPoolClient extends BaseAbstractClient {
     return sortEventsDescending(l2Tokens)[0].l1Token;
   }
 
-  /**
-   * Returns the L1 token that should be used for an L2 Bridge event. This function is
-   * designed to be used by the caller to associate the L2 token with its mapped L1 token
-   * at the HubPool equivalent block number of the L2 event.
-   * @param deposit Deposit event
-   * @param returns string L1 token counterpart for Deposit
-   */
-  getL1TokenForDeposit(deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">): string {
+  protected getL1TokenForDeposit(
+    deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
+  ): string {
     // L1-->L2 token mappings are set via PoolRebalanceRoutes which occur on mainnet,
     // so we use the latest token mapping. This way if a very old deposit is filled, the relayer can use the
     // latest L2 token mapping to find the L1 token counterpart.
     return this.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
   }
 
-  /**
-   * Returns the L2 token that should be used as a counterpart to a deposit event. For example, the caller
-   * might want to know what the refund token will be on l2ChainId for the deposit event.
-   * @param l2ChainId Chain where caller wants to get L2 token counterpart for
-   * @param event Deposit event
-   * @returns string L2 token counterpart on l2ChainId
-   */
-  getL2TokenForDeposit(
-    deposit: Pick<DepositWithBlock, "originChainId" | "destinationChainId" | "inputToken" | "quoteBlockNumber">,
-    l2ChainId = deposit.destinationChainId
-  ): string {
-    const l1Token = this.getL1TokenForDeposit(deposit);
-    // Use the latest hub block number to find the L2 token counterpart.
-    return this.getL2TokenForL1TokenAtBlock(l1Token, l2ChainId, deposit.quoteBlockNumber);
-  }
-
   l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean {
     return this.l1TokensToDestinationTokens?.[l1Token]?.[destinationChainId] != undefined;
   }
 
+  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
+    // Find the last mapping published before the target block.
+    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
+      this.l1TokensToDestinationTokensWithBlock?.[l1Token]?.[destinationChainId] ?? []
+    ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
+    return l2Token !== undefined;
+  }
+
+  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestBlockSearched): boolean {
+    return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
+      return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
+        return setPoolRebalanceRouteEvents.some((e) => {
+          return (
+            e.blockNumber <= hubPoolBlock &&
+            compareAddressesSimple(e.l2Token, l2Token) &&
+            Number(_l2ChainId) === l2ChainId
+          );
+        });
+      });
+    });
+  }
+
   /**
    * @dev If tokenAddress + chain do not exist in TOKEN_SYMBOLS_MAP then this will throw.
    * @param tokenAddress Token address on `chain`
@@ -506,21 +510,23 @@ export class HubPoolClient extends BaseAbstractClient {
     chainIdB: number,
     hubPoolBlock = this.latestBlockSearched
   ): boolean {
-    try {
-      // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
-      const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
-      const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
-      if (l1TokenA !== l1TokenB) {
-        return false;
-      }
-
-      // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
-      const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
-      const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
-      return tokenA === _tokenA && tokenB === _tokenB;
-    } catch {
-      return false; // One or both input tokens were not recognised.
+    if (
+      !this.l2TokenHasPoolRebalanceRoute(tokenA, chainIdA, hubPoolBlock) ||
+      !this.l2TokenHasPoolRebalanceRoute(tokenB, chainIdB, hubPoolBlock)
+    ) {
+      return false;
     }
+    // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
+    const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
+    const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
+    if (l1TokenA !== l1TokenB) {
+      return false;
+    }
+
+    // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
+    const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
+    const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
+    return tokenA === _tokenA && tokenB === _tokenB;
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {
@@ -878,39 +884,73 @@ export class HubPoolClient extends BaseAbstractClient {
     if (eventsToQuery.includes("CrossChainContractsSet")) {
       for (const event of events["CrossChainContractsSet"]) {
         const args = spreadEventWithBlockNumber(event) as CrossChainContractsSet;
-        assign(
-          this.crossChainContracts,
-          [args.l2ChainId],
-          [
-            {
-              spokePool: args.spokePool,
-              blockNumber: args.blockNumber,
-              transactionIndex: args.transactionIndex,
-              logIndex: args.logIndex,
-            },
-          ]
-        );
+        const dataToAdd: CrossChainContractsSet = {
+          spokePool: args.spokePool,
+          blockNumber: args.blockNumber,
+          txnRef: args.txnRef,
+          logIndex: args.logIndex,
+          txnIndex: args.txnIndex,
+          l2ChainId: args.l2ChainId,
+        };
+        // If the chain is SVM then our `args.spokePool` will be set to the `solanaSpokePool.toAddressUnchecked()` in the
+        // hubpool event because our hub deals with `address` types and not byte32. Therefore, we should confirm that the
+        // `args.spokePool` is the same as the `solanaSpokePool.toAddressUnchecked()`. We can derive the `solanaSpokePool`
+        // address by using the `getDeployedAddress` function.
+        if (chainIsSvm(args.l2ChainId)) {
+          const solanaSpokePool = getDeployedAddress("SvmSpoke", args.l2ChainId);
+          if (!solanaSpokePool) {
+            throw new Error(`SVM spoke pool not found for chain ${args.l2ChainId}`);
+          }
+          const truncatedAddress = SvmAddress.from(solanaSpokePool).toEvmAddress();
+          // Verify the event address matches our expected truncated address
+          if (args.spokePool.toLowerCase() !== truncatedAddress.toLowerCase()) {
+            throw new Error(
+              `SVM spoke pool address mismatch for chain ${args.l2ChainId}. ` +
+                `Expected ${truncatedAddress}, got ${args.spokePool}`
+            );
+          }
+          // Store the full Solana address
+          dataToAdd.spokePool = SvmAddress.from(solanaSpokePool).toBytes32();
+        }
+        assign(this.crossChainContracts, [args.l2ChainId], [dataToAdd]);
       }
     }
 
     if (eventsToQuery.includes("SetPoolRebalanceRoute")) {
       for (const event of events["SetPoolRebalanceRoute"]) {
         const args = spreadEventWithBlockNumber(event) as SetPoolRebalanceRoot;
+
+        // 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 = args.destinationToken;
+        if (chainIsSvm(args.destinationChainId)) {
+          const usdcTokenSol = TOKEN_SYMBOLS_MAP.USDC.addresses[args.destinationChainId];
+          const truncatedAddress = SvmAddress.from(usdcTokenSol).toEvmAddress();
+          if (destinationToken.toLowerCase() !== truncatedAddress.toLowerCase()) {
+            throw new Error(
+              `SVM USDC address mismatch for chain ${args.destinationChainId}. ` +
+                `Expected ${truncatedAddress}, got ${destinationToken}`
+            );
+          }
+          destinationToken = SvmAddress.from(usdcTokenSol).toBytes32();
+        }
+
         // If the destination token is set to the zero address in an event, then this means Across should no longer
         // rebalance to this chain.
-        if (args.destinationToken !== ZERO_ADDRESS) {
-          assign(this.l1TokensToDestinationTokens, [args.l1Token, args.destinationChainId], args.destinationToken);
+        if (destinationToken !== ZERO_ADDRESS) {
+          assign(this.l1TokensToDestinationTokens, [args.l1Token, args.destinationChainId], destinationToken);
           assign(
             this.l1TokensToDestinationTokensWithBlock,
             [args.l1Token, args.destinationChainId],
             [
               {
                 l1Token: args.l1Token,
-                l2Token: args.destinationToken,
+                l2Token: destinationToken,
                 blockNumber: args.blockNumber,
-                transactionIndex: args.transactionIndex,
+                txnIndex: args.txnIndex,
                 logIndex: args.logIndex,
-                transactionHash: args.transactionHash,
+                txnRef: args.txnRef,
               },
             ]
           );
@@ -956,12 +996,7 @@ export class HubPoolClient extends BaseAbstractClient {
       this.proposedRootBundles.push(
         ...events["ProposeRootBundle"]
           .filter((event) => !this.configOverride.ignoredHubProposedBundles.includes(event.blockNumber))
-          .map((event) => {
-            return {
-              ...spreadEventWithBlockNumber(event),
-              transactionHash: event.transactionHash,
-            } as ProposedRootBundle;
-          })
+          .map((event) => spreadEventWithBlockNumber(event) as ProposedRootBundle)
       );
     }
 

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -19,6 +19,7 @@ import {
 } from "../../utils";
 import {
   EventSearchConfig,
+  logToSortableEvent,
   paginatedEventQuery,
   sortEventsAscendingInPlace,
   spreadEventWithBlockNumber,
@@ -127,7 +128,7 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     }
 
     // Sort all events to ensure they are stored in a consistent order.
-    events.forEach((events) => sortEventsAscendingInPlace(events));
+    events.forEach((events) => sortEventsAscendingInPlace(events.map(logToSortableEvent)));
 
     return {
       success: true,