@across-protocol/sdk 4.1.45 → 4.1.46-beta.1

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,GAAG,SAAS,CAWrH;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa/E"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,GAAG,SAAS,CAWrH;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAe/E"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.1.45",
+  "version": "4.1.46-beta.1",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -24,7 +24,6 @@ import {
   DisabledChainsUpdate,
   GlobalConfigUpdate,
   LiteChainsIdListUpdate,
-  Log,
   ParsedTokenConfig,
   RateModelUpdate,
   RouteRateModelUpdate,
@@ -43,8 +42,8 @@ type ConfigStoreUpdateSuccess = {
   chainId: number;
   searchEndBlock: number;
   events: {
-    updatedTokenConfigEvents: Log[];
-    updatedGlobalConfigEvents: Log[];
+    updatedTokenConfigEvents: SortableEvent[];
+    updatedGlobalConfigEvents: SortableEvent[];
     globalConfigUpdateTimes: number[];
   };
 };
@@ -341,8 +340,13 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
       paginatedEventQuery(this.configStore, this.configStore.filters.UpdatedGlobalConfig(), searchConfig),
     ]);
 
+    const updatedTokenConfigSortableEvents = updatedTokenConfigEvents.map(spreadEventWithBlockNumber);
+    const updatedGlobalConfigSortableEvents = updatedGlobalConfigEvents.map(spreadEventWithBlockNumber);
+
     // Events *should* normally be received in ascending order, but explicitly enforce the ordering.
-    [updatedTokenConfigEvents, updatedGlobalConfigEvents].forEach((events) => sortEventsAscendingInPlace(events));
+    [updatedTokenConfigSortableEvents, updatedGlobalConfigSortableEvents].forEach((events) =>
+      sortEventsAscendingInPlace(events)
+    );
 
     const globalConfigUpdateTimes = (
       await Promise.all(updatedGlobalConfigEvents.map((event) => this.configStore.provider.getBlock(event.blockNumber)))
@@ -353,8 +357,8 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
       chainId,
       searchEndBlock: searchConfig.toBlock,
       events: {
-        updatedTokenConfigEvents,
-        updatedGlobalConfigEvents,
+        updatedTokenConfigEvents: updatedTokenConfigSortableEvents,
+        updatedGlobalConfigEvents: updatedGlobalConfigSortableEvents,
         globalConfigUpdateTimes,
       },
     };
@@ -380,13 +384,11 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     // Save new TokenConfig updates.
     for (const event of updatedTokenConfigEvents) {
       // If transaction hash is known to be invalid, skip it immediately to avoid creating extra logs.
-      if (KNOWN_INVALID_TOKEN_CONFIG_UPDATE_HASHES.includes(event.transactionHash.toLowerCase())) {
+      if (KNOWN_INVALID_TOKEN_CONFIG_UPDATE_HASHES.includes(event.txnRef.toLowerCase())) {
         continue;
       }
 
-      const args = {
-        ...(spreadEventWithBlockNumber(event) as TokenConfig),
-      };
+      const args = event as TokenConfig;
 
       try {
         const { rateModel, routeRateModel, spokeTargetBalances } = this.validateTokenConfigUpdate(args);
@@ -418,7 +420,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
           this.logger.debug({
             at: "ConfigStoreClient::update",
             message: `Skipping invalid historical update at block ${event.blockNumber}`,
-            transactionHash: event.transactionHash,
+            txnRef: event.txnRef,
           });
         }
         continue;
@@ -427,7 +429,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
 
     // Save new Global config updates.
     for (let i = 0; i < updatedGlobalConfigEvents.length; i++) {
-      const args = spreadEventWithBlockNumber(updatedGlobalConfigEvents[i]) as SortableEvent & {
+      const args = updatedGlobalConfigEvents[i] as SortableEvent & {
         key: string;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         value: any;
@@ -562,7 +564,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     rateModel: string | undefined;
     routeRateModel: RouteRateModelUpdate["routeRateModel"];
   } {
-    const { value, key, transactionHash } = args;
+    const { value, key, txnRef } = args;
     const parsedValue = parseJSONWithNumericString(value) as ParsedTokenConfig;
     const l1Token = key;
 
@@ -578,7 +580,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
       const rateModel = parsedValue.rateModel;
       assert(
         this.isValidRateModel(rateModel),
-        `Invalid rateModel UBar for ${l1Token} at transaction ${transactionHash}, ${JSON.stringify(rateModel)}`
+        `Invalid rateModel UBar for ${l1Token} at transaction ${txnRef}, ${JSON.stringify(rateModel)}`
       );
       rateModelForToken = JSON.stringify(rateModel);
 
@@ -601,7 +603,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
           Object.entries(parsedValue.routeRateModel).map(([path, routeRateModel]) => {
             assert(
               this.isValidRateModel(routeRateModel) &&
-                `Invalid routeRateModel UBar for ${path} for ${l1Token} at transaction ${transactionHash}, ${JSON.stringify(
+                `Invalid routeRateModel UBar for ${path} for ${l1Token} at transaction ${txnRef}, ${JSON.stringify(
                   routeRateModel
                 )}`
             );

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -237,13 +237,115 @@ export class BundleDataClient {
         {} as Record<number, Record<string, UnderlyingType>>
       );
 
+    const convertSortableEventFieldsIntoRequiredFields = <
+      T extends {
+        txnIndex?: number;
+        transactionIndex?: number;
+        txnRef?: string;
+        transactionHash?: string;
+      },
+    >(
+      data: T[]
+    ): Array<
+      Omit<T, "txnIndex" | "transactionIndex" | "txnRef" | "transactionHash"> & {
+        txnIndex: number;
+        txnRef: string;
+      }
+    > => {
+      return data.map((item) => {
+        // For txnIndex/transactionIndex: throw if both are defined or both are missing.
+        if (
+          (item.txnIndex !== undefined && item.transactionIndex !== undefined) ||
+          (item.txnIndex === undefined && item.transactionIndex === undefined)
+        ) {
+          throw new Error("Either txnIndex or transactionIndex must be defined, but not both.");
+        }
+
+        // For txnRef/transactionHash: throw if both are defined or both are missing.
+        if (
+          (item.txnRef !== undefined && item.transactionHash !== undefined) ||
+          (item.txnRef === undefined && item.transactionHash === undefined)
+        ) {
+          throw new Error("Either txnRef or transactionHash must be defined, but not both.");
+        }
+
+        // Destructure the fields we don't need anymore
+        const { txnIndex, transactionIndex, txnRef, transactionHash, ...rest } = item;
+
+        // Return a new object with normalized fields.
+        // The non-null assertion (!) is safe here because our conditions ensure that one of each pair is defined.
+        return {
+          ...rest,
+          txnIndex: txnIndex ?? transactionIndex!,
+          txnRef: txnRef ?? transactionHash!,
+        };
+      });
+    };
+
+    const convertEmbeddedSortableEventFieldsIntoRequiredFields = <
+      T extends {
+        txnIndex?: number;
+        transactionIndex?: number;
+        txnRef?: string;
+        transactionHash?: string;
+      },
+    >(
+      data: Record<string, Record<string, T[]>>
+    ) => {
+      return Object.fromEntries(
+        Object.entries(data).map(([chainId, tokenData]) => [
+          chainId,
+          Object.fromEntries(
+            Object.entries(tokenData).map(([token, data]) => [
+              token,
+              convertSortableEventFieldsIntoRequiredFields(data),
+            ])
+          ),
+        ])
+      );
+    };
+
     const data = persistedData[0].data;
+
+    // This section processes and transforms bundle data loaded from Arweave storage into the correct format:
+    // 1. Each field (bundleFillsV3, expiredDepositsToRefundV3, etc.) contains nested records keyed by chainId and token
+    // 2. The chainId keys are converted from strings to numbers using convertTypedStringRecordIntoNumericRecord
+    // 3. For arrays of events (fills, deposits, etc.), the transaction fields are normalized:
+    //    - txnIndex/transactionIndex -> txnIndex
+    //    - txnRef/transactionHash -> txnRef
+    //    This ensures consistent field names across all event objects
+    // 4. The data structure maintains all other fields like refunds, totalRefundAmount, and realizedLpFees
     const bundleData = {
-      bundleFillsV3: convertTypedStringRecordIntoNumericRecord(data.bundleFillsV3),
-      expiredDepositsToRefundV3: convertTypedStringRecordIntoNumericRecord(data.expiredDepositsToRefundV3),
-      bundleDepositsV3: convertTypedStringRecordIntoNumericRecord(data.bundleDepositsV3),
-      unexecutableSlowFills: convertTypedStringRecordIntoNumericRecord(data.unexecutableSlowFills),
-      bundleSlowFillsV3: convertTypedStringRecordIntoNumericRecord(data.bundleSlowFillsV3),
+      bundleFillsV3: convertTypedStringRecordIntoNumericRecord(
+        Object.fromEntries(
+          Object.entries(data.bundleFillsV3).map(([chainId, tokenData]) => [
+            chainId,
+            Object.fromEntries(
+              Object.entries(tokenData).map(([token, data]) => [
+                token,
+                {
+                  refunds: data.refunds,
+                  totalRefundAmount: data.totalRefundAmount,
+                  realizedLpFees: data.realizedLpFees,
+                  fills: convertSortableEventFieldsIntoRequiredFields(data.fills),
+                },
+              ])
+            ),
+          ])
+        )
+      ),
+      expiredDepositsToRefundV3: convertTypedStringRecordIntoNumericRecord(
+        convertEmbeddedSortableEventFieldsIntoRequiredFields(data.expiredDepositsToRefundV3)
+      ),
+      bundleDepositsV3: convertTypedStringRecordIntoNumericRecord(
+        convertEmbeddedSortableEventFieldsIntoRequiredFields(data.bundleDepositsV3)
+      ),
+      unexecutableSlowFills: convertTypedStringRecordIntoNumericRecord(
+        convertEmbeddedSortableEventFieldsIntoRequiredFields(data.unexecutableSlowFills)
+      ),
+      bundleSlowFillsV3: convertTypedStringRecordIntoNumericRecord(
+        convertEmbeddedSortableEventFieldsIntoRequiredFields(data.bundleSlowFillsV3)
+      ),
     };
     this.logger.debug({
       at: "BundleDataClient#loadPersistedDataFromArweave",

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

@@ -87,9 +87,7 @@ export async function verifyFillRepayment(
   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.
-
-    // @todo: If chainIsEvm:
-    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)) {

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,
@@ -43,8 +43,10 @@ import {
   toBN,
   getTokenInfo,
   getUsdcSymbol,
-  getL1TokenInfo,
   compareAddressesSimple,
+  chainIsSvm,
+  getDeployedAddress,
+  SvmAddress,
 } from "../utils";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "./AcrossConfigStoreClient/AcrossConfigStoreClient";
 import { BaseAbstractClient, isUpdateFailureReason, UpdateFailureReason } from "./BaseAbstractClient";
@@ -282,17 +284,6 @@ export class HubPoolClient extends BaseAbstractClient {
     return tokenInfo;
   }
 
-  /**
-   * @dev If tokenAddress + chain do not exist in TOKEN_SYMBOLS_MAP then this will throw.
-   * @dev if the token matched in TOKEN_SYMBOLS_MAP does not have an L1 token address then this will throw.
-   * @param tokenAddress Token address on `chain`
-   * @param chain Chain where the `tokenAddress` exists in TOKEN_SYMBOLS_MAP.
-   * @returns Token info for the given token address on the Hub chain including symbol and decimal and L1 address.
-   */
-  getL1TokenInfoForAddress(tokenAddress: string, chain: number): L1Token {
-    return getL1TokenInfo(tokenAddress, chain);
-  }
-
   /**
    * Resolve a given timestamp to a block number on the HubPool chain.
    * @param timestamp A single timestamp to be resolved to a block number on the HubPool chain.
@@ -512,17 +503,6 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.getTokenInfoForL1Token(l1TokenCounterpart);
   }
 
-  getTokenInfoForDeposit(deposit: Pick<Deposit, "inputToken" | "originChainId">): L1Token | undefined {
-    return this.getTokenInfoForL1Token(
-      this.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, this.latestBlockSearched)
-    );
-  }
-
-  getTokenInfo(chainId: number | string, tokenAddress: string): L1Token | undefined {
-    const deposit = { originChainId: parseInt(chainId.toString()), inputToken: tokenAddress };
-    return this.getTokenInfoForDeposit(deposit);
-  }
-
   areTokensEquivalent(
     tokenA: string,
     chainIdA: number,
@@ -904,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,
               },
             ]
           );
@@ -982,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,

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -401,7 +401,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Log any invalid deposits with same deposit id but different params.
     const invalidFillsForDeposit = invalidFills.filter((x) => {
-      const txnUid = `${x.transactionHash}:${x.logIndex}`;
+      const txnUid = `${x.txnRef}:${x.logIndex}`;
       // if txnUid doesn't exist in the invalidFills set, add it now, but log the corresponding fill.
       const newInvalidFill = x.depositId.eq(deposit.depositId) && !this.invalidFills.has(txnUid);
       if (newInvalidFill) {

package/src/clients/mocks/MockConfigStoreClient.ts

@@ -2,7 +2,14 @@ import assert from "assert";
 import winston from "winston";
 import { Contract, ethers } from "ethers";
 import { Log } from "../../interfaces";
-import { getCurrentTime, EventSearchConfig, MakeOptional, isDefined, utf8ToHex } from "../../utils";
+import {
+  getCurrentTime,
+  EventSearchConfig,
+  MakeOptional,
+  isDefined,
+  utf8ToHex,
+  spreadEventWithBlockNumber,
+} from "../../utils";
 import {
   AcrossConfigStoreClient,
   ConfigStoreUpdate,
@@ -92,9 +99,9 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
       chainId: this.chainId as number,
       searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
       events: {
-        updatedGlobalConfigEvents: events["UpdatedGlobalConfig"],
+        updatedGlobalConfigEvents: events["UpdatedGlobalConfig"].map(spreadEventWithBlockNumber),
         globalConfigUpdateTimes,
-        updatedTokenConfigEvents: events["UpdatedTokenConfig"],
+        updatedTokenConfigEvents: events["UpdatedTokenConfig"].map(spreadEventWithBlockNumber),
       },
     });
   }

package/src/clients/mocks/MockHubPoolClient.ts

@@ -24,7 +24,7 @@ export class MockHubPoolClient extends HubPoolClient {
 
   private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
   private tokenInfoToReturn: L1Token = { address: "", decimals: 0, symbol: "" };
-
+  
   private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
 
   private eventManager: EventManager;
@@ -91,7 +91,7 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock;
   }
 
-  getTokenInfoForDeposit() {
+  getTokenInfoForAddress() {
     return this.tokenInfoToReturn;
   }
 
@@ -178,6 +178,30 @@ export class MockHubPoolClient extends HubPoolClient {
     RootBundleExecuted: "uint256,uint256,uint256,address[],uint256[],int256[],int256[],address",
   };
 
+  setCrossChainContractsEvent(
+    l2ChainId: number,
+    adapter: string,
+    spokePool: string,
+    overrides: EventOverrides = {}
+  ): Log {
+    const event = "CrossChainContractsSet";
+
+    const topics: string[] = [];
+    const args = {
+      l2ChainId,
+      adapter,
+      spokePool,
+    };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.hubPool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber: overrides.blockNumber,
+    });
+  }
+
   setPoolRebalanceRoute(
     destinationChainId: number,
     l1Token: string,

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -129,7 +129,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
   }
 
   protected _deposit(event: string, deposit: Omit<Deposit, "messageHash"> & Partial<SortableEvent>): Log {
-    const { blockNumber, transactionIndex } = deposit;
+    const { blockNumber, txnIndex } = deposit;
     let { depositId, destinationChainId, inputAmount, outputAmount } = deposit;
     depositId ??= this.numberOfDeposits;
     this.numberOfDeposits = depositId.add(bnOne);
@@ -171,7 +171,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       topics: topics.map((topic) => topic.toString()),
       args,
       blockNumber,
-      transactionIndex,
+      transactionIndex: txnIndex,
     });
   }
 
@@ -187,7 +187,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     event: string,
     fill: Omit<Fill, "messageHash"> & { message: string } & Partial<SortableEvent>
   ): Log {
-    const { blockNumber, transactionIndex } = fill;
+    const { blockNumber, txnIndex } = fill;
     let { originChainId, depositId, inputAmount, outputAmount, fillDeadline } = fill;
     originChainId ??= random(1, 42161, false);
     depositId ??= BigNumber.from(random(1, 100_000, false));
@@ -260,7 +260,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       topics: topics.map((topic) => topic.toString()),
       args,
       blockNumber,
-      transactionIndex,
+      transactionIndex: txnIndex,
     });
   }
 
@@ -335,7 +335,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
         exclusiveRelayer: addressModifier(args.exclusiveRelayer ?? ZERO_ADDRESS),
       },
       blockNumber: request.blockNumber,
-      transactionIndex: request.transactionIndex,
+      transactionIndex: request.txnIndex,
     });
   }
 

package/src/interfaces/Common.ts

@@ -9,9 +9,9 @@ export type Log = _Log & {
 
 export interface SortableEvent {
   blockNumber: number;
-  transactionIndex: number;
+  txnIndex: number;
   logIndex: number;
-  transactionHash: string;
+  txnRef: string;
 }
 
 export interface BigNumberForToken {

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

@@ -252,14 +252,4 @@ export class QueryBase implements QueryInterface {
     );
     return price;
   }
-
-  /**
-   * Resolves the number of decimal places a token can have
-   * @param tokenSymbol A valid Across-Enabled Token ID
-   * @returns The number of decimals of precision for the corresponding tokenSymbol
-   */
-  getTokenDecimals(tokenSymbol: string): number {
-    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
-    return this.symbolMapping[tokenSymbol].decimals;
-  }
 }

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -34,7 +34,6 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getTokenDecimals: (tokenSymbol: string) => number;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];

package/src/utils/AddressUtils.ts

@@ -241,6 +241,10 @@ export class SvmAddress extends Address {
     return this.toBase58();
   }
 
+  override toEvmAddress(): string {
+    return toAddress(`0x${this.toBytes32().slice(-40)}`);
+  }
+
   // Constructs a new SvmAddress type.
   static from(bs58Address: string): SvmAddress {
     return new this(bs58.decode(bs58Address));