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

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,
   };