@across-protocol/sdk 4.3.2 → 4.3.3

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

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEvD,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,WAAW,CAAC,CAI9G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAa/E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;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;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,SAAS,CAoBjH;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjF"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.2",
+  "version": "4.3.3",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -33,7 +33,8 @@
     "bump-version:major": "yarn version --major --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:minor": "yarn version --minor --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:patch": "yarn version --patch --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
-    "typechain": "typechain --target ethers-v5 --out-dir src/utils/abi/typechain 'src/utils/abi/contracts/*.json' && eslint --fix src/utils/abi/typechain && yarn prettier --write \"src/utils/abi/typechain/**/*.ts\""
+    "typechain": "typechain --target ethers-v5 --out-dir src/utils/abi/typechain 'src/utils/abi/contracts/*.json' && eslint --fix src/utils/abi/typechain && yarn prettier --write \"src/utils/abi/typechain/**/*.ts\"",
+    "yalc:watch": "nodemon --watch src --ext ts,tsx,json,js,jsx --exec 'yalc push'"
   },
   "lint-staged": {
     "*.ts": "yarn lint"

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -43,6 +43,7 @@ import {
   invalidOutputToken,
   Address,
   getNetworkName,
+  toBytes32,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -327,7 +328,9 @@ export class BundleDataClient {
               Object.entries(tokenData).map(([token, data]) => [
                 token,
                 {
-                  refunds: data.refunds,
+                  refunds: Object.fromEntries(
+                    Object.entries(data.refunds).map(([refundAddress, refund]) => [toBytes32(refundAddress), refund])
+                  ),
                   totalRefundAmount: data.totalRefundAmount,
                   realizedLpFees: data.realizedLpFees,
                   fills: convertSortableEventFieldsIntoRequiredFields(data.fills),

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

@@ -15,10 +15,10 @@ import {
   type,
 } from "superstruct";
 import { CHAIN_IDs, UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType } from "../../../utils";
+import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType, toBytes32 } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
-const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{40}$/);
+const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{64}$/);
 
 const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (value) => {
   try {
@@ -43,6 +43,10 @@ const AddressType = coerce(AddressInstanceSS, string(), (value) => {
   return toAddressType(value, chainId);
 });
 
+const Web3AddressType = coerce(Web3AddressSS, string(), (value) => {
+  return toBytes32(value);
+});
+
 const FillTypeSS = number();
 
 const V3RelayDataSS = {
@@ -126,20 +130,20 @@ const BundleFillV3SS = object({
   lpFeePct: BigNumberType,
 });
 
-const nestedV3DepositRecordSS = record(PositiveIntegerStringSS, record(Web3AddressSS, array(V3DepositWithBlockSS)));
+const nestedV3DepositRecordSS = record(PositiveIntegerStringSS, record(Web3AddressType, array(V3DepositWithBlockSS)));
 const nestedV3DepositRecordWithLpFeePctSS = record(
   PositiveIntegerStringSS,
-  record(Web3AddressSS, array(V3DepositWithBlockLpFeeSS))
+  record(Web3AddressType, array(V3DepositWithBlockLpFeeSS))
 );
 
 const nestedV3BundleFillsSS = record(
   // Must be a chainId
   PositiveIntegerStringSS,
   record(
-    Web3AddressSS,
+    Web3AddressType,
     object({
       fills: array(BundleFillV3SS),
-      refunds: record(string(), BigNumberType),
+      refunds: record(Web3AddressType, BigNumberType),
       totalRefundAmount: BigNumberType,
       realizedLpFees: BigNumberType,
     })

package/src/clients/HubPoolClient.ts

@@ -281,13 +281,12 @@ export class HubPoolClient extends BaseAbstractClient {
    * @param chainId 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(address: Address, chainId: number): TokenInfo {
+    const tokenInfo = getTokenInfo(address, chainId);
     // @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";
+      tokenInfo.symbol = getUsdcSymbol(address, chainId) ?? "UNKNOWN USDC";
     }
     return tokenInfo;
   }

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -27,6 +27,7 @@ import {
   Address,
   EvmAddress,
   SvmAddress,
+  toAddressType,
 } from "../utils";
 
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
@@ -277,10 +278,10 @@ export class RelayFeeCalculator {
         isDefined(details.addresses[destinationChainId])
     );
     const outputToken = deposit.outputToken.isZeroAddress()
-      ? destinationChainTokenDetails!.addresses[destinationChainId]
-      : deposit.outputToken.toNative();
+      ? toAddressType(destinationChainTokenDetails!.addresses[destinationChainId], destinationChainId)
+      : deposit.outputToken;
     const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId, tokenMapping);
+    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
     if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }
@@ -507,8 +508,8 @@ export class RelayFeeCalculator {
     const { inputToken, originChainId, outputToken, destinationChainId } = deposit;
     // We can perform a simple lookup with `getTokenInfo` here without resolving the exact token to resolve since we only need to
     // resolve the L1 token symbol and not the L2 token decimals.
-    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId);
-    const outputTokenInfo = getTokenInfo(outputToken.toNative(), destinationChainId);
+    const inputTokenInfo = getTokenInfo(inputToken, originChainId);
+    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId);
     if (!isDefined(inputTokenInfo) || !isDefined(outputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }

package/src/typeguards/error.ts

@@ -1,7 +1,10 @@
 import { ethers } from "ethers";
 import { EthersError } from "../interfaces";
+import { BaseError } from "viem";
 
 export const isError = (error: unknown): error is Error => error instanceof Error;
 
 export const isEthersError = (error?: unknown): error is EthersError =>
   (error as EthersError)?.code in ethers.utils.Logger.errors;
+
+export const isViemError = (error?: unknown): error is BaseError => error instanceof BaseError;

package/src/utils/TokenUtils.ts

@@ -7,7 +7,7 @@ import { ERC20__factory } from "../typechain";
 import { BigNumber } from "./BigNumberUtils";
 import { getNetworkName, chainIsL1, chainIsProd } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
-import { compareAddressesSimple, EvmAddress, toAddressType } from "./AddressUtils";
+import { Address, EvmAddress, toAddressType } from "./AddressUtils";
 const { TOKEN_SYMBOLS_MAP, CHAIN_IDs, TOKEN_EQUIVALENCE_REMAPPING } = constants;
 
 type SignerOrProvider = providers.Provider | Signer;
@@ -66,11 +66,8 @@ export const resolveContractFromSymbol = (
   })?.addresses[Number(chainId)];
 };
 
-export function getCoingeckoTokenIdByAddress(contractAddress: string, chainId: number): string {
-  const token = getTokenInfo(contractAddress, chainId);
-  if (!token) {
-    throw new Error(`Token with address ${contractAddress} not found in token mapping`);
-  }
+export function getCoingeckoTokenIdByAddress(address: string, chainId: number): string {
+  const token = getTokenInfo(toAddressType(address, chainId), chainId);
   return TOKEN_SYMBOLS_MAP[token.symbol as keyof typeof TOKEN_SYMBOLS_MAP].coingeckoId;
 }
 
@@ -108,31 +105,26 @@ export function isStablecoin(tokenSymbol: string): boolean {
  * @notice Returns the Token info for the token mapping in TOKEN_SYMBOLS_MAP matching the given l2TokenAddress
  * and chainId. If the chain is the hub chain, then will remap the L1 token to its equivalent L1 token symbol for example
  * it will always return a token info with symbol USDC and never USDC.e if chainId = mainnet.
- * @param l2TokenAddress
- * @param chainId
- * @param tokenMapping
- * @returns
+ * @param l2Token Address instance.
+ * @param chainId ChainId for l2Token address.
+ * @param tokenMapping Optional custom token mapping.
+ * @returns TokenInfo object.
  */
-export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): TokenInfo {
-  const parsedAddress = toAddressType(l2TokenAddress, chainId).toNative();
+export function getTokenInfo(l2Token: Address, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): TokenInfo {
+  const address = l2Token.toNative();
 
   // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
   // to get around this...
-  let tokenObject = Object.values(tokenMapping).find(({ addresses }) => addresses[chainId] === parsedAddress);
+  let tokenObject = Object.values(tokenMapping).find(({ addresses }) => addresses[chainId] === address);
   if (!tokenObject) {
-    throw new Error(
-      `TokenUtils#getTokenInfo: Unable to resolve token in TOKEN_SYMBOLS_MAP for ${l2TokenAddress} on chain ${chainId}`
-    );
+    throw new Error(`Unable to resolve token info for ${address} on chain ${chainId}`);
   }
   if (chainIsL1(chainId)) {
     const l1TokenSymbol = TOKEN_EQUIVALENCE_REMAPPING[tokenObject.symbol] ?? tokenObject.symbol;
     tokenObject = tokenMapping[l1TokenSymbol as keyof typeof tokenMapping];
   }
-  return {
-    address: toAddressType(l2TokenAddress, chainId),
-    symbol: tokenObject.symbol,
-    decimals: tokenObject.decimals,
-  };
+
+  return { address: l2Token, symbol: tokenObject.symbol, decimals: tokenObject.decimals };
 }
 
 /**
@@ -141,26 +133,30 @@ export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMappi
  * @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 getUsdcSymbol(l2Token: Address, chainId: number): string | undefined {
+  type TokenRecord = Record<string, { addresses?: Record<number, string> }>;
+  const IterableTokenSymbolsMap = TOKEN_SYMBOLS_MAP as TokenRecord;
+  return ["USDC", "USDbC", "USDC.e"].find(
+    (token) => IterableTokenSymbolsMap[token]?.addresses?.[chainId] === l2Token.toNative()
   );
 }
 
 /**
  * @notice Returns the l1 token address matching the given l2TokenAddress and chainId.
  */
-export function getL1TokenAddress(l2TokenAddress: string, chainId: number): string {
-  if (chainIsL1(chainId)) return l2TokenAddress;
-  const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(({ addresses }) => addresses[chainId] === l2TokenAddress);
+export function getL1TokenAddress(l2TokenAddress: Address, chainId: number): EvmAddress {
+  if (chainIsL1(chainId)) {
+    assert(l2TokenAddress.isEVM());
+    return l2TokenAddress;
+  }
+
+  const tokenObject = Object.values(TOKEN_SYMBOLS_MAP).find(
+    ({ addresses }) => l2TokenAddress.toNative() === addresses[chainId]
+  );
   const l1TokenAddress = tokenObject?.addresses[chainIsProd(chainId) ? CHAIN_IDs.MAINNET : CHAIN_IDs.SEPOLIA];
   if (!l1TokenAddress) {
-    throw new Error(
-      `TokenUtils#getL1TokenInfo: Unable to resolve l1 token address in TOKEN_SYMBOLS_MAP for L2 token ${l2TokenAddress} on chain ${chainId}`
-    );
+    throw new Error(`getL1TokenAddress: Unable to resolve l1 token for L2 token ${l2TokenAddress} on chain ${chainId}`);
   }
-  return l1TokenAddress;
+
+  return EvmAddress.from(l1TokenAddress);
 }