@across-protocol/sdk 4.2.16-alpha.6 → 4.2.16

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

@@ -14,8 +14,8 @@ import {
   union,
   type,
 } from "superstruct";
-import { CHAIN_IDs, UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType } from "../../../utils";
+import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
+import { BigNumber } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
 const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{40}$/);
@@ -31,31 +31,19 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   }
 });
 
-// Accept any concrete implementation of `Address` (Evm, Svm, or Raw) but avoid using the
-// abstract `Address` class directly to keep TypeScript happy.
-const AddressInstanceSS = union([instance(EvmAddress), instance(SvmAddress), instance(RawAddress)]);
-
-const AddressType = coerce(AddressInstanceSS, string(), (value) => {
-  // Addresses are posted to arweave in their native format (base16 for EVM, base58 for SVM). The chainId for
-  // for the event data is not directly available, so infer it based on the shape of the address. RawAddress
-  // will be instantiated if the address format does not match the expected family.
-  const chainId = value.startsWith("0x") ? CHAIN_IDs.MAINNET : CHAIN_IDs.SOLANA;
-  return toAddressType(value, chainId);
-});
-
 const FillTypeSS = number();
 
 const V3RelayDataSS = {
-  inputToken: AddressType,
+  inputToken: string(),
   inputAmount: BigNumberType,
-  outputToken: AddressType,
+  outputToken: string(),
   outputAmount: BigNumberType,
   fillDeadline: number(),
-  exclusiveRelayer: AddressType,
+  exclusiveRelayer: string(),
   exclusivityDeadline: number(),
   originChainId: number(),
-  depositor: AddressType,
-  recipient: AddressType,
+  depositor: string(),
+  recipient: string(),
   depositId: BigNumberType,
   message: string(),
 };
@@ -79,7 +67,7 @@ const V3DepositSS = {
   quoteTimestamp: number(),
   relayerFeePct: optional(BigNumberType),
   speedUpSignature: optional(string()),
-  updatedRecipient: optional(AddressType),
+  updatedRecipient: optional(string()),
   updatedOutputAmount: optional(BigNumberType),
   updatedMessage: optional(string()),
 };
@@ -100,7 +88,7 @@ const V3DepositWithBlockLpFeeSS = object({
 const V3RelayExecutionEventInfoSS = object({
   updatedOutputAmount: BigNumberType,
   fillType: FillTypeSS,
-  updatedRecipient: AddressType,
+  updatedRecipient: string(),
   updatedMessage: optional(string()),
   updatedMessageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
 });
@@ -110,7 +98,7 @@ const V3FillSS = {
   message: optional(string()),
   messageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
   destinationChainId: number(),
-  relayer: AddressType,
+  relayer: string(),
   repaymentChainId: number(),
   relayExecutionInfo: V3RelayExecutionEventInfoSS,
   quoteTimestamp: number(),

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, TOKEN_SYMBOLS_MAP } from "../constants";
+import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL, TOKEN_SYMBOLS_MAP, ZERO_ADDRESS } from "../constants";
 import {
   CachingMechanismInterface,
   CancelledRootBundle,
@@ -12,7 +12,7 @@ import {
   DestinationTokenWithBlock,
   DisputedRootBundle,
   ExecutedRootBundle,
-  TokenInfo,
+  L1Token,
   Log,
   LpToken,
   PendingRootBundle,
@@ -20,7 +20,6 @@ import {
   RealizedLpFee,
   SetPoolRebalanceRoot,
   TokenRunningBalance,
-  L1TokenInfo,
 } from "../interfaces";
 import * as lpFeeCalculator from "../lpFeeCalculator";
 import { EVMBlockFinder } from "../arch/evm";
@@ -44,12 +43,10 @@ import {
   toBN,
   getTokenInfo,
   getUsdcSymbol,
+  compareAddressesSimple,
   chainIsSvm,
   getDeployedAddress,
   SvmAddress,
-  EvmAddress,
-  Address,
-  toAddressType,
 } from "../utils";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "./AcrossConfigStoreClient/AcrossConfigStoreClient";
 import { BaseAbstractClient, isUpdateFailureReason, UpdateFailureReason } from "./BaseAbstractClient";
@@ -87,8 +84,7 @@ export type LpFeeRequest = Pick<Deposit, "originChainId" | "inputToken" | "input
 export class HubPoolClient extends BaseAbstractClient {
   // L1Token -> destinationChainId -> destinationToken
   protected l1TokensToDestinationTokens: L1TokensToDestinationTokens = {};
-  protected l1Tokens: L1TokenInfo[] = []; // L1Tokens and their associated info.
-  // @dev `token` here is a 20-byte hex sting
+  protected l1Tokens: L1Token[] = []; // L1Tokens and their associated info.
   protected lpTokens: { [token: string]: LpToken } = {};
   protected proposedRootBundles: ProposedRootBundle[] = [];
   protected canceledRootBundles: CancelledRootBundle[] = [];
@@ -96,7 +92,6 @@ export class HubPoolClient extends BaseAbstractClient {
   protected executedRootBundles: ExecutedRootBundle[] = [];
   protected crossChainContracts: { [l2ChainId: number]: CrossChainContractsSet[] } = {};
   protected l1TokensToDestinationTokensWithBlock: {
-    // @dev `l1Token` here is a 20-byte hex sting
     [l1Token: string]: { [destinationChainId: number]: DestinationTokenWithBlock[] };
   } = {};
   protected pendingRootBundle: PendingRootBundle | undefined;
@@ -165,7 +160,7 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.executedRootBundles;
   }
 
-  getSpokePoolForBlock(chain: number, block: number = Number.MAX_SAFE_INTEGER): Address {
+  getSpokePoolForBlock(chain: number, block: number = Number.MAX_SAFE_INTEGER): string {
     if (!this.crossChainContracts[chain]) {
       throw new Error(`No cross chain contracts set for ${chain}`);
     }
@@ -179,33 +174,33 @@ export class HubPoolClient extends BaseAbstractClient {
     }
   }
 
-  getSpokePoolActivationBlock(chain: number, spokePool: Address): number | undefined {
+  getSpokePoolActivationBlock(chain: number, spokePool: string): number | undefined {
     // Return first time that this spoke pool was registered in the HubPool as a cross chain contract. We can use
     // this block as the oldest block that we should query for SpokePoolClient purposes.
-    const mostRecentSpokePoolUpdateBeforeBlock = this.crossChainContracts[chain].find((crossChainContract) =>
-      crossChainContract.spokePool.eq(spokePool)
+    const mostRecentSpokePoolUpdateBeforeBlock = this.crossChainContracts[chain].find(
+      (crossChainContract) => crossChainContract.spokePool === spokePool
     );
     return mostRecentSpokePoolUpdateBeforeBlock?.blockNumber;
   }
 
   // Returns the latest L2 token to use for an L1 token as of the input hub block.
   getL2TokenForL1TokenAtBlock(
-    l1Token: EvmAddress,
+    l1Token: string,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): Address {
-    if (!this.l1TokensToDestinationTokensWithBlock?.[l1Token.toEvmAddress()]?.[destinationChainId]) {
+  ): string {
+    if (!this.l1TokensToDestinationTokensWithBlock?.[l1Token]?.[destinationChainId]) {
       const chain = getNetworkName(destinationChainId);
-      const { symbol } = this.l1Tokens.find(({ address }) => address.eq(l1Token)) ?? { symbol: l1Token.toString() };
+      const { symbol } = this.l1Tokens.find(({ address }) => address === l1Token) ?? { symbol: l1Token };
       throw new Error(`Could not find SpokePool mapping for ${symbol} on ${chain} and L1 token ${l1Token}`);
     }
     // Find the last mapping published before the target block.
     const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
-      this.l1TokensToDestinationTokensWithBlock[l1Token.toEvmAddress()][destinationChainId]
+      this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId]
     ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= latestHubBlock);
     if (!l2Token) {
       const chain = getNetworkName(destinationChainId);
-      const { symbol } = this.l1Tokens.find(({ address }) => address.eq(l1Token)) ?? { symbol: l1Token.toString() };
+      const { symbol } = this.l1Tokens.find(({ address }) => address === l1Token) ?? { symbol: l1Token };
       throw new Error(
         `Could not find SpokePool mapping for ${symbol} on ${chain} at or before HubPool block ${latestHubBlock}!`
       );
@@ -213,23 +208,18 @@ export class HubPoolClient extends BaseAbstractClient {
     return l2Token.l2Token;
   }
 
-  // TODO: this might have to deal with truncated Solana addresses? Depends on what input is given actually
-  // TODO: might craete `getL1TokenForL2EVMTokenAtBlock` and some other fn
   // Returns the latest L1 token to use for an L2 token as of the input hub block.
   getL1TokenForL2TokenAtBlock(
-    l2Token: Address, // ! TODO: assuming that for Svm token, we'll have a proper full SvmAddress in this var
+    l2Token: string,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): EvmAddress {
+  ): string {
     const l2Tokens = Object.keys(this.l1TokensToDestinationTokensWithBlock)
-      .filter((l1Token) => this.l2TokenEnabledForL1Token(EvmAddress.from(l1Token), destinationChainId))
+      .filter((l1Token) => this.l2TokenEnabledForL1Token(l1Token, destinationChainId))
       .map((l1Token) => {
         // Return all matching L2 token mappings that are equal to or earlier than the target block.
         return this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId].filter(
-          // ! TODO: Okay. Here, in `l1TokensToDestinationTokensWithBlock`, we might be saving truncated solana addresses (as `l1TokensToDestinationTokensWithBlock` is probably generated from events)
-          // ! TODO: Considering this, this filtering should be a bit different. If .isSvmAddress => check not for equality, but for *truncated equality*. If .isEvmAddress, check for equality
-          (dstTokenWithBlock) =>
-            dstTokenWithBlock.l2Token.eq(l2Token) && dstTokenWithBlock.blockNumber <= latestHubBlock
+          (mapping) => mapping.l2Token === l2Token && mapping.blockNumber <= latestHubBlock
         );
       })
       .flat();
@@ -245,33 +235,32 @@ export class HubPoolClient extends BaseAbstractClient {
 
   protected getL1TokenForDeposit(
     deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
-  ): EvmAddress {
+  ): 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);
   }
 
-  l2TokenEnabledForL1Token(l1Token: EvmAddress, destinationChainId: number): boolean {
-    return this.l1TokensToDestinationTokens?.[l1Token.toEvmAddress()]?.[destinationChainId] != undefined;
+  l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean {
+    return this.l1TokensToDestinationTokens?.[l1Token]?.[destinationChainId] != undefined;
   }
 
-  l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
+  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.toEvmAddress()]?.[destinationChainId] ?? []
+      this.l1TokensToDestinationTokensWithBlock?.[l1Token]?.[destinationChainId] ?? []
     ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
     return l2Token !== undefined;
   }
 
-  l2TokenHasPoolRebalanceRoute(l2Token: Address, l2ChainId: number, hubPoolBlock = this.latestHeightSearched): boolean {
+  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestHeightSearched): boolean {
     return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
       return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
         return setPoolRebalanceRouteEvents.some((e) => {
           return (
             e.blockNumber <= hubPoolBlock &&
-            // TODO: compare the last 20 bytes of l2Token only. Solana workaround, is this correct?
-            e.l2Token.eq(l2Token) &&
+            compareAddressesSimple(e.l2Token, l2Token) &&
             Number(_l2ChainId) === l2ChainId
           );
         });
@@ -282,16 +271,15 @@ export class HubPoolClient extends BaseAbstractClient {
   /**
    * @dev If tokenAddress + chain do not exist in TOKEN_SYMBOLS_MAP then this will throw.
    * @param tokenAddress Token address on `chain`
-   * @param chainId Chain where the `tokenAddress` exists in TOKEN_SYMBOLS_MAP.
+   * @param chain Chain where the `tokenAddress` exists in TOKEN_SYMBOLS_MAP.
    * @returns Token info for the given token address on the L2 chain including symbol and decimal.
    */
-  // TODO: didn't change `tokenAddress` here to Address because of downstream getTokenInfo impl
-  getTokenInfoForAddress(tokenAddress: string, chainId: number): TokenInfo {
-    const tokenInfo = getTokenInfo(tokenAddress, chainId);
+  getTokenInfoForAddress(tokenAddress: string, chain: number): L1Token {
+    const tokenInfo = getTokenInfo(tokenAddress, chain);
     // @dev Temporarily handle case where an L2 token for chain ID can map to more than one TOKEN_SYMBOLS_MAP
     // entry. For example, L2 Bridged USDC maps to both the USDC and USDC.e/USDbC entries in TOKEN_SYMBOLS_MAP.
-    if (tokenInfo.symbol.toLowerCase() === "usdc" && chainId !== this.chainId) {
-      tokenInfo.symbol = getUsdcSymbol(tokenAddress, chainId) ?? "UNKNOWN";
+    if (tokenInfo.symbol.toLowerCase() === "usdc" && chain !== this.chainId) {
+      tokenInfo.symbol = getUsdcSymbol(tokenAddress, chain) ?? "UNKNOWN";
     }
     return tokenInfo;
   }
@@ -323,7 +311,7 @@ export class HubPoolClient extends BaseAbstractClient {
     return blockNumbers;
   }
 
-  async getCurrentPoolUtilization(l1Token: EvmAddress): Promise<BigNumber> {
+  async getCurrentPoolUtilization(l1Token: string): Promise<BigNumber> {
     const blockNumber = this.latestHeightSearched ?? (await this.hubPool.provider.getBlockNumber());
     return await this.getUtilization(l1Token, blockNumber, bnZero, getCurrentTime(), 0);
   }
@@ -338,7 +326,7 @@ export class HubPoolClient extends BaseAbstractClient {
    * @returns HubPool utilization at `blockNumber` after optional `amount` increase in utilization.
    */
   protected async getUtilization(
-    hubPoolToken: EvmAddress,
+    hubPoolToken: string,
     blockNumber: number,
     depositAmount: BigNumber,
     timestamp: number,
@@ -349,14 +337,10 @@ export class HubPoolClient extends BaseAbstractClient {
       const overrides = { blockTag: blockNumber };
       if (depositAmount.eq(0)) {
         // For zero amount, just get the utilisation at `blockNumber`.
-        return await this.hubPool.callStatic.liquidityUtilizationCurrent(hubPoolToken.toEvmAddress(), overrides);
+        return await this.hubPool.callStatic.liquidityUtilizationCurrent(hubPoolToken, overrides);
       }
 
-      return await this.hubPool.callStatic.liquidityUtilizationPostRelay(
-        hubPoolToken.toEvmAddress(),
-        depositAmount,
-        overrides
-      );
+      return await this.hubPool.callStatic.liquidityUtilizationPostRelay(hubPoolToken, depositAmount, overrides);
     };
 
     // Resolve the cache locally so that we can appease typescript
@@ -371,8 +355,8 @@ export class HubPoolClient extends BaseAbstractClient {
     // @note Avoid collisions with pre-existing cache keys by appending an underscore (_) for post-relay utilization.
     // @fixme This can be removed once the existing keys have been ejected from the cache (i.e. 7 days).
     const key = depositAmount.eq(0)
-      ? `utilization_${hubPoolToken.toEvmAddress()}_${blockNumber}`
-      : `utilization_${hubPoolToken.toEvmAddress()}_${blockNumber}_${depositAmount.toString()}_`;
+      ? `utilization_${hubPoolToken}_${blockNumber}`
+      : `utilization_${hubPoolToken}_${blockNumber}_${depositAmount.toString()}_`;
     const result = await cache.get<string>(key);
     if (isDefined(result)) {
       return BigNumber.from(result);
@@ -409,14 +393,14 @@ export class HubPoolClient extends BaseAbstractClient {
 
     // Map SpokePool token addresses to HubPool token addresses.
     // Note: Should only be accessed via `getHubPoolToken()` or `getHubPoolTokens()`.
-    const hubPoolTokens: { [k: string]: EvmAddress } = {};
-    const getHubPoolToken = (deposit: LpFeeRequest, quoteBlockNumber: number): EvmAddress | undefined => {
+    const hubPoolTokens: { [k: string]: string } = {};
+    const getHubPoolToken = (deposit: LpFeeRequest, quoteBlockNumber: number): string | undefined => {
       const tokenKey = `${deposit.originChainId}-${deposit.inputToken}`;
       if (this.l2TokenHasPoolRebalanceRoute(deposit.inputToken, deposit.originChainId, quoteBlockNumber)) {
         return (hubPoolTokens[tokenKey] ??= this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber }));
       } else return undefined;
     };
-    const getHubPoolTokens = (): EvmAddress[] => dedupArray(Object.values(hubPoolTokens).filter(isDefined));
+    const getHubPoolTokens = (): string[] => dedupArray(Object.values(hubPoolTokens).filter(isDefined));
 
     // Helper to resolve the unqiue hubPoolToken & quoteTimestamp mappings.
     const resolveUniqueQuoteTimestamps = (deposit: LpFeeRequest): void => {
@@ -430,17 +414,17 @@ export class HubPoolClient extends BaseAbstractClient {
       }
 
       // Append the quoteTimestamp for this HubPool token, if it isn't already enqueued.
-      utilizationTimestamps[hubPoolToken.toEvmAddress()] ??= [];
-      if (!utilizationTimestamps[hubPoolToken.toEvmAddress()].includes(quoteTimestamp)) {
-        utilizationTimestamps[hubPoolToken.toEvmAddress()].push(quoteTimestamp);
+      utilizationTimestamps[hubPoolToken] ??= [];
+      if (!utilizationTimestamps[hubPoolToken].includes(quoteTimestamp)) {
+        utilizationTimestamps[hubPoolToken].push(quoteTimestamp);
       }
     };
 
     // Helper to resolve existing HubPool token utilisation for an array of unique block numbers.
     // Produces a mapping of blockNumber -> utilization for a specific token.
-    const resolveUtilization = async (hubPoolToken: EvmAddress): Promise<Record<number, BigNumber>> => {
+    const resolveUtilization = async (hubPoolToken: string): Promise<Record<number, BigNumber>> => {
       return Object.fromEntries(
-        await mapAsync(utilizationTimestamps[hubPoolToken.toEvmAddress()], async (quoteTimestamp) => {
+        await mapAsync(utilizationTimestamps[hubPoolToken], async (quoteTimestamp) => {
           const blockNumber = quoteBlocks[quoteTimestamp];
           const utilization = await this.getUtilization(
             hubPoolToken,
@@ -476,7 +460,7 @@ export class HubPoolClient extends BaseAbstractClient {
         quoteBlock
       );
 
-      const preUtilization = utilization[hubPoolToken.toEvmAddress()][quoteBlock];
+      const preUtilization = utilization[hubPoolToken][quoteBlock];
       const postUtilization = await this.getUtilization(
         hubPoolToken,
         quoteBlock,
@@ -504,10 +488,7 @@ export class HubPoolClient extends BaseAbstractClient {
     // For each token / quoteBlock pair, resolve the utilisation for each quoted block.
     // This can be reused for each deposit with the same HubPool token and quoteTimestamp pair.
     utilization = Object.fromEntries(
-      await mapAsync(getHubPoolTokens(), async (hubPoolToken) => [
-        hubPoolToken.toEvmAddress(),
-        await resolveUtilization(hubPoolToken),
-      ])
+      await mapAsync(getHubPoolTokens(), async (hubPoolToken) => [hubPoolToken, await resolveUtilization(hubPoolToken)])
     );
 
     // For each deposit, compute the post-relay HubPool utilisation independently.
@@ -525,22 +506,22 @@ export class HubPoolClient extends BaseAbstractClient {
     });
   }
 
-  getL1Tokens(): L1TokenInfo[] {
+  getL1Tokens(): L1Token[] {
     return this.l1Tokens;
   }
 
-  getTokenInfoForL1Token(l1Token: EvmAddress): L1TokenInfo | undefined {
-    return this.l1Tokens.find((token) => token.address.eq(l1Token));
+  getTokenInfoForL1Token(l1Token: string): L1Token | undefined {
+    return this.l1Tokens.find((token) => token.address === l1Token);
   }
 
-  getLpTokenInfoForL1Token(l1Token: EvmAddress): LpToken | undefined {
-    return this.lpTokens[l1Token.toEvmAddress()];
+  getLpTokenInfoForL1Token(l1Token: string): LpToken | undefined {
+    return this.lpTokens[l1Token];
   }
 
   areTokensEquivalent(
-    tokenA: Address,
+    tokenA: string,
     chainIdA: number,
-    tokenB: Address,
+    tokenB: string,
     chainIdB: number,
     hubPoolBlock = this.latestHeightSearched
   ): boolean {
@@ -553,14 +534,14 @@ export class HubPoolClient extends BaseAbstractClient {
     // 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.eq(l1TokenB)) {
+    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.eq(_tokenA) && tokenB.eq(_tokenB);
+    return tokenA === _tokenA && tokenB === _tokenB;
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {
@@ -797,35 +778,34 @@ export class HubPoolClient extends BaseAbstractClient {
   getLatestExecutedRootBundleContainingL1Token(
     block: number,
     chain: number,
-    l1Token: EvmAddress
+    l1Token: string
   ): ExecutedRootBundle | undefined {
     // Search ExecutedRootBundles in descending block order to find the most recent event before the target block.
     return sortEventsDescending(this.executedRootBundles).find((executedLeaf: ExecutedRootBundle) => {
       return (
         executedLeaf.blockNumber <= block &&
         executedLeaf.chainId === chain &&
-        executedLeaf.l1Tokens.some((token) => token.eq(l1Token))
+        executedLeaf.l1Tokens.some((token) => token.toLowerCase() === l1Token.toLowerCase())
       );
     });
   }
 
-  getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: EvmAddress): TokenRunningBalance {
+  getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: string): TokenRunningBalance {
     const executedRootBundle = this.getLatestExecutedRootBundleContainingL1Token(block, chain, l1Token);
 
     return this.getRunningBalanceForToken(l1Token, executedRootBundle);
   }
 
   public getRunningBalanceForToken(
-    l1Token: EvmAddress,
+    l1Token: string,
     executedRootBundle: ExecutedRootBundle | undefined
   ): TokenRunningBalance {
     let runningBalance = toBN(0);
     if (executedRootBundle) {
-      const indexOfL1Token = executedRootBundle.l1Tokens.findIndex((tokenInBundle) => tokenInBundle.eq(l1Token));
-      // TODO: not sure this if is required. Wasn't here before. Probably `getRunningBalanceForToken` is used on checked tokens only
-      if (indexOfL1Token !== -1) {
-        runningBalance = executedRootBundle.runningBalances[indexOfL1Token];
-      }
+      const indexOfL1Token = executedRootBundle.l1Tokens
+        .map((l1Token) => l1Token.toLowerCase())
+        .indexOf(l1Token.toLowerCase());
+      runningBalance = executedRootBundle.runningBalances[indexOfL1Token];
     }
 
     return { runningBalance };
@@ -893,10 +873,7 @@ export class HubPoolClient extends BaseAbstractClient {
     return {
       success: true,
       currentTime,
-      pendingRootBundleProposal: {
-        ...pendingRootBundleProposal,
-        proposer: toAddressType(pendingRootBundleProposal.proposer, this.chainId),
-      },
+      pendingRootBundleProposal,
       searchEndBlock: searchConfig.to,
       events: _events,
     };
@@ -921,9 +898,9 @@ export class HubPoolClient extends BaseAbstractClient {
 
     if (eventsToQuery.includes("CrossChainContractsSet")) {
       for (const event of events["CrossChainContractsSet"]) {
-        const args = spreadEventWithBlockNumber(event) as CrossChainContractsSet & { spokePool: string };
+        const args = spreadEventWithBlockNumber(event) as CrossChainContractsSet;
         const dataToAdd: CrossChainContractsSet = {
-          spokePool: toAddressType(args.spokePool, this.chainId),
+          spokePool: args.spokePool,
           blockNumber: args.blockNumber,
           txnRef: args.txnRef,
           logIndex: args.logIndex,
@@ -939,8 +916,7 @@ export class HubPoolClient extends BaseAbstractClient {
           if (!solanaSpokePool) {
             throw new Error(`SVM spoke pool not found for chain ${args.l2ChainId}`);
           }
-          const svmSpoke = SvmAddress.from(solanaSpokePool);
-          const truncatedAddress = svmSpoke.truncateToBytes20();
+          const truncatedAddress = SvmAddress.from(solanaSpokePool).truncateToBytes20();
           // Verify the event address matches our expected truncated address
           if (args.spokePool.toLowerCase() !== truncatedAddress.toLowerCase()) {
             throw new Error(
@@ -948,7 +924,8 @@ export class HubPoolClient extends BaseAbstractClient {
                 `Expected ${truncatedAddress}, got ${args.spokePool}`
             );
           }
-          dataToAdd.spokePool = svmSpoke;
+          // Store the full Solana address
+          dataToAdd.spokePool = SvmAddress.from(solanaSpokePool).toBytes32();
         }
         assign(this.crossChainContracts, [args.l2ChainId], [dataToAdd]);
       }
@@ -956,37 +933,34 @@ export class HubPoolClient extends BaseAbstractClient {
 
     if (eventsToQuery.includes("SetPoolRebalanceRoute")) {
       for (const event of events["SetPoolRebalanceRoute"]) {
-        const args = spreadEventWithBlockNumber(event) as SetPoolRebalanceRoot & {
-          l1Token: string;
-          destinationToken: string;
-        };
+        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 = toAddressType(args.destinationToken, this.chainId);
+        let destinationToken = args.destinationToken;
         if (chainIsSvm(args.destinationChainId)) {
           const usdcTokenSol = TOKEN_SYMBOLS_MAP.USDC.addresses[args.destinationChainId];
-          const svmUsdc = SvmAddress.from(usdcTokenSol);
-          if (destinationToken.truncateToBytes20() !== svmUsdc.truncateToBytes20()) {
+          const truncatedAddress = SvmAddress.from(usdcTokenSol).truncateToBytes20();
+          if (destinationToken.toLowerCase() !== truncatedAddress.toLowerCase()) {
             throw new Error(
               `SVM USDC address mismatch for chain ${args.destinationChainId}. ` +
-                `Expected ${svmUsdc.truncateToBytes20()}, got ${destinationToken}`
+                `Expected ${truncatedAddress}, got ${destinationToken}`
             );
           }
-          destinationToken = svmUsdc;
+          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 (!destinationToken.isZeroAddress()) {
+        if (destinationToken !== ZERO_ADDRESS) {
           assign(this.l1TokensToDestinationTokens, [args.l1Token, args.destinationChainId], destinationToken);
           assign(
             this.l1TokensToDestinationTokensWithBlock,
             [args.l1Token, args.destinationChainId],
             [
               {
-                l1Token: toAddressType(args.l1Token, this.chainId),
+                l1Token: args.l1Token,
                 l2Token: destinationToken,
                 blockNumber: args.blockNumber,
                 txnIndex: args.txnIndex,
@@ -1008,15 +982,7 @@ export class HubPoolClient extends BaseAbstractClient {
       );
 
       const [tokenInfo, lpTokenInfo] = await Promise.all([
-        Promise.all(
-          uniqueL1Tokens.map(async (l1Token: string) => {
-            const tokenInfo = await fetchTokenInfo(l1Token, this.hubPool.provider);
-            return {
-              ...tokenInfo,
-              address: EvmAddress.from(l1Token),
-            };
-          })
-        ),
+        Promise.all(uniqueL1Tokens.map((l1Token: string) => fetchTokenInfo(l1Token, this.hubPool.provider))),
         Promise.all(
           uniqueL1Tokens.map(
             async (l1Token: string) => await this.hubPool.pooledTokens(l1Token, { blockTag: update.searchEndBlock })
@@ -1024,7 +990,7 @@ export class HubPoolClient extends BaseAbstractClient {
         ),
       ]);
       for (const info of tokenInfo) {
-        if (!this.l1Tokens.find((token) => token.address.eq(info.address))) {
+        if (!this.l1Tokens.find((token) => compareAddressesSimple(token.address, info.address))) {
           if (info.decimals > 0 && info.decimals <= 18) {
             this.l1Tokens.push(info);
           } else {
@@ -1045,13 +1011,7 @@ export class HubPoolClient extends BaseAbstractClient {
       this.proposedRootBundles.push(
         ...events["ProposeRootBundle"]
           .filter((event) => !this.configOverride.ignoredHubProposedBundles.includes(event.blockNumber))
-          .map((_event) => {
-            const args = spreadEventWithBlockNumber(_event) as ProposedRootBundle & { proposer: string };
-            return {
-              ...args,
-              proposer: EvmAddress.from(args.proposer),
-            };
-          })
+          .map((event) => spreadEventWithBlockNumber(event) as ProposedRootBundle)
       );
     }
 
@@ -1074,7 +1034,7 @@ export class HubPoolClient extends BaseAbstractClient {
         }
 
         // Set running balances and incentive balances for this bundle.
-        const executedRootBundle = spreadEventWithBlockNumber(event) as ExecutedRootBundle & { l1Tokens: string[] };
+        const executedRootBundle = spreadEventWithBlockNumber(event) as ExecutedRootBundle;
         const { l1Tokens, runningBalances } = executedRootBundle;
         const nTokens = l1Tokens.length;
 
@@ -1086,12 +1046,7 @@ export class HubPoolClient extends BaseAbstractClient {
           );
         }
         executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
-        this.executedRootBundles.push({
-          ...executedRootBundle,
-          l1Tokens: l1Tokens.map((token: string) => {
-            return EvmAddress.from(token, "base16");
-          }),
-        });
+        this.executedRootBundles.push(executedRootBundle);
       }
     }
 

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -17,7 +17,6 @@ import {
   MakeOptional,
   toBN,
   EvmAddress,
-  toAddressType,
 } from "../../utils";
 import {
   EventSearchConfig,
@@ -195,11 +194,6 @@ export class EVMSpokePoolClient extends SpokePoolClient {
 
     deposit = {
       ...spreadEventWithBlockNumber(event),
-      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.