@across-protocol/sdk 4.2.16-alpha.0 → 4.2.16-alpha.2

package/src/utils/AddressUtils.ts

@@ -1,7 +1,6 @@
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
-import { Address as V2Address } from "@solana/kit";
-import { BigNumber, chainIsEvm } from "./";
+import { BigNumber, chainIsEvm, chainIsSvm } from "./";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -48,8 +47,9 @@ export function toBytes32(address: string): string {
   return utils.hexZeroPad(address, 32).toLowerCase();
 }
 
-// Checks if the input string can be coerced into a bytes20 evm address. Returns true if it is possible, and false otherwise.
-export function toAddress(hexString: string): string {
+// Constructs a 20-byte checksummed EVM address from a hex string input.
+// Throws an error if the underlying address length is longer than 20 bytes or incorrectly checksummed.
+export function toEvmAddress(hexString: string): string {
   // rawAddress is the address which is not properly checksummed.
   const rawAddress = utils.hexZeroPad(utils.hexStripZeros(hexString), 20);
   return utils.getAddress(rawAddress);
@@ -74,21 +74,17 @@ export function isValidEvmAddress(address: string): boolean {
 /**
  * Creates the proper address type given the input chain ID corresponding to the address's origin network.
  * @param address Stringified address type to convert. Can be either hex encoded or base58 encoded.
- * @param chainId Network ID corresponding to the input address, used to determine which address type to output.
+ * @param chainId Chain ID for the intended use of the address.
  * @returns a child `Address` type most fitting for the chain ID.
  * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
  */
-export function toAddressType(address: string): Address | EvmAddress | SvmAddress {
-  try {
-    if (utils.isHexString(address)) {
-      return EvmAddress.from(address);
-    }
-    return SvmAddress.from(address);
-  } catch (e) {
-    // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
-    // return an unchecked address type.
-    return new Address(utils.arrayify(address));
-  }
+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);
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
@@ -113,12 +109,24 @@ 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 {
     return (this.bytes32Address ??= utils.hexZeroPad(utils.hexlify(this.rawAddress), 32).toLowerCase());
   }
 
+  // Returns last 20 bytes of Address as a hex string. Truncates if necessary. This function is useful for comparing some longer addresses(e.g. Solana) to Solidity events
+  // that contain truncated `address` type as one of the fields
+  truncateToBytes20(): string {
+    // Take the last 20 bytes
+    const bytes20 = this.rawAddress.slice(-20);
+    return toEvmAddress(utils.hexlify(bytes20));
+  }
+
   // Converts the address (can be bytes32 or bytes20) to its base58 counterpart. This conversion will always succeed, even if the input address is not valid on Solana,
   // as this address may be needed to represent an EVM address on Solana.
   toBase58(): string {
@@ -126,7 +134,7 @@ export class Address {
   }
 
   // Converts the address to a BigNumber type.
-  toBigNumber(): BigNumber {
+  private toBigNumber(): BigNumber {
     return (this.bnAddress ??= BigNumber.from(this.toBytes32()));
   }
 
@@ -143,37 +151,20 @@ export class Address {
 
   // Converts the address to a hex string. This method should be overriden by subclasses to obtain more meaningful
   // address representations for the target chain ID.
-  toAddress(): string {
+  toNative(): string {
     return this.toBytes32();
   }
 
-  // Converts the address to a Buffer type.
-  toBuffer(): Buffer {
-    return Buffer.from(this.rawAddress);
-  }
-
   // Implements `Hexable` for `Address`. Needed for encoding purposes. This class is treated by default as a bytes32 primitive type, but can change for subclasses.
   toHexString(): string {
     return this.toBytes32();
   }
 
-  // Checks if this address can be coerced into a bytes20 evm address. Returns true if it is possible and false otherwise.
-  isValidEvmAddress(): boolean {
-    try {
-      this.toAddress();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
   // Checks if the address is valid on the given chain ID.
   isValidOn(chainId: number): boolean {
-    if (chainIsEvm(chainId)) {
-      return this.isValidEvmAddress();
-    }
-    // Assume the address is always valid on Solana.
-    return true;
+    if (chainIsEvm(chainId)) return EvmAddress.validate(this.rawAddress);
+    if (chainIsSvm(chainId)) return SvmAddress.validate(this.rawAddress);
+    return false;
   }
 
   // Checks if the object is an address by looking at whether it has an Address constructor.
@@ -183,7 +174,7 @@ export class Address {
 
   // Converts the input address to a 32-byte hex data string.
   toString(): string {
-    return this.toHexString();
+    return this.toNative();
   }
 
   // Checks if the address is the zero address.
@@ -196,11 +187,6 @@ export class Address {
     return SvmAddress.from(this.toBase58());
   }
 
-  // Forces `rawAddress` to become an EvmAddress type. This will throw if `rawAddress.length > 20`.
-  forceEvmAddress(): EvmAddress {
-    return EvmAddress.from(this.toEvmAddress());
-  }
-
   // Checks if the other address is equivalent to this address.
   eq(other: Address): boolean {
     return this.toString() === other.toString();
@@ -220,21 +206,35 @@ export class Address {
       return 0;
     }
   }
+
+  static isEvmAddress(address: Address): boolean {
+    return address instanceof EvmAddress;
+  }
+
+  static isSvmAddress(address: Address): boolean {
+    return address instanceof SvmAddress;
+  }
 }
 
 // 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 {
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
   constructor(rawAddress: Uint8Array) {
-    super(rawAddress);
-    const hexString = utils.hexlify(rawAddress);
-    if (!this.isValidEvmAddress()) {
-      throw new Error(`${hexString} is not a valid EVM address`);
+    if (!EvmAddress.validate(rawAddress)) {
+      throw new Error(`${utils.hexlify(rawAddress)} is not a valid EVM address`);
     }
+
+    super(rawAddress);
+  }
+
+  static validate(rawAddress: Uint8Array): boolean {
+    return (
+      rawAddress.length == 20 || (rawAddress.length === 32 && rawAddress.slice(0, 12).every((field) => field === 0))
+    );
   }
 
   // Override `toAddress` to return the 20-byte representation address.
-  override toAddress(): string {
+  override toNative(): string {
     return this.toEvmAddress();
   }
 
@@ -260,25 +260,23 @@ export class EvmAddress extends Address {
 export class SvmAddress extends Address {
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
+    if (!SvmAddress.validate(rawAddress)) {
+      throw new Error(`${utils.hexlify(rawAddress)} is not a valid SVM address`); // @todo: Display as Base58?
+    }
+
     super(rawAddress);
   }
 
+  static validate(rawAddress: Uint8Array): boolean {
+    return rawAddress.length === 32;
+  }
+
   // 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
   // used in TOKEN_SYMBOLS_MAP.
-  override toAddress(): string {
+  override toNative(): string {
     return this.toBase58();
   }
 
-  // Small utility to convert an SvmAddress to a Solana Kit branded type.
-  toV2Address(): V2Address<string> {
-    return this.toBase58() as V2Address<string>;
-  }
-
-  // Forces an SvmAddress to an EVM address string by truncating the leading 12 bytes.
-  override toEvmAddress(): string {
-    return toAddress(`0x${this.toBytes32().slice(-40)}`);
-  }
-
   // Constructs a new SvmAddress type.
   static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
     if (encoding === "base58") {

package/src/utils/EventUtils.ts

@@ -3,7 +3,7 @@ import { Result } from "@ethersproject/abi";
 import { Contract, Event, EventFilter } from "ethers";
 import { Log, SortableEvent } from "../interfaces";
 import { delay } from "./common";
-import { isDefined, toBN, BigNumberish, toAddress } from "./";
+import { isDefined, toBN, BigNumberish, toEvmAddress } from "./";
 
 const maxRetries = 3;
 const retrySleepTime = 10;
@@ -88,7 +88,7 @@ export function spreadEvent(args: Result | Record<string, unknown>): { [key: str
     if (isDefined(returnedObject[field])) {
       let address = String(returnedObject[field]);
       try {
-        address = toAddress(address);
+        address = toEvmAddress(address);
         // eslint-disable-next-line no-empty
       } catch (_) {}
       returnedObject[field] = address;

package/src/utils/SpokeUtils.ts

@@ -1,9 +1,9 @@
 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 { Address } from "./AddressUtils";
 import { isMessageEmpty } from "./DepositUtils";
 import { chainIsSvm } from "./NetworkUtils";
 import { svm } from "../arch";
@@ -16,28 +16,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 +46,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]));
 }
@@ -95,8 +73,8 @@ export function isUnsafeDepositId(depositId: BigNumber): boolean {
 }
 
 // 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 isZeroAddress(address: Address): boolean {
+  return address.toBytes32() === ZERO_BYTES;
 }
 
 export function getMessageHash(message: string): string {

package/src/utils/TokenUtils.ts

@@ -1,20 +1,20 @@
 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, chainIsSvm } from "./NetworkUtils";
+import { getNetworkName, chainIsL1, chainIsProd } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
 import { compareAddressesSimple, 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<TokenInfo> {
   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: toAddressType(address, CHAIN_IDs.MAINNET), symbol, decimals };
 }
 
 export const getL2TokenAddresses = (
@@ -33,7 +33,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])) {
@@ -44,7 +44,7 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): L1Token {
   const { decimals, addresses } = token;
   const address = addresses[chainId];
 
-  return { symbol, decimals, address };
+  return { symbol, decimals, address: toAddressType(address, chainId) };
 }
 
 /**
@@ -111,10 +111,9 @@ export function isStablecoin(tokenSymbol: string): boolean {
  * @param tokenMapping
  * @returns
  */
-export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): L1Token {
-  const parsedAddress = chainIsSvm(chainId)
-    ? toAddressType(l2TokenAddress).toBase58()
-    : toAddressType(l2TokenAddress).toEvmAddress();
+export function getTokenInfo(l2TokenAddress: string, chainId: number, tokenMapping = TOKEN_SYMBOLS_MAP): L1TokenInfo {
+  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
   // to get around this...
   let tokenObject = Object.values(tokenMapping).find(({ addresses }) => addresses[chainId] === parsedAddress);
@@ -128,7 +127,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,
   };