@across-protocol/sdk 4.2.16 → 4.3.1

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -5,33 +5,35 @@ import {
   DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM,
   TOKEN_SYMBOLS_MAP,
 } from "../constants";
-import { Deposit } from "../interfaces";
+import { RelayData } from "../interfaces";
 import {
   BigNumber,
   BigNumberish,
-  ConvertDecimals,
   MAX_BIG_INT,
   TransactionCostEstimate,
   bnZero,
-  chainIsSvm,
-  compareAddressesSimple,
   fixedPointAdjustment,
   getTokenInfo,
   isDefined,
-  isZeroAddress,
   max,
   min,
   nativeToToken,
   percent,
   toBN,
   toBNWei,
+  compareAddressesSimple,
+  ConvertDecimals,
+  chainIsSvm,
+  Address,
+  EvmAddress,
+  SvmAddress,
 } from "../utils";
 
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
 export interface QueryInterface {
   getGasCosts: (
-    deposit: Omit<Deposit, "messageHash">,
-    relayer: string,
+    deposit: RelayData & { destinationChainId: number },
+    relayer: Address,
     options?: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -42,7 +44,7 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: string) => Promise<BigNumber>;
+  getNativeGasCost: (deposit: RelayData & { destinationChainId: number }, relayer: Address) => Promise<BigNumber>;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -112,10 +114,10 @@ export const DEFAULT_LOGGER: Logger = {
   error: (...args) => console.error(args),
 };
 
-export function getDefaultSimulatedRelayerAddress(chainId?: number) {
+export function getDefaultRelayer(chainId?: number): Address {
   return isDefined(chainId) && chainIsSvm(chainId)
-    ? DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM
-    : DEFAULT_SIMULATED_RELAYER_ADDRESS;
+    ? SvmAddress.from(DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM)
+    : EvmAddress.from(DEFAULT_SIMULATED_RELAYER_ADDRESS);
 }
 
 // Small amount to simulate filling with. Should be low enough to guarantee a successful fill.
@@ -251,10 +253,10 @@ export class RelayFeeCalculator {
    *       the correct parameters to see a full fill.
    */
   async gasFeePercent(
-    deposit: Deposit,
+    deposit: RelayData & { destinationChainId: number },
     outputAmount: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = getDefaultRelayer(deposit.destinationChainId),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -271,14 +273,14 @@ export class RelayFeeCalculator {
     // undefined address on destination.
     const destinationChainTokenDetails = Object.values(tokenMapping).find(
       (details) =>
-        compareAddressesSimple(details.addresses[originChainId], inputToken) &&
+        compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
         isDefined(details.addresses[destinationChainId])
     );
-    const outputToken = isZeroAddress(deposit.outputToken)
+    const outputToken = deposit.outputToken.isZeroAddress()
       ? destinationChainTokenDetails!.addresses[destinationChainId]
-      : deposit.outputToken;
+      : deposit.outputToken.toNative();
     const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
+    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId, tokenMapping);
     if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }
@@ -490,10 +492,10 @@ export class RelayFeeCalculator {
    * @returns A resulting `RelayerFeeDetails` object
    */
   async relayerFeeDetails(
-    deposit: Deposit,
+    deposit: RelayData & { destinationChainId: number },
     outputAmount?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = getDefaultRelayer(deposit.destinationChainId),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,
@@ -505,8 +507,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, originChainId);
-    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId);
+    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId);
+    const outputTokenInfo = getTokenInfo(outputToken.toNative(), destinationChainId);
     if (!isDefined(inputTokenInfo) || !isDefined(outputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }

package/src/utils/AddressUtils.ts

@@ -81,15 +81,15 @@ export function isValidEvmAddress(address: string): boolean {
 export function toAddressType(address: string, chainId: number): Address {
   const rawAddress = address.startsWith("0x") ? utils.arrayify(address) : bs58.decode(address);
 
-  const isEvm = chainIsEvm(chainId);
-  if (isEvm && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
-  if (!isEvm && SvmAddress.validate(rawAddress)) return new SvmAddress(rawAddress);
-  return new Address(rawAddress);
+  if (chainIsEvm(chainId) && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
+  else if (chainIsSvm(chainId) && SvmAddress.validate(rawAddress)) return new SvmAddress(rawAddress);
+
+  return new RawAddress(rawAddress);
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
 // which for this class, is a bytes32 hex string.
-export class Address {
+export abstract class Address {
   readonly rawAddress: Uint8Array;
 
   // Keep all address types in cache so that we may lazily evaluate them when necessary.
@@ -109,10 +109,6 @@ export class Address {
     this.rawAddress = utils.zeroPad(_rawAddress, 32);
   }
 
-  static __unsafeConstruct(_rawAddress: Uint8Array): Address {
-    return new this(_rawAddress);
-  }
-
   // Converts the address into a bytes32 string. Note that the output bytes will be lowercase so that it matches ethers event data. This function will never
   // throw since address length validation was done at construction time.
   toBytes32(): string {
@@ -167,11 +163,6 @@ export class Address {
     return false;
   }
 
-  // Checks if the object is an address by looking at whether it has an Address constructor.
-  static isAddress(obj: unknown): boolean {
-    return obj instanceof this;
-  }
-
   // Converts the input address to a 32-byte hex data string.
   toString(): string {
     return this.toNative();
@@ -193,6 +184,7 @@ export class Address {
   }
 
   // Compares Addresses by first converting them to BigNumbers.
+  // note: Intended for use when sorting like addresses.
   compare(otherAddress: Address): 1 | -1 | 0 {
     // Convert address strings to BigNumbers and then sort numerical value of the BigNumber, which sorts the addresses
     // effectively by their hex value.
@@ -207,20 +199,18 @@ export class Address {
     }
   }
 
-  static isEvmAddress(address: Address): boolean {
-    return address instanceof EvmAddress;
+  isEVM(): this is EvmAddress {
+    return false;
   }
 
-  static isSvmAddress(address: Address): boolean {
-    return address instanceof SvmAddress;
+  isSVM(): this is SvmAddress {
+    return false;
   }
 }
 
 // Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
 export class EvmAddress extends Address {
-  // @dev This property is required for Typescript typechecker to know to distinguish between `Address`, `SvmAddress` and `EvmAddress`.
-  // Otherwise it lets any of these to use in place where other is expected.
-  private readonly _brandEvmAddress!: void;
+  private readonly _type = "evm";
 
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
   constructor(rawAddress: Uint8Array) {
@@ -229,8 +219,7 @@ export class EvmAddress extends Address {
     }
 
     super(rawAddress);
-    // @dev required for TS to compile with `noUnusedLocals` rule
-    this._brandEvmAddress;
+    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
@@ -239,34 +228,24 @@ export class EvmAddress extends Address {
     );
   }
 
+  override isEVM(): this is EvmAddress {
+    return true;
+  }
+
   // Override `toAddress` to return the 20-byte representation address.
   override toNative(): string {
     return this.toEvmAddress();
   }
 
   // Constructs a new EvmAddress type.
-  static from(address: string, encoding: "base16" | "base58" = "base16"): EvmAddress {
-    if (encoding === "base16") {
-      return new this(utils.arrayify(address));
-    }
-
-    const decodedAddress = bs58.decode(address);
-    const padding = decodedAddress.subarray(0, 12);
-    const evmAddress = decodedAddress.subarray(12);
-
-    if (padding.length !== 12 || utils.stripZeros(padding).length !== 0 || evmAddress.length !== 20) {
-      throw new Error(`Not a valid base58-encoded EVM address: ${address}`);
-    }
-
-    return new this(evmAddress);
+  static from(address: string, encoding: "base58" | "base16" = "base16"): EvmAddress {
+    return encoding === "base16" ? new this(utils.arrayify(address)) : new this(bs58.decode(address));
   }
 }
 
 // Subclass of address which strictly deals SVM addresses. These addresses are guaranteed to be valid SVM addresses, so `toBase58` will always produce a valid Solana address.
 export class SvmAddress extends Address {
-  // @dev This property is required for Typescript typechecker to know to distinguish between `Address`, `SvmAddress` and `EvmAddress`.
-  // Otherwise it lets any of these to use in place where other is expected.
-  private readonly _brandSvmAddress!: void;
+  private readonly _type = "svm";
 
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
@@ -275,12 +254,21 @@ export class SvmAddress extends Address {
     }
 
     super(rawAddress);
-    // @dev required for TS to compile with `noUnusedLocals` rule
-    this._brandSvmAddress;
+    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
-    return rawAddress.length === 32;
+    // Deliberately invalidate SVM addresses w/ the upper 12 bytes zeroed. These addresses are technically valid
+    // but highly improbable and are much more likely to be a mistaken interpretation of an EVM address. Err on
+    // the side of caution for the time being. Exception: Permit the zero address (i.e. for exclusiverRelayer).
+    return (
+      rawAddress.length === 32 &&
+      (!rawAddress.slice(0, 12).every((field) => field === 0) || rawAddress.every((field) => field === 0))
+    );
+  }
+
+  override isSVM(): this is SvmAddress {
+    return true;
   }
 
   // Override the toAddress function for SVM addresses only since while they will never have a defined 20-byte representation. The base58 encoded addresses are also the encodings
@@ -291,15 +279,15 @@ export class SvmAddress extends Address {
 
   // Constructs a new SvmAddress type.
   static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
-    if (encoding === "base58") {
-      return new this(bs58.decode(address));
-    }
+    return encoding === "base58" ? new this(bs58.decode(address)) : new this(utils.arrayify(address));
+  }
+}
 
-    const decodedAddress = utils.arrayify(address);
-    if (decodedAddress.length !== 32) {
-      throw new Error(`Not a valid base16-encoded SVM address: ${address}`);
-    }
+export class RawAddress extends Address {
+  private readonly _type = "raw";
 
-    return new this(decodedAddress);
+  constructor(rawAddress: Uint8Array) {
+    super(rawAddress);
+    this._type; // tsc noUnusedLocals appeasement.
   }
 }

package/src/utils/DepositUtils.ts

@@ -2,7 +2,7 @@ import assert from "assert";
 import { SpokePoolClient } from "../clients";
 import { DEFAULT_CACHING_TTL, EMPTY_MESSAGE, UNDEFINED_MESSAGE_HASH, ZERO_BYTES } from "../constants";
 import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, RelayData, SlowFillRequest } from "../interfaces";
-import { getMessageHash, isUnsafeDepositId, isZeroAddress } from "./SpokeUtils";
+import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getNetworkName } from "./NetworkUtils";
 import { bnZero } from "./BigNumberUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
@@ -204,13 +204,13 @@ export function validateFillForDeposit(
  * @param deposit Deposit to check.
  * @returns True if deposit's input amount is 0 and message is empty.
  */
-export function isZeroValueDeposit(deposit: Pick<Deposit, "inputAmount" | "message">): boolean {
+export function isZeroValueDeposit(deposit: Pick<RelayData, "inputAmount" | "message">): boolean {
   return deposit.inputAmount.eq(0) && isMessageEmpty(deposit.message);
 }
 
-export function invalidOutputToken(deposit: Pick<DepositWithBlock, "outputToken">): boolean {
+export function invalidOutputToken(deposit: Pick<RelayData, "outputToken">): boolean {
   // If the output token is zero address, then it is invalid.
-  return isZeroAddress(deposit.outputToken);
+  return deposit.outputToken.isZeroAddress();
 }
 
 export function isZeroValueFillOrSlowFillRequest(

package/src/utils/SpokeUtils.ts

@@ -1,8 +1,7 @@
 import { encodeAbiParameters, Hex, keccak256 } from "viem";
 import { fixedPointAdjustment as fixedPoint } from "./common";
-import { MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
-import { Deposit, Fill, FillType, RelayData, SlowFillLeaf } from "../interfaces";
-import { toBytes32 } from "./AddressUtils";
+import { MAX_SAFE_DEPOSIT_ID, ZERO_BYTES } from "../constants";
+import { Fill, FillType, RelayData, SlowFillLeaf } from "../interfaces";
 import { BigNumber } from "./BigNumberUtils";
 import { isMessageEmpty } from "./DepositUtils";
 import { chainIsSvm } from "./NetworkUtils";
@@ -16,28 +15,6 @@ export function getSlowFillLeafLpFeePct(leaf: SlowFillLeaf): BigNumber {
   const { relayData, updatedOutputAmount } = leaf;
   return relayData.inputAmount.sub(updatedOutputAmount).mul(fixedPoint).div(relayData.inputAmount);
 }
-/**
- * Produce the RelayData for a Deposit.
- * @param deposit Deposit instance.
- * @returns The corresponding RelayData object.
- */
-export function getDepositRelayData(deposit: Omit<Deposit, "messageHash">): RelayData {
-  return {
-    depositor: toBytes32(deposit.depositor),
-    recipient: toBytes32(deposit.recipient),
-    exclusiveRelayer: toBytes32(deposit.exclusiveRelayer),
-    inputToken: toBytes32(deposit.inputToken),
-    outputToken: toBytes32(deposit.outputToken),
-    inputAmount: deposit.inputAmount,
-    outputAmount: deposit.outputAmount,
-    originChainId: deposit.originChainId,
-    depositId: deposit.depositId,
-    fillDeadline: deposit.fillDeadline,
-    exclusivityDeadline: deposit.exclusivityDeadline,
-    message: deposit.message,
-  };
-}
-
 /**
  * Compute the RelayData hash for a fill. This can be used to determine the fill status.
  * @param relayData RelayData information that is used to complete a fill.
@@ -68,14 +45,14 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
 
   const _relayData = {
     ...relayData,
-    depositor: toBytes32(relayData.depositor),
-    recipient: toBytes32(relayData.recipient),
-    inputToken: toBytes32(relayData.inputToken),
-    outputToken: toBytes32(relayData.outputToken),
-    exclusiveRelayer: toBytes32(relayData.exclusiveRelayer),
+    depositor: relayData.depositor.toBytes32(),
+    recipient: relayData.recipient.toBytes32(),
+    inputToken: relayData.inputToken.toBytes32(),
+    outputToken: relayData.outputToken.toBytes32(),
+    exclusiveRelayer: relayData.exclusiveRelayer.toBytes32(),
   };
   if (chainIsSvm(destinationChainId)) {
-    return svm.getRelayDataHash(_relayData, destinationChainId);
+    return svm.getRelayDataHash(relayData, destinationChainId);
   }
   return keccak256(encodeAbiParameters(abi, [_relayData, destinationChainId]));
 }
@@ -94,11 +71,6 @@ export function isUnsafeDepositId(depositId: BigNumber): boolean {
   return maxSafeDepositId.lt(depositId);
 }
 
-// Determines if the input address (either a bytes32 or bytes20) is the zero address.
-export function isZeroAddress(address: string): boolean {
-  return address === ZERO_ADDRESS || address === ZERO_BYTES;
-}
-
 export function getMessageHash(message: string): string {
   return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as Hex);
 }

package/src/utils/TokenUtils.ts

@@ -1,20 +1,21 @@
+import assert from "assert";
 import { BlockTag } from "@ethersproject/abstract-provider";
 import { Contract, providers, Signer } from "ethers";
 import * as constants from "../constants";
-import { L1Token } from "../interfaces";
+import { L1TokenInfo, TokenInfo } from "../interfaces";
 import { ERC20__factory } from "../typechain";
 import { BigNumber } from "./BigNumberUtils";
 import { getNetworkName, chainIsL1, chainIsProd } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
-import { compareAddressesSimple, toAddressType } from "./AddressUtils";
+import { compareAddressesSimple, EvmAddress, toAddressType } from "./AddressUtils";
 const { TOKEN_SYMBOLS_MAP, CHAIN_IDs, TOKEN_EQUIVALENCE_REMAPPING } = constants;
 
 type SignerOrProvider = providers.Provider | Signer;
 
-export async function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<L1Token> {
+export async function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<L1TokenInfo> {
   const token = new Contract(address, ERC20__factory.abi, signerOrProvider);
   const [symbol, decimals] = await Promise.all([token.symbol(), token.decimals()]);
-  return { address, symbol, decimals };
+  return { address: EvmAddress.from(address), symbol, decimals };
 }
 
 export const getL2TokenAddresses = (
@@ -33,7 +34,7 @@ export const getL2TokenAddresses = (
  * @param chainId Chain ID to query on.
  * @returns Symbol, decimals and contract address on the requested chain.
  */
-export function resolveSymbolOnChain(chainId: number, symbol: string): L1Token {
+export function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo {
   // @dev Suppress tsc complaints by casting symbol to the expected type.
   const token = TOKEN_SYMBOLS_MAP[symbol as keyof typeof TOKEN_SYMBOLS_MAP];
   if (!isDefined(token) || !isDefined(token.addresses[chainId])) {
@@ -42,7 +43,8 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): L1Token {
   }
 
   const { decimals, addresses } = token;
-  const address = addresses[chainId];
+  const address = toAddressType(addresses[chainId], chainId);
+  assert(address.isEVM() || address.isSVM());
 
   return { symbol, decimals, address };
 }
@@ -111,7 +113,7 @@ export function isStablecoin(tokenSymbol: string): boolean {
  * @param tokenMapping
  * @returns
  */
-export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): L1Token {
+export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): TokenInfo {
   const parsedAddress = toAddressType(l2TokenAddress, chainId).toNative();
 
   // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
@@ -127,7 +129,7 @@ export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMappi
     tokenObject = tokenMapping[l1TokenSymbol as keyof typeof tokenMapping];
   }
   return {
-    address: l2TokenAddress,
+    address: toAddressType(l2TokenAddress, chainId),
     symbol: tokenObject.symbol,
     decimals: tokenObject.decimals,
   };