@across-protocol/sdk 3.1.24 → 3.1.26

package/src/providers/utils.ts

@@ -43,6 +43,27 @@ export function compareArrayResultsWithIgnoredKeys(ignoredKeys: string[], objA:
   return isDefined(filteredA) && isDefined(filteredB) && isEqual(filteredA, filteredB);
 }
 
+/**
+ * A record of error codes that correspond to fields that should be ignored when comparing RPC results.
+ * This is used to compare results from different providers that may have different, but still valid, results.
+ */
+const IGNORED_FIELDS = {
+  // We've seen some RPC's like QuickNode add in transactionLogIndex which isn't in the
+  // JSON RPC spec: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges
+  // Additional reference: https://github.com/ethers-io/ethers.js/issues/1721
+  // 2023-08-31 Added blockHash because of upstream zkSync provider disagreements. Consider removing later.
+  // 2024-05-07 Added l1BatchNumber and logType due to Alchemy. Consider removing later.
+  // 2024-07-11 Added blockTimestamp after zkSync rolled out a new node release.
+  eth_getBlockByNumber: [
+    "miner", // polygon (sometimes)
+    "l1BatchNumber", // zkSync
+    "l1BatchTimestamp", // zkSync
+    "size", // Alchemy/Arbitrum (temporary)
+    "totalDifficulty", // Quicknode/Alchemy (sometimes)
+  ],
+  eth_getLogs: ["blockTimestamp", "transactionLogIndex", "l1BatchNumber", "logType"],
+};
+
 /**
  * This is the type we pass to define a request "task".
  */
@@ -85,25 +106,13 @@ export function compareRpcResults(method: string, rpcResultA: unknown, rpcResult
     // We've seen RPC's disagree on the miner field, for example when Polygon nodes updated software that
     // led alchemy and quicknode to disagree on the miner field's value.
     return compareResultsAndFilterIgnoredKeys(
-      [
-        "miner", // polygon (sometimes)
-        "l1BatchNumber", // zkSync
-        "l1BatchTimestamp", // zkSync
-        "size", // Alchemy/Arbitrum (temporary)
-        "totalDifficulty", // Quicknode/Alchemy (sometimes)
-      ],
+      IGNORED_FIELDS.eth_getBlockByNumber,
       rpcResultA as Record<string, unknown>,
       rpcResultB as Record<string, unknown>
     );
   } else if (method === "eth_getLogs") {
-    // We've seen some RPC's like QuickNode add in transactionLogIndex which isn't in the
-    // JSON RPC spec: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges
-    // Additional reference: https://github.com/ethers-io/ethers.js/issues/1721
-    // 2023-08-31 Added blockHash because of upstream zkSync provider disagreements. Consider removing later.
-    // 2024-05-07 Added l1BatchNumber and logType due to Alchemy. Consider removing later.
-    // 2024-07-11 Added blockTimestamp after zkSync rolled out a new node release.
     return compareArrayResultsWithIgnoredKeys(
-      ["blockTimestamp", "transactionLogIndex", "l1BatchNumber", "logType"],
+      IGNORED_FIELDS.eth_getLogs,
       rpcResultA as unknown[],
       rpcResultB as unknown[]
     );

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -196,7 +196,6 @@ export class RelayFeeCalculator {
    */
   static validateCapitalCostsConfig(capitalCosts: CapitalCostConfig): void {
     assert(toBN(capitalCosts.upperBound).lt(toBNWei("0.01")), "upper bound must be < 1%");
-    assert(toBN(capitalCosts.lowerBound).lte(capitalCosts.upperBound), "lower bound must be <= upper bound");
     assert(capitalCosts.decimals > 0 && capitalCosts.decimals <= 18, "invalid decimals");
   }
 

package/src/utils/AddressUtils.ts

@@ -16,3 +16,10 @@ export async function isContractDeployedToAddress(address: string, provider: pro
   // If the code is not empty, then there is a contract at this address
   return code !== "0x";
 }
+
+export function compareAddressesSimple(addressA?: string, addressB?: string): boolean {
+  if (addressA === undefined || addressB === undefined) {
+    return false;
+  }
+  return addressA.toLowerCase() === addressB.toLowerCase();
+}

package/src/utils/TokenUtils.ts

@@ -5,6 +5,7 @@ import { L1Token } from "../interfaces";
 import { ERC20__factory } from "../typechain";
 import { getNetworkName } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
+import { compareAddressesSimple } from "./AddressUtils";
 const { TOKEN_SYMBOLS_MAP, CHAIN_IDs } = constants;
 
 type SignerOrProvider = providers.Provider | Signer;
@@ -106,3 +107,49 @@ export function isBridgedUsdc(tokenSymbol: string): boolean {
     (bridgedUsdcSymbol) => bridgedUsdcSymbol.toLowerCase() === tokenSymbol.toLowerCase()
   );
 }
+
+export function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token {
+  // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
+  // to get around this...
+  const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
+  if (!tokenObject) {
+    throw new Error(
+      `TokenUtils#getTokenInfo: Unable to resolve token in TOKEN_SYMBOLS_MAP for ${l2TokenAddress} on chain ${chainId}`
+    );
+  }
+  return {
+    address: l2TokenAddress,
+    symbol: tokenObject.symbol,
+    decimals: tokenObject.decimals,
+  };
+}
+
+/**
+ * Get the USDC symbol for the given token address and chain ID.
+ * @param l2Token A Web3 token address (not case sensitive)
+ * @param chainId A chain Id to reference
+ * @returns Either USDC (if native) or USDbC/USDC.e (if bridged) or undefined if the token address is not recognized.
+ */
+export function getUsdcSymbol(l2Token: string, chainId: number): string | undefined {
+  const compareToken = (token?: string) => isDefined(token) && compareAddressesSimple(l2Token, token);
+  return ["USDC", "USDbC", "USDC.e"].find((token) =>
+    compareToken(
+      (TOKEN_SYMBOLS_MAP as Record<string, { addresses?: Record<number, string> }>)[token]?.addresses?.[chainId]
+    )
+  );
+}
+
+export function getL1TokenInfo(l2TokenAddress: string, chainId: number): L1Token {
+  const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
+  const l1TokenAddress = tokenObject?.addresses[CHAIN_IDs.MAINNET];
+  if (!l1TokenAddress) {
+    throw new Error(
+      `TokenUtils#getL1TokenInfo: Unable to resolve l1 token address in TOKEN_SYMBOLS_MAP for L2 token ${l2TokenAddress} on chain ${chainId}`
+    );
+  }
+  return {
+    address: l1TokenAddress,
+    symbol: tokenObject.symbol,
+    decimals: tokenObject.decimals,
+  };
+}