@across-protocol/sdk 4.3.2 → 4.3.4

package/src/relayFeeCalculator/chain-queries/svmQuery.ts

@@ -1,33 +1,11 @@
 import assert from "assert";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
-import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
-import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, fetchMint } from "@solana-program/token";
-import { getComputeUnitEstimateForTransactionMessageFactory } from "@solana/kit";
-import {
-  SVMProvider,
-  SolanaVoidSigner,
-  createFillInstruction,
-  getAssociatedTokenAddress,
-  getEventAuthority,
-  getFillRelayDelegatePda,
-  getFillStatusPda,
-  getStatePda,
-  toAddress,
-} from "../../arch/svm";
+import { getComputeUnitEstimateForTransactionMessageFactory, TransactionSigner } from "@solana/kit";
+import { SVMProvider, SolanaVoidSigner, getFillRelayTx } from "../../arch/svm";
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
 import { getGasPriceEstimate } from "../../gasPriceOracle";
 import { RelayData } from "../../interfaces";
-import {
-  Address,
-  BigNumber,
-  BigNumberish,
-  SvmAddress,
-  TransactionCostEstimate,
-  getRelayDataHash,
-  toBN,
-} from "../../utils";
+import { Address, BigNumber, BigNumberish, SvmAddress, TransactionCostEstimate, toBN } from "../../utils";
 import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { SymbolMappingType } from "./";
 
@@ -93,7 +71,7 @@ export class SvmQuery implements QueryInterface {
     const [repaymentChainId, repaymentAddress] = [destinationChainId, relayer]; // These are not important for gas cost simulation.
     const fillRelayTx = await this.getFillRelayTx(
       { ...relayData, recipient, outputToken, exclusiveRelayer },
-      relayer,
+      SolanaVoidSigner(relayer.toBase58()),
       repaymentChainId,
       repaymentAddress
     );
@@ -139,7 +117,7 @@ export class SvmQuery implements QueryInterface {
     const [repaymentChainId, repaymentAddress] = [destinationChainId, relayer]; // These are not important for gas cost simulation.
     const fillRelayTx = await this.getFillRelayTx(
       { ...deposit, recipient, outputToken, exclusiveRelayer },
-      relayer,
+      SolanaVoidSigner(relayer.toBase58()),
       repaymentChainId,
       repaymentAddress
     );
@@ -158,75 +136,11 @@ export class SvmQuery implements QueryInterface {
       recipient: SvmAddress;
       outputToken: SvmAddress;
     },
-    relayer: SvmAddress,
+    signer: TransactionSigner,
     repaymentChainId: number,
     repaymentAddress: Address
   ) {
-    const { depositor, recipient, inputToken, outputToken, exclusiveRelayer, destinationChainId } = relayData;
-
-    // tsc appeasement...should be unnecessary, but isn't. @todo Identify why.
-    assert(recipient.isSVM(), `getFillRelayTx: recipient not an SVM address (${recipient})`);
-    assert(
-      repaymentAddress.isValidOn(repaymentChainId),
-      `getFillRelayTx: repayment address ${repaymentAddress} not valid on chain ${repaymentChainId})`
-    );
-
-    const program = toAddress(this.spokePool);
-    const _relayDataHash = getRelayDataHash(relayData, destinationChainId);
-    const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
-
-    const [state, delegate] = await Promise.all([
-      getStatePda(program),
-      getFillRelayDelegatePda(relayDataHash, BigInt(repaymentChainId), toAddress(repaymentAddress), program),
-    ]);
-
-    const mint = toAddress(outputToken);
-    const mintInfo = await fetchMint(this.provider, mint);
-
-    const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
-      getAssociatedTokenAddress(recipient, outputToken, mintInfo.programAddress),
-      getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), outputToken, mintInfo.programAddress),
-      getFillStatusPda(program, relayData, destinationChainId),
-      getEventAuthority(program),
-    ]);
-
-    const svmRelayData: SvmSpokeClient.FillRelayInput["relayData"] = {
-      depositor: toAddress(depositor),
-      recipient: toAddress(recipient),
-      exclusiveRelayer: toAddress(exclusiveRelayer),
-      inputToken: toAddress(inputToken),
-      outputToken: mint,
-      inputAmount: relayData.inputAmount.toBigInt(),
-      outputAmount: relayData.outputAmount.toBigInt(),
-      originChainId: relayData.originChainId,
-      depositId: new Uint8Array(intToU8Array32(relayData.depositId.toNumber())),
-      fillDeadline: relayData.fillDeadline,
-      exclusivityDeadline: relayData.exclusivityDeadline,
-      message: new Uint8Array(Buffer.from(relayData.message, "hex")),
-    };
-
-    const simulatedSigner = SolanaVoidSigner(relayer.toBase58());
-    const fillInput: SvmSpokeClient.FillRelayInput = {
-      signer: simulatedSigner,
-      state,
-      delegate,
-      mint,
-      relayerTokenAccount: relayerAta,
-      recipientTokenAccount: recipientAta,
-      fillStatus,
-      tokenProgram: mintInfo.programAddress,
-      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-      systemProgram: SYSTEM_PROGRAM_ADDRESS,
-      eventAuthority,
-      program,
-      relayHash: relayDataHash,
-      relayData: svmRelayData,
-      repaymentChainId: BigInt(repaymentChainId),
-      repaymentAddress: toAddress(repaymentAddress),
-    };
-    // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
-    // if it doesn't exist.
-    return createFillInstruction(simulatedSigner, this.provider, fillInput, mintInfo.data.decimals, true);
+    return await getFillRelayTx(this.spokePool, this.provider, relayData, signer, repaymentChainId, repaymentAddress);
   }
 
   /**

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/AddressUtils.ts

@@ -90,6 +90,7 @@ export function toAddressType(address: string, chainId: number): Address {
 // 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 abstract class Address {
+  readonly __address_type_brand = true;
   readonly rawAddress: Uint8Array;
 
   // Keep all address types in cache so that we may lazily evaluate them when necessary.
@@ -109,6 +110,10 @@ export abstract class Address {
     this.rawAddress = utils.zeroPad(_rawAddress, 32);
   }
 
+  static isAddress(obj: unknown): obj is Address {
+    return "__address_type_brand" in (obj as { __address_type_brand: boolean });
+  }
+
   // 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 {

package/src/utils/DepositUtils.ts

@@ -1,7 +1,16 @@
 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 {
+  CachingMechanismInterface,
+  Deposit,
+  DepositWithBlock,
+  Fill,
+  RelayData,
+  SlowFillRequest,
+  ConvertedRelayData,
+  ConvertedFill,
+} from "../interfaces";
 import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
 import { getNetworkName } from "./NetworkUtils";
 import { bnZero } from "./BigNumberUtils";
@@ -251,3 +260,42 @@ export function resolveDepositMessage(deposit: Deposit): string {
   assert(isDefined(message)); // Appease tsc about the updatedMessage being possibly undefined.
   return message;
 }
+
+/**
+ * Converts a RelayData object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has strings as fields.
+ */
+export function convertRelayDataParamsToBytes32(relayData: RelayData): ConvertedRelayData {
+  return {
+    ...relayData,
+    depositor: relayData.depositor.toBytes32(),
+    recipient: relayData.recipient.toBytes32(),
+    inputToken: relayData.inputToken.toBytes32(),
+    outputToken: relayData.outputToken.toBytes32(),
+    exclusiveRelayer: relayData.exclusiveRelayer.toBytes32(),
+  };
+}
+
+/**
+ * Converts a Fill object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has strings as fields.
+ */
+export function convertFillParamsToBytes32(fill: Fill): ConvertedFill {
+  return {
+    ...fill,
+    depositor: fill.depositor.toBytes32(),
+    recipient: fill.recipient.toBytes32(),
+    inputToken: fill.inputToken.toBytes32(),
+    outputToken: fill.outputToken.toBytes32(),
+    exclusiveRelayer: fill.exclusiveRelayer.toBytes32(),
+    relayer: fill.relayer.toBytes32(),
+    relayExecutionInfo: {
+      ...fill.relayExecutionInfo,
+      updatedRecipient: fill.relayExecutionInfo.updatedRecipient.toBytes32(),
+    },
+  };
+}

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