@across-protocol/sdk 4.3.62 → 4.3.64

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

@@ -160,6 +160,16 @@ export class QueryBase implements QueryInterface {
     return voidSigner.estimateGas(unsignedTx);
   }
 
+  /**
+   * @notice Return the native token cost of filling a deposit beyond gas cost. We're not using msg.value in our fills,
+   * so return zero for EVM side
+   * @param deposit RelayData associated with Deposit we're estimating for
+   * @returns Native token cost
+   */
+  getAuxiliaryNativeTokenCost(_deposit: RelayData): BigNumber {
+    return bnZero;
+  }
+
   /**
    * @notice Return L1 data fee for OP stack L2 transaction, which is based on L2 calldata.
    * @dev https://docs.optimism.io/stack/transactions/fees#l1-data-fee

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

@@ -5,12 +5,28 @@ import {
   fetchEncodedAccount,
   isSome,
 } from "@solana/kit";
-import { SVMProvider, SolanaVoidSigner, getFillRelayTx, toAddress, getAssociatedTokenAddress } from "../../arch/svm";
+import {
+  SVMProvider,
+  SolanaVoidSigner,
+  getFillRelayTx,
+  toAddress,
+  getAssociatedTokenAddress,
+  deserializeMessage,
+} 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, toBN } from "../../utils";
+import {
+  Address,
+  BigNumber,
+  BigNumberish,
+  SvmAddress,
+  TransactionCostEstimate,
+  bnZero,
+  isMessageEmpty,
+  toBN,
+} from "../../utils";
 import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { SymbolMappingType } from "./";
 import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
@@ -156,6 +172,20 @@ export class SvmQuery implements QueryInterface {
     return toBN(await this.computeUnitEstimator(fillRelayTx));
   }
 
+  /**
+   * @notice Return the native token cost of filling a deposit beyond gas cost. If `value_amount` is specified in a message,
+   * `value_amount` of SOL gets forwarded to the first Account. We account for that in Fill cost estimation
+   * @param deposit RelayData associated with Deposit we're estimating for
+   * @throws If deposit.message is malformed (unable to be deserialized into `AcrossPlusMessage`)
+   * @returns Native token cost
+   */
+  getAuxiliaryNativeTokenCost(deposit: RelayData): BigNumber {
+    // Notice. We return `message.value_amount` here instead of simulating the Transaction. The reason is, we choose to
+    // rely hard on Solana program to protect us from not taking more than `value_amount` rather than relying on
+    // simulation. Chain state may change between simulation and execution, so simulation alone is unreliable
+    return isMessageEmpty(deposit.message) ? bnZero : BigNumber.from(deserializeMessage(deposit.message).value_amount);
+  }
+
   /**
    * @notice Return the fillRelay transaction for a given deposit
    * @param relayData RelayData instance, supplemented with destinationChainId

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -5,7 +5,7 @@ import {
   DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM,
   TOKEN_SYMBOLS_MAP,
 } from "../constants";
-import { RelayData } from "../interfaces";
+import { RelayData, TokenInfo } from "../interfaces";
 import {
   BigNumber,
   BigNumberish,
@@ -46,6 +46,7 @@ export interface QueryInterface {
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
   getNativeGasCost: (deposit: RelayData & { destinationChainId: number }, relayer: Address) => Promise<BigNumber>;
+  getAuxiliaryNativeTokenCost(deposit: RelayData): BigNumber;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -86,6 +87,9 @@ export interface RelayerFeeDetails {
   gasFeePercent: string;
   gasFeeTotal: string;
   gasDiscountPercent: number;
+  auxNativeFeePercent: string;
+  auxNativeFeeTotal: string;
+  auxNativeDiscountPercent: number;
   capitalFeePercent: string;
   capitalFeeTotal: string;
   capitalDiscountPercent: number;
@@ -256,10 +260,10 @@ export class RelayFeeCalculator {
   async gasFeePercent(
     deposit: RelayData & { destinationChainId: number },
     outputAmount: BigNumberish,
+    outputTokenInfo: TokenInfo,
     simulateZeroFill = false,
     relayerAddress = getDefaultRelayer(deposit.destinationChainId),
     _tokenPrice?: number,
-    tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
     gasLimit?: BigNumberish,
     _tokenGasCost?: BigNumberish,
@@ -267,25 +271,6 @@ export class RelayFeeCalculator {
   ): Promise<BigNumber> {
     if (toBN(outputAmount).eq(bnZero)) return MAX_BIG_INT;
 
-    const { inputToken, destinationChainId, originChainId } = deposit;
-    // It's fine if we resolve a destination token which is not the "canonical" L1 token (e.g. USDB for DAI or USDC.e for USDC), since `getTokenInfo` will re-map
-    // the output token to the canonical version. What matters here is that we find an entry in the token map which has defined addresses for BOTH the origin
-    // and destination chain. This prevents the call to `getTokenInfo` to mistakenly return token info for a token which has a defined address on origin and an
-    // undefined address on destination.
-    const destinationChainTokenDetails = Object.values(tokenMapping).find(
-      (details) =>
-        compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
-        isDefined(details.addresses[destinationChainId])
-    );
-    const outputToken = deposit.outputToken.isZeroAddress()
-      ? toAddressType(destinationChainTokenDetails!.addresses[destinationChainId], destinationChainId)
-      : deposit.outputToken;
-    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
-    if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
-      throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
-    }
-
     // Reduce the output amount to simulate a full fill with a lower value to estimate
     // the fill cost accurately without risking a failure due to insufficient balance.
     const simulatedAmount = simulateZeroFill ? safeOutputAmount : toBN(outputAmount);
@@ -306,22 +291,43 @@ export class RelayFeeCalculator {
       });
     const [tokenGasCost, tokenPrice] = await Promise.all([
       _tokenGasCost ? Promise.resolve(_tokenGasCost) : getGasCosts,
-      _tokenPrice ??
-        this.queries.getTokenPrice(outputTokenInfo.symbol).catch((error) => {
-          this.logger.error({
-            at: "sdk/gasFeePercent",
-            message: "Error while fetching token price",
-            error,
-            destinationChainId: deposit.destinationChainId,
-            inputToken,
-          });
-          throw error;
-        }),
+      this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit),
     ]);
     const gasFeesInToken = nativeToToken(tokenGasCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
     return percent(gasFeesInToken, outputAmount.toString());
   }
 
+  /**
+   * Calculate the auxiliary native token fee as a % of the amount to relay.
+   * Treats auxiliary native outlay as value forwarded to user, reported separately.
+   */
+  async auxNativeFeePercent(
+    deposit: RelayData & { destinationChainId: number },
+    outputAmount: BigNumberish,
+    outputTokenInfo: TokenInfo,
+    _tokenPrice?: number
+  ): Promise<BigNumber> {
+    if (toBN(outputAmount).eq(bnZero)) return MAX_BIG_INT;
+
+    let auxNativeCost = bnZero;
+    try {
+      auxNativeCost = this.queries.getAuxiliaryNativeTokenCost(deposit);
+    } catch (error) {
+      this.logger.error({
+        at: "sdk/auxNativeFeePercent",
+        message: "Error while fetching auxiliary native token cost",
+        error,
+        destinationChainId: deposit.destinationChainId,
+        inputToken: deposit.inputToken,
+      });
+      throw error;
+    }
+
+    const tokenPrice = await this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit);
+    const auxFeesInToken = nativeToToken(auxNativeCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
+    return percent(auxFeesInToken, outputAmount);
+  }
+
   // Note: these variables are unused now, but may be needed in future versions of this function that are more complex.
   capitalFeePercent(
     _outputAmount: BigNumberish,
@@ -505,22 +511,17 @@ export class RelayFeeCalculator {
     // If the amount to relay is not provided, then we
     // should use the full deposit amount.
     outputAmount ??= deposit.outputAmount;
-    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);
-    if (!isDefined(inputTokenInfo) || !isDefined(outputTokenInfo)) {
-      throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
-    }
+    const { inputTokenInfo, outputTokenInfo } = this.resolveInOutTokenInfos(deposit);
+
+    const tokenPrice = await this.resolveTokenPrice(outputTokenInfo, _tokenPrice, deposit);
 
     const gasFeePercent = await this.gasFeePercent(
       deposit,
       outputAmount,
+      outputTokenInfo,
       simulateZeroFill,
       relayerAddress,
-      _tokenPrice,
-      undefined,
+      tokenPrice,
       gasPrice,
       gasUnits,
       tokenGasCost
@@ -534,16 +535,28 @@ export class RelayFeeCalculator {
       deposit.destinationChainId.toString()
     );
     const capitalFeeTotal = capitalFeePercent.mul(outToInDecimals(outputAmount.toString())).div(fixedPointAdjustment);
-    const relayFeePercent = gasFeePercent.add(capitalFeePercent);
-    const relayFeeTotal = gasFeeTotal.add(capitalFeeTotal);
 
-    // We don't want the relayer to incur an excessive gas fee charge as a % of the deposited total.
-    // The maximum gas fee % charged is equal to the remaining fee % leftover after subtracting the capital fee %
+    const auxNativeFeePercent = await this.auxNativeFeePercent(deposit, outputAmount, outputTokenInfo, tokenPrice);
+    const auxNativeFeeTotal = auxNativeFeePercent
+      .mul(outToInDecimals(outputAmount.toString()))
+      .div(fixedPointAdjustment);
+    const auxNativeDiscountPercent = this.gasDiscountPercent;
+
+    const relayFeePercent = gasFeePercent.add(capitalFeePercent).add(auxNativeFeePercent);
+    const relayFeeTotal = gasFeeTotal.add(capitalFeeTotal).add(auxNativeFeeTotal);
+
+    // We don't want the relayer to incur an excessive gas fee charge as a % of the deposited total. The maximum
+    // gas fee % charged is equal to the remaining fee % leftover after subtracting the capital fee % and aux fee %
     // from the fee limit %. We then compute the minimum deposited amount required to not exceed the maximum
     // gas fee %: maxGasFeePercent = gasFeeTotal / minDeposit. Refactor this to figure out the minDeposit:
     // minDeposit = gasFeeTotal / maxGasFeePercent, and subsequently determine
     // isAmountTooLow = amountToRelay < minDeposit.
-    const maxGasFeePercent = max(toBNWei(this.feeLimitPercent / 100).sub(capitalFeePercent), toBN(0));
+    const maxGasFeePercent = max(
+      toBNWei(this.feeLimitPercent / 100)
+        .sub(capitalFeePercent)
+        .sub(auxNativeFeePercent),
+      toBN(0)
+    );
     // If maxGasFee % is 0, then the min deposit should be infinite because there is no deposit amount that would
     // incur a non zero gas fee % charge. In this case, isAmountTooLow should always be true.
     let minDeposit: BigNumber, isAmountTooLow: boolean;
@@ -561,6 +574,9 @@ export class RelayFeeCalculator {
       gasFeePercent: gasFeePercent.toString(),
       gasFeeTotal: gasFeeTotal.toString(),
       gasDiscountPercent: this.gasDiscountPercent,
+      auxNativeFeePercent: auxNativeFeePercent.toString(),
+      auxNativeFeeTotal: auxNativeFeeTotal.toString(),
+      auxNativeDiscountPercent,
       capitalFeePercent: capitalFeePercent.toString(),
       capitalFeeTotal: capitalFeeTotal.toString(),
       capitalDiscountPercent: this.capitalDiscountPercent,
@@ -572,4 +588,52 @@ export class RelayFeeCalculator {
       isAmountTooLow,
     };
   }
+
+  resolveInOutTokenInfos(
+    deposit: RelayData & { destinationChainId: number },
+    tokenMapping = TOKEN_SYMBOLS_MAP
+  ): {
+    inputTokenInfo: TokenInfo;
+    outputTokenInfo: TokenInfo;
+  } {
+    const { inputToken, destinationChainId, originChainId } = deposit;
+    // It's fine if we resolve a destination token which is not the "canonical" L1 token (e.g. USDB for DAI or USDC.e for USDC), since `getTokenInfo` will re-map
+    // the output token to the canonical version. What matters here is that we find an entry in the token map which has defined addresses for BOTH the origin
+    // and destination chain. This prevents the call to `getTokenInfo` to mistakenly return token info for a token which has a defined address on origin and an
+    // undefined address on destination.
+    const destinationChainTokenDetails = Object.values(tokenMapping).find(
+      (details) =>
+        compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
+        isDefined(details.addresses[destinationChainId])
+    );
+    const outputToken = deposit.outputToken.isZeroAddress()
+      ? toAddressType(destinationChainTokenDetails!.addresses[destinationChainId], destinationChainId)
+      : deposit.outputToken;
+    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
+    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
+    if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
+      throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
+    }
+    return { inputTokenInfo, outputTokenInfo };
+  }
+
+  async resolveTokenPrice(
+    outputTokenInfo: TokenInfo,
+    _tokenPrice: number | undefined,
+    deposit: RelayData & { destinationChainId: number }
+  ): Promise<number> {
+    return (
+      _tokenPrice ??
+      (await this.queries.getTokenPrice(outputTokenInfo.symbol).catch((error) => {
+        this.logger.error({
+          at: "sdk/resolveTokenPrice",
+          message: "Error while fetching token price",
+          error,
+          destinationChainId: deposit.destinationChainId,
+          inputToken: deposit.inputToken,
+        });
+        throw error;
+      }))
+    );
+  }
 }

package/src/utils/FormattingUtils.ts

@@ -59,12 +59,12 @@ export const formatFeePct = (relayerFeePct: BN): string => {
 /**
  * Shortens a lengthy hexadecimal string to a shorter version with an ellipsis in the middle.
  * @param hex A hexadecimal string to be shortened.
- * @param maxLength The maximum length of the shortened string. Defaults to 8.
+ * @param maxLength The maximum length of the shortened string.
  * @param delimiter The delimiter to use in the middle of the shortened string. Defaults to "...".
  * @returns The shortened hexadecimal string.
  * @example createShortenedString("0x772871a444c6e4e9903d8533a5a13101b74037158123e6709470f0afbf6e7d94") -> "0x7787...7d94"
  */
-export function createShortenedString(hex: string, maxLength = 8, delimiter = ".."): string {
+export function createShortenedString(hex: string, maxLength = 12, delimiter = ".."): string {
   // If we have more maxLength then the hex size, we can simply
   // return the hex directly.
   if (hex.length <= maxLength) {

package/src/utils/Multicall.ts

@@ -32,6 +32,7 @@ const DETERMINISTIC_MULTICALL_CHAINS = [
   CHAIN_IDs.HYPEREVM,
   CHAIN_IDs.LINEA,
   CHAIN_IDs.MAINNET,
+  CHAIN_IDs.PLASMA,
   CHAIN_IDs.POLYGON,
   CHAIN_IDs.SCROLL,
   // Testnet:
@@ -39,6 +40,7 @@ const DETERMINISTIC_MULTICALL_CHAINS = [
   CHAIN_IDs.SCROLL_SEPOLIA,
   CHAIN_IDs.SEPOLIA,
   CHAIN_IDs.ARBITRUM_SEPOLIA,
+  CHAIN_IDs.PLASMA_TESTNET,
   CHAIN_IDs.TATARA,
   ...Object.keys(hreNetworks).map(Number), // See test/utils/multicall.ts
 ];

package/src/utils/NetworkUtils.ts

@@ -155,7 +155,7 @@ export function chainIsCCTPEnabled(chainId: number): boolean {
 export function chainIsOFTEnabled(chainId: number): boolean {
   // Add chainIds to oftEnabled as they are supported by the protocol.
   // This is backwards vs. CCTP logic because Across support for OFTs is limited vs. OFT deployments.
-  const oftEnabled = [CHAIN_IDs.ARBITRUM, CHAIN_IDs.POLYGON];
+  const oftEnabled = [CHAIN_IDs.ARBITRUM, CHAIN_IDs.POLYGON, CHAIN_IDs.HYPEREVM, CHAIN_IDs.PLASMA];
   return oftEnabled.includes(chainId) && PRODUCTION_NETWORKS[chainId]?.oftEid !== OFT_NO_EID;
 }