improve(API): Make gasFeeTotal more accurate in /limits and increase cache hit frequency

api/_utils.ts

@@ -1970,94 +1970,158 @@ export function isContractCache(chainId: number, address: string) {
   );
 }
 
-export function getCachedFillGasUsage(
+export function getCachedNativeGasCost(
   deposit: Parameters<typeof buildDepositForSimulation>[0],
-  gasPrice?: BigNumber,
   overrides?: Partial<{
     relayerAddress: string;
   }>
 ) {
+  // We can use a long TTL since we are fetching only the native gas cost which should rarely change.
   const ttlPerChain = {
-    default: 10,
-    [CHAIN_IDs.ARBITRUM]: 10,
+    default: 60,
   };
 
   const cacheKey = buildInternalCacheKey(
-    "fillGasUsage",
+    "nativeGasCost",
     deposit.destinationChainId,
     deposit.outputToken
   );
-  const ttl = ttlPerChain[deposit.destinationChainId] || ttlPerChain.default;
+  const ttl = ttlPerChain.default;
   const fetchFn = async () => {
+    const relayerAddress =
+      overrides?.relayerAddress ??
+      sdk.constants.DEFAULT_SIMULATED_RELAYER_ADDRESS;
     const relayerFeeCalculatorQueries = getRelayerFeeCalculatorQueries(
       deposit.destinationChainId,
       overrides
     );
+    const unsignedFillTxn =
+      await relayerFeeCalculatorQueries.getUnsignedTxFromDeposit(
+        buildDepositForSimulation(deposit),
+        relayerAddress
+      );
+    const voidSigner = new ethers.VoidSigner(
+      relayerAddress,
+      relayerFeeCalculatorQueries.provider
+    );
+    return voidSigner.estimateGas(unsignedFillTxn);
+  };
+
+  return getCachedValue(cacheKey, ttl, fetchFn, (nativeGasCostFromCache) => {
+    return BigNumber.from(nativeGasCostFromCache);
+  });
+}
+
+export function getCachedOpStackL1DataFee(
+  deposit: Parameters<typeof buildDepositForSimulation>[0],
+  nativeGasCost: BigNumber,
+  overrides?: Partial<{
+    relayerAddress: string;
+  }>
+) {
+  // This should roughly be the length of 1 block on Ethereum mainnet which is how often the L1 data fee should
+  // change since its based on the L1 base fee. However, this L1 data fee is mostly affected by the L1 base fee which
+  // should only change by 12.5% at most per block.
+  const ttlPerChain = {
+    default: 12,
+  };
+
+  const cacheKey = buildInternalCacheKey(
+    "opStackL1DataFee",
+    deposit.destinationChainId,
+    deposit.outputToken // This should technically differ based on the output token since the L2 calldata
+    // size affects the L1 data fee and this calldata can differ based on the output token.
+  );
+  const ttl = ttlPerChain.default;
+  const fetchFn = async () => {
     // We don't care about the gas token price or the token gas price, only the raw gas units. In the API
     // we'll compute the gas price separately.
-    const markups = getGasMarkup(deposit.destinationChainId);
-    const gasCosts = await relayerFeeCalculatorQueries.getGasCosts(
-      buildDepositForSimulation(deposit),
-      overrides?.relayerAddress,
-      {
-        gasPrice,
-        // We want the fee multipliers if the gasPrice is undefined:
-        baseFeeMultiplier: markups.baseFeeMarkup,
-        priorityFeeMultiplier: markups.priorityFeeMarkup,
-        opStackL1GasCostMultiplier: sdk.utils.chainIsOPStack(
-          deposit.destinationChainId
-        )
-          ? getGasMarkup(deposit.destinationChainId).opStackL1DataFeeMarkup
-          : undefined,
-      }
+    const { opStackL1DataFeeMarkup } = getGasMarkup(deposit.destinationChainId);
+    const relayerFeeCalculatorQueries = getRelayerFeeCalculatorQueries(
+      deposit.destinationChainId,
+      overrides
     );
-    return {
-      nativeGasCost: gasCosts.nativeGasCost,
-      tokenGasCost: gasCosts.tokenGasCost,
-    };
+    const unsignedTx =
+      await relayerFeeCalculatorQueries.getUnsignedTxFromDeposit(
+        buildDepositForSimulation(deposit),
+        overrides?.relayerAddress
+      );
+    const opStackL1GasCost =
+      await relayerFeeCalculatorQueries.getOpStackL1DataFee(
+        unsignedTx,
+        overrides?.relayerAddress,
+        {
+          opStackL2GasUnits: nativeGasCost, // Passed in here to avoid gas cost recomputation by the SDK
+          opStackL1DataFeeMultiplier: opStackL1DataFeeMarkup,
+        }
+      );
+    return opStackL1GasCost;
   };
 
-  return getCachedValue(
-    cacheKey,
-    ttl,
-    fetchFn,
-    (gasCosts: { nativeGasCost: BigNumber; tokenGasCost: BigNumber }) => {
-      return {
-        nativeGasCost: BigNumber.from(gasCosts.nativeGasCost),
-        tokenGasCost: BigNumber.from(gasCosts.tokenGasCost),
-      };
-    }
-  );
+  return getCachedValue(cacheKey, ttl, fetchFn, (l1DataFeeFromCache) => {
+    return BigNumber.from(l1DataFeeFromCache);
+  });
 }
 
-export function latestGasPriceCache(chainId: number) {
+export function latestGasPriceCache(
+  chainId: number,
+  deposit?: Parameters<typeof buildDepositForSimulation>[0],
+  overrides?: Partial<{
+    relayerAddress: string;
+  }>
+) {
   const ttlPerChain = {
-    default: 30,
-    [CHAIN_IDs.ARBITRUM]: 15,
+    default: 5,
   };
-
   return makeCacheGetterAndSetter(
-    buildInternalCacheKey("latestGasPriceCache", chainId),
-    ttlPerChain[chainId] || ttlPerChain.default,
-    async () => (await getMaxFeePerGas(chainId)).maxFeePerGas,
-    (bnFromCache) => BigNumber.from(bnFromCache)
+    // If deposit is defined, then the gas price will be dependent on the fill transaction derived from the deposit.
+    // Therefore, we technically should cache a different gas price per different types of deposit so we add
+    // an additional outputToken to the cache key to distinguish between gas prices dependent on deposit args
+    // for different output tokens, which should be the main factor affecting the fill gas cost.
+    buildInternalCacheKey(
+      `latestGasPriceCache${deposit ? `-${deposit.outputToken}` : ""}`,
+      chainId
+    ),
+    ttlPerChain.default,
+    async () => await getMaxFeePerGas(chainId, deposit, overrides),
+    (gasPrice: sdk.gasPriceOracle.GasPriceEstimate) => {
+      return {
+        maxFeePerGas: BigNumber.from(gasPrice.maxFeePerGas),
+        maxPriorityFeePerGas: BigNumber.from(gasPrice.maxPriorityFeePerGas),
+      };
+    }
   );
 }
 
-/**
- * Resolve the current gas price for a given chain
- * @param chainId The chain ID to resolve the gas price for
- * @returns The gas price in the native currency of the chain
- */
-export function getMaxFeePerGas(
-  chainId: number
+export async function getMaxFeePerGas(
+  chainId: number,
+  deposit?: Parameters<typeof buildDepositForSimulation>[0],
+  overrides?: Partial<{
+    relayerAddress: string;
+  }>
 ): Promise<sdk.gasPriceOracle.GasPriceEstimate> {
+  if (deposit && deposit.destinationChainId !== chainId) {
+    throw new Error(
+      "Chain ID must match the destination chain ID of the deposit"
+    );
+  }
   const {
     baseFeeMarkup: baseFeeMultiplier,
     priorityFeeMarkup: priorityFeeMultiplier,
   } = getGasMarkup(chainId);
+  const relayerFeeCalculatorQueries = getRelayerFeeCalculatorQueries(
+    chainId,
+    overrides
+  );
+  const unsignedFillTxn = deposit
+    ? await relayerFeeCalculatorQueries.getUnsignedTxFromDeposit(
+        buildDepositForSimulation(deposit),
+        overrides?.relayerAddress
+      )
+    : undefined;
   return sdk.gasPriceOracle.getGasPriceEstimate(getProvider(chainId), {
     chainId,
+    unsignedTx: unsignedFillTxn,
     baseFeeMultiplier,
     priorityFeeMultiplier,
   });

api/cron-cache-gas-prices.ts

@@ -10,6 +10,7 @@ import { UnauthorizedError } from "./_errors";
 
 import mainnetChains from "../src/data/chains_1.json";
 import { utils } from "@across-protocol/sdk";
+import { CHAIN_IDs } from "./_constants";
 
 const updateIntervalsSecPerChain = {
   default: 10,
@@ -52,23 +53,29 @@ const handler = async (
     // But we want to update gas prices more frequently than that.
     // To circumvent this, we run the function in a loop and update gas prices every
     // `secondsPerUpdateForChain` seconds and stop after `maxDurationSec` seconds (1 minute).
-    const gasPricePromises = mainnetChains.map(async (chain) => {
-      const secondsPerUpdateForChain =
-        updateIntervalsSecPerChain[
-          chain.chainId as keyof typeof updateIntervalsSecPerChain
-        ] || updateIntervalsSecPerChain.default;
-      const cache = latestGasPriceCache(chain.chainId);
+    const gasPricePromises = mainnetChains
+      // @dev Remove Linea from this cron cache job because Linea's gas price is dependent on the
+      // calldata of the transaction to be submitted on Linea.
+      .filter((chain) => CHAIN_IDs.LINEA !== chain.chainId)
+      .map(async (chain) => {
+        const secondsPerUpdateForChain =
+          updateIntervalsSecPerChain[
+            chain.chainId as keyof typeof updateIntervalsSecPerChain
+          ] || updateIntervalsSecPerChain.default;
+        // The deposit args don't matter for any chain besides Linea, which is why we filter it out
+        // above, because gas price on Linea is dependent on the fill transaction args.
+        const cache = latestGasPriceCache(chain.chainId);
 
-      while (true) {
-        const diff = Date.now() - functionStart;
-        // Stop after `maxDurationSec` seconds
-        if (diff >= maxDurationSec * 1000) {
-          break;
+        while (true) {
+          const diff = Date.now() - functionStart;
+          // Stop after `maxDurationSec` seconds
+          if (diff >= maxDurationSec * 1000) {
+            break;
+          }
+          await cache.set();
+          await utils.delay(secondsPerUpdateForChain);
         }
-        await cache.set();
-        await utils.delay(secondsPerUpdateForChain);
-      }
-    });
+      });
     await Promise.all(gasPricePromises);
 
     logger.debug({