@across-protocol/sdk 4.3.44 → 4.3.45

package/src/clients/HubPoolClient.ts

@@ -34,7 +34,6 @@ import {
   fetchTokenInfo,
   getCachedBlockForTimestamp,
   getCurrentTime,
-  getNetworkName,
   isDefined,
   mapAsync,
   paginatedEventQuery,
@@ -75,17 +74,11 @@ type HubPoolEvent =
   | "RootBundleExecuted"
   | "CrossChainContractsSet";
 
-type L1TokensToDestinationTokens = {
-  [l1Token: string]: { [destinationChainId: number]: Address };
-};
-
 export type LpFeeRequest = Pick<Deposit, "originChainId" | "inputToken" | "inputAmount" | "quoteTimestamp"> & {
   paymentChainId?: number;
 };
 
 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 lpTokens: { [token: string]: LpToken } = {};
@@ -192,24 +185,16 @@ export class HubPoolClient extends BaseAbstractClient {
     l1Token: EvmAddress,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): Address {
+  ): Address | undefined {
     if (!this.l1TokensToDestinationTokensWithBlock?.[l1Token.toEvmAddress()]?.[destinationChainId]) {
-      const chain = getNetworkName(destinationChainId);
-      const { symbol } = this.l1Tokens.find(({ address }) => address.eq(l1Token)) ?? { symbol: l1Token.toString() };
-      throw new Error(`Could not find SpokePool mapping for ${symbol} on ${chain} and L1 token ${l1Token}`);
+      return undefined;
     }
     // Find the last mapping published before the target block.
-    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
-      this.l1TokensToDestinationTokensWithBlock[l1Token.toEvmAddress()][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() };
-      throw new Error(
-        `Could not find SpokePool mapping for ${symbol} on ${chain} at or before HubPool block ${latestHubBlock}!`
-      );
-    }
-    return l2Token.l2Token;
+    const l2Token: DestinationTokenWithBlock | undefined = this.l1TokensToDestinationTokensWithBlock[
+      l1Token.toEvmAddress()
+    ][destinationChainId].find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= latestHubBlock);
+
+    return !l2Token || l2Token.l2Token.isZeroAddress() ? undefined : l2Token.l2Token;
   }
 
   // Returns the latest L1 token to use for an L2 token as of the input hub block.
@@ -217,32 +202,27 @@ export class HubPoolClient extends BaseAbstractClient {
     l2Token: Address,
     destinationChainId: number,
     latestHubBlock = Number.MAX_SAFE_INTEGER
-  ): EvmAddress {
-    const l2Tokens = Object.keys(this.l1TokensToDestinationTokensWithBlock)
-      .filter((l1Token) => this.l2TokenEnabledForL1Token(EvmAddress.from(l1Token), destinationChainId))
-      .map((l1Token) => {
-        // Return all matching L2 token mappings that are equal to or earlier than the target block.
-        // @dev Since tokens on L2s (like Solana) can have 32 byte addresses, filter on the lower 20 bytes of the token only.
-        return this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId].filter(
-          (dstTokenWithBlock) =>
-            dstTokenWithBlock.l2Token.truncateToBytes20() === l2Token.truncateToBytes20() &&
-            dstTokenWithBlock.blockNumber <= latestHubBlock
-        );
-      })
-      .flat();
-    if (l2Tokens.length === 0) {
-      const chain = getNetworkName(destinationChainId);
-      throw new Error(
-        `Could not find HubPool mapping for ${l2Token} on ${chain} at or before HubPool block ${latestHubBlock}!`
+  ): EvmAddress | undefined {
+    const l2Tokens = Object.keys(this.l1TokensToDestinationTokensWithBlock).flatMap((l1Token) => {
+      // Get the latest L2 token mapping for the given L1 token.
+      // @dev Since tokens on L2s (like Solana) can have 32 byte addresses, filter on the lower 20 bytes of the token only.
+      const sortedL2Tokens = sortEventsDescending(
+        (this.l1TokensToDestinationTokensWithBlock[l1Token][destinationChainId] ?? []).filter(
+          (dstTokenWithBlock) => dstTokenWithBlock.blockNumber <= latestHubBlock
+        )
       );
-    }
-    // Find the last mapping published before the target block.
-    return sortEventsDescending(l2Tokens)[0].l1Token;
+      // If the latest L2 token mapping is equal to the target L2 token, return it.
+      return sortedL2Tokens.length > 0 && sortedL2Tokens[0].l2Token.truncateToBytes20() === l2Token.truncateToBytes20()
+        ? sortedL2Tokens[0]
+        : [];
+    });
+
+    return l2Tokens.length === 0 ? undefined : sortEventsDescending(l2Tokens)[0].l1Token;
   }
 
   protected getL1TokenForDeposit(
     deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
-  ): EvmAddress {
+  ): EvmAddress | undefined {
     // 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.
@@ -250,7 +230,7 @@ export class HubPoolClient extends BaseAbstractClient {
   }
 
   l2TokenEnabledForL1Token(l1Token: EvmAddress, destinationChainId: number): boolean {
-    return this.l1TokensToDestinationTokens?.[l1Token.toEvmAddress()]?.[destinationChainId] != undefined;
+    return this.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, Number.MAX_SAFE_INTEGER);
   }
 
   l2TokenEnabledForL1TokenAtBlock(l1Token: EvmAddress, destinationChainId: number, hubBlockNumber: number): boolean {
@@ -258,21 +238,12 @@ export class HubPoolClient extends BaseAbstractClient {
     const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
       this.l1TokensToDestinationTokensWithBlock?.[l1Token.toEvmAddress()]?.[destinationChainId] ?? []
     ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
-    return l2Token !== undefined;
+    return l2Token !== undefined && !l2Token.l2Token.isZeroAddress();
   }
 
   l2TokenHasPoolRebalanceRoute(l2Token: Address, 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 &&
-            e.l2Token.truncateToBytes20() === l2Token.truncateToBytes20() &&
-            Number(_l2ChainId) === l2ChainId
-          );
-        });
-      });
-    });
+    const l1Token = this.getL1TokenForL2TokenAtBlock(l2Token, l2ChainId, hubPoolBlock);
+    return l1Token !== undefined;
   }
 
   /**
@@ -407,9 +378,11 @@ export class HubPoolClient extends BaseAbstractClient {
     const hubPoolTokens: { [k: string]: EvmAddress } = {};
     const getHubPoolToken = (deposit: LpFeeRequest, quoteBlockNumber: number): EvmAddress | 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 l1Token = this.getL1TokenForDeposit({ ...deposit, quoteBlockNumber });
+      if (!l1Token) {
+        return undefined;
+      }
+      return (hubPoolTokens[tokenKey] ??= l1Token);
     };
     const getHubPoolTokens = (): EvmAddress[] => dedupArray(Object.values(hubPoolTokens).filter(isDefined));
 
@@ -548,14 +521,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 || !l1TokenA.eq(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 !== undefined && _tokenB !== undefined && tokenA.eq(_tokenA) && tokenB.eq(_tokenB);
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {
@@ -995,24 +968,22 @@ export class HubPoolClient extends BaseAbstractClient {
           destinationToken = svmUsdc;
         }
 
-        // 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()) {
-          assign(this.l1TokensToDestinationTokens, [args.l1Token, args.destinationChainId], destinationToken);
-          assign(
-            this.l1TokensToDestinationTokensWithBlock,
-            [args.l1Token, args.destinationChainId],
-            [
-              {
-                l1Token: EvmAddress.from(args.l1Token),
-                l2Token: destinationToken,
-                blockNumber: args.blockNumber,
-                txnIndex: args.txnIndex,
-                logIndex: args.logIndex,
-                txnRef: args.txnRef,
-              },
-            ]
-          );
+        const newRoute: DestinationTokenWithBlock = {
+          l1Token: EvmAddress.from(args.l1Token),
+          l2Token: destinationToken,
+          blockNumber: args.blockNumber,
+          txnIndex: args.txnIndex,
+          logIndex: args.logIndex,
+          txnRef: args.txnRef,
+        };
+        if (this.l1TokensToDestinationTokensWithBlock[args.l1Token]?.[args.destinationChainId]) {
+          // Events are most likely coming in descending orders already but just in case we sort them again.
+          this.l1TokensToDestinationTokensWithBlock[args.l1Token][args.destinationChainId] = sortEventsDescending([
+            ...this.l1TokensToDestinationTokensWithBlock[args.l1Token][args.destinationChainId],
+            newRoute,
+          ]);
+        } else {
+          assign(this.l1TokensToDestinationTokensWithBlock, [args.l1Token, args.destinationChainId], [newRoute]);
         }
       }
     }

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -472,18 +472,22 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       )
     ) {
       return false;
-    } else {
-      const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
-        deposit.inputToken,
-        deposit.originChainId,
-        deposit.quoteBlockNumber
-      );
-      return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
-        l1Token,
-        deposit.destinationChainId,
-        deposit.quoteBlockNumber
-      );
     }
+
+    const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
+      deposit.inputToken,
+      deposit.originChainId,
+      deposit.quoteBlockNumber
+    );
+    if (!l1Token) {
+      return false;
+    }
+
+    return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
+      l1Token,
+      deposit.destinationChainId,
+      deposit.quoteBlockNumber
+    );
   }
 
   /**

package/src/clients/mocks/MockHubPoolClient.ts

@@ -118,9 +118,9 @@ export class MockHubPoolClient extends HubPoolClient {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }
 
-  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress {
+  getL1TokenForL2TokenAtBlock(l2Token: Address, chainId: number, blockNumber: number): EvmAddress | undefined {
     const l1Token = Object.keys(this.spokePoolTokens).find(
-      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId].eq(l2Token)
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId]?.eq(l2Token)
     );
     if (isDefined(l1Token)) {
       return EvmAddress.from(l1Token);
@@ -129,7 +129,7 @@ export class MockHubPoolClient extends HubPoolClient {
     }
   }
 
-  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address {
+  getL2TokenForL1TokenAtBlock(l1Token: EvmAddress, chainId: number, blockNumber: number): Address | undefined {
     const l2Token = this.spokePoolTokens[l1Token.toEvmAddress()]?.[chainId];
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }

package/src/utils/BlockExplorerUtils.ts

@@ -1,7 +1,9 @@
 import { ethers } from "ethers";
 import { PUBLIC_NETWORKS } from "../constants";
-import { createShortHexString } from "./FormattingUtils";
+import { createShortenedString } from "./FormattingUtils";
+import { chainIsEvm } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
+import bs58 from "bs58";
 
 /**
  * Creates a block explorer link for a transaction or address on a given network.
@@ -49,32 +51,37 @@ function constructURL(domain: string, parts: string[]): string {
  * @param chainId The chainId to link to.
  * @returns A formatted markdown block explorer link to the given transaction hash or address on the given chainId.
  */
-function _createBlockExplorerLinkMarkdown(hex: string, chainId = 1): string | null {
+function _createBlockExplorerLinkMarkdown(addr: string, chainId = 1): string | null {
   // Attempt to resolve the block explorer domain for the given chainId.
   const explorerDomain = resolveBlockExplorerDomain(chainId);
   // If the chainId is not supported, return an unsupported link.
   if (!isDefined(explorerDomain)) {
-    return `<unsupported chain/hash ${chainId}:${hex}>}`;
+    return `<unsupported chain/hash ${chainId}:${addr}>}`;
   }
   // Ensure that the first two characters are "0x". If they are not, append them.
-  if (hex.substring(0, 2) !== "0x") {
-    hex = `0x${hex}`;
-  }
-  // Ensure that the hex string is a valid hexadecimal string.
-  if (!ethers.utils.isHexString(hex)) {
-    return null;
+  if (addr.substring(0, 2) !== "0x" && chainIsEvm(chainId)) {
+    addr = `0x${addr}`;
+    if (!ethers.utils.isHexString(addr)) {
+      return null;
+    }
   }
   // Resolve the short URL string.
-  const shortURLString = createShortHexString(hex);
-  // Iterate over the two possible hex lengths.
-  for (const [length, route] of [
-    [66, "tx"],
-    [42, "address"],
-  ] as [number, string][]) {
-    // If the hex string is the correct length, return the link.
-    if (hex.length === length) {
-      return `<${constructURL(explorerDomain, [route, hex])} | ${shortURLString}>`;
+  const shortURLString = createShortenedString(addr);
+  if (chainIsEvm(chainId)) {
+    // Iterate over the two possible addr lengths.
+    for (const [length, route] of [
+      [66, "tx"],
+      [42, "address"],
+    ] as [number, string][]) {
+      // If the hex string is the correct length, return the link.
+      if (addr.length === length) {
+        return `<${constructURL(explorerDomain, [route, addr])} | ${shortURLString}>`;
+      }
     }
+  } else {
+    const addrLength = bs58.decode(addr).length;
+    const route = addrLength === 32 ? "account" : "tx";
+    return `<${constructURL(explorerDomain, [route, addr])} | ${shortURLString}>`;
   }
   return null;
 }

package/src/utils/FormattingUtils.ts

@@ -62,9 +62,9 @@ export const formatFeePct = (relayerFeePct: BN): string => {
  * @param maxLength The maximum length of the shortened string. Defaults to 8.
  * @param delimiter The delimiter to use in the middle of the shortened string. Defaults to "...".
  * @returns The shortened hexadecimal string.
- * @example createShortHexString("0x772871a444c6e4e9903d8533a5a13101b74037158123e6709470f0afbf6e7d94") -> "0x7787...7d94"
+ * @example createShortenedString("0x772871a444c6e4e9903d8533a5a13101b74037158123e6709470f0afbf6e7d94") -> "0x7787...7d94"
  */
-export function createShortHexString(hex: string, maxLength = 8, delimiter = ".."): string {
+export function createShortenedString(hex: string, maxLength = 8, delimiter = ".."): string {
   // If we have more maxLength then the hex size, we can simply
   // return the hex directly.
   if (hex.length <= maxLength) {
@@ -134,10 +134,10 @@ export function formatGwei(weiVal: string): string {
  * Shortens a list of addresses to a shorter version with only the first 10 characters.
  * @param addresses A list of addresses to shorten.
  * @returns A list of shortened addresses.
- * @see createShortHexString
+ * @see createShortenedString
  */
 export function shortenHexStrings(addresses: string[]): string[] {
-  return addresses.map((h) => createShortHexString(h));
+  return addresses.map((h) => createShortenedString(h));
 }
 
 // formatWei converts a string or BN instance from Wei to Ether, e.g., 1e19 -> 10.