improve: Use base fee multiplier option in SDK to resolve gas fees

scripts/zkSyncDemo.ts

@@ -62,7 +62,7 @@ export async function run(): Promise<void> {
     connectedSigner
   );
   const l2PubdataByteLimit = zksync.utils.REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT;
-  const l1GasPriceData = await gasPriceOracle.getGasPriceEstimate(l1Provider, l1ChainId);
+  const l1GasPriceData = await gasPriceOracle.getGasPriceEstimate(l1Provider, { chainId: l1ChainId });
   const estimatedL1GasPrice = l1GasPriceData.maxPriorityFeePerGas.add(l1GasPriceData.maxFeePerGas);
   // The ZkSync Mailbox contract checks that the msg.value of the transaction is enough to cover the transaction base
   // cost. The transaction base cost can be queried from the Mailbox by passing in an L1 "executed" gas price,

src/clients/ProfitClient.ts

@@ -97,7 +97,7 @@ export class ProfitClient {
   protected totalGasCosts: { [chainId: number]: TransactionCostEstimate } = {};
 
   // Queries needed to fetch relay gas costs.
-  private relayerFeeQueries: { [chainId: number]: relayFeeCalculator.QueryInterface } = {};
+  protected relayerFeeQueries: { [chainId: number]: relayFeeCalculator.QueryInterface } = {};
 
   private readonly isTestnet: boolean;
 
@@ -205,7 +205,9 @@ export class ProfitClient {
 
   private async _getTotalGasCost(deposit: Deposit, relayer: string): Promise<TransactionCostEstimate> {
     try {
-      return await this.relayerFeeQueries[deposit.destinationChainId].getGasCosts(deposit, relayer);
+      return await this.relayerFeeQueries[deposit.destinationChainId].getGasCosts(deposit, relayer, {
+        baseFeeMultiplier: this.gasPadding,
+      });
     } catch (err) {
       const reason = isEthersError(err) ? err.reason : isError(err) ? err.message : "unknown error";
       this.logger.warn({
@@ -243,8 +245,15 @@ export class ProfitClient {
 
     const gasToken = this.resolveGasToken(chainId);
     const gasTokenPriceUsd = this.getPriceOfToken(gasToken.symbol);
+    // This is where the relayer's computation of the tokenGasCost (gasUnits * gasFee) can diverge from the
+    // quoting API's. The latter uses the SDK's GasPriceOracle.getGasPriceEstimate() function and passes in an optional
+    // baseFeeMultiplier. The relayer uses this.getTotalGasCost() to compute the gasUnits the same way that the
+    // API does and then computes the tokenGasCost by computing the gasPrice using a baseFeeMultiplier set as this
+    // client's this.gasPadding. Therefore, this.getTotalGasCost will importantly set
+    // baseFeeMultiplier = this.gasPadding.
     const totalGasCost = await this.getTotalGasCost(deposit);
-    let { nativeGasCost, tokenGasCost } = totalGasCost;
+    let tokenGasCost = totalGasCost.tokenGasCost;
+    const nativeGasCost = totalGasCost.nativeGasCost;
     const gasPrice = totalGasCost.gasPrice;
 
     Object.entries({
@@ -257,11 +266,6 @@ export class ProfitClient {
       }
     });
 
-    // Fills with messages have arbitrary execution and therefore lower certainty about the simulated execution cost.
-    // Pad these estimates before computing profitability to allow execution headroom and reduce the chance of an OoG.
-    nativeGasCost = nativeGasCost.mul(this.gasPadding).div(fixedPoint);
-    tokenGasCost = tokenGasCost.mul(this.gasPadding).div(fixedPoint);
-
     // Gas estimates for token-only fills are stable and reliable. Allow these to be scaled up or down via the
     // configured gasMultiplier. Do not scale the nativeGasCost, since it might be used to set the transaction gasLimit.
     // @todo Consider phasing this out and relying solely on the minimum profitability config.

src/utils/TransactionUtils.ts

@@ -82,7 +82,12 @@ export async function runTransaction(
       Number(process.env[`MAX_FEE_PER_GAS_SCALER_${chainId}`] || process.env.MAX_FEE_PER_GAS_SCALER) ||
       DEFAULT_GAS_FEE_SCALERS[chainId]?.maxFeePerGasScaler;
 
-    const gas = await getGasPrice(provider, priorityFeeScaler, maxFeePerGasScaler);
+    const gas = await getGasPrice(
+      provider,
+      priorityFeeScaler,
+      maxFeePerGasScaler,
+      await contract.populateTransaction[method](...(args as Array<unknown>), { value })
+    );
 
     logger.debug({
       at: "TxUtil",
@@ -154,16 +159,19 @@ export async function runTransaction(
   }
 }
 
-// TODO: add in gasPrice when the SDK has this for the given chainId. TODO: improve how we fetch prices.
-// For now this method will extract the provider's Fee data from the associated network and scale it by a priority
-// scaler. This works on both mainnet and L2's by the utility switching the response structure accordingly.
 export async function getGasPrice(
   provider: ethers.providers.Provider,
   priorityScaler = 1.2,
-  maxFeePerGasScaler = 3
+  maxFeePerGasScaler = 3,
+  transactionObject?: ethers.PopulatedTransaction
 ): Promise<Partial<FeeData>> {
   const { chainId } = await provider.getNetwork();
-  const feeData = await gasPriceOracle.getGasPriceEstimate(provider, chainId);
+  // Pass in unsignedTx here for better Linea gas price estimations via the Linea Viem provider.
+  const feeData = await gasPriceOracle.getGasPriceEstimate(provider, {
+    chainId,
+    baseFeeMultiplier: toBNWei(maxFeePerGasScaler),
+    unsignedTx: transactionObject,
+  });
 
   if (feeData.maxPriorityFeePerGas.gt(feeData.maxFeePerGas)) {
     feeData.maxFeePerGas = scaleByNumber(feeData.maxPriorityFeePerGas, 1.5);
@@ -176,7 +184,7 @@ export async function getGasPrice(
 
   // Default to EIP-1559 (type 2) pricing.
   return {
-    maxFeePerGas: scaleByNumber(feeData.maxFeePerGas, Math.max(priorityScaler * maxFeePerGasScaler, 1)),
+    maxFeePerGas: feeData.maxFeePerGas,
     maxPriorityFeePerGas: scaleByNumber(feeData.maxPriorityFeePerGas, priorityScaler),
   };
 }

test/ProfitClient.ConsiderProfitability.ts

@@ -1,6 +1,6 @@
 import { assert } from "chai";
 import { random } from "lodash";
-import { constants as sdkConstants, utils as sdkUtils } from "@across-protocol/sdk";
+import { constants as sdkConstants, utils as sdkUtils, relayFeeCalculator } from "@across-protocol/sdk";
 import { ConfigStoreClient, FillProfit, SpokePoolClient } from "../src/clients";
 import { Deposit } from "../src/interfaces";
 import {
@@ -16,6 +16,7 @@ import {
   toBNWei,
   toGWei,
   TOKEN_SYMBOLS_MAP,
+  fixedPointAdjustment,
 } from "../src/utils";
 import { MockHubPoolClient, MockProfitClient } from "./mocks";
 import { originChainId, destinationChainId, ZERO_ADDRESS } from "./constants";
@@ -207,28 +208,50 @@ describe("ProfitClient: Consider relay profit", () => {
     }
   });
 
-  it("Verify gas padding", async () => {
+  it("Verify gas padding on SDK call is set correctly", async () => {
+    class ExampleQueries implements relayFeeCalculator.QueryInterface {
+      GAS_PRICE(): BigNumber {
+        return toGWei("1");
+      }
+      // We only test that the baseFeeMultiplier is being correctly passed from the ProfitClient
+      // to the RelayFeeCalculator using this class
+      getGasCosts(_deposit: Deposit, _relayer: string, options?: any): Promise<TransactionCostEstimate> {
+        const gasCost = BigNumber.from(300_000);
+        const gasPrice = this.GAS_PRICE()
+          .mul(options?.baseFeeMultiplier ?? fixedPointAdjustment)
+          .div(fixedPointAdjustment);
+        return Promise.resolve({
+          nativeGasCost: gasCost,
+          tokenGasCost: toBN(gasCost).mul(gasPrice),
+          gasPrice,
+        });
+      }
+
+      // Unused functions in the QueryInterface
+      getTokenPrice(): Promise<number> {
+        return Promise.resolve(1);
+      }
+      getTokenDecimals(): number {
+        return 18;
+      }
+    }
     const gasPadding = ["0", "0.10", "0.20", "0.50", "1"].map((padding) => toBNWei("1").add(toBNWei(padding)));
 
     profitClient.setGasMultiplier(toBNWei("1")); // Neutralise any gas multiplier.
+    profitClient.setGasCosts({}); // Neutralise any hardcoded gas costs so ExampleQueries.getGasCosts() is called
 
-    for (const destinationChainId of chainIds) {
-      spyLogger.debug({ message: `Verifying gas padding for chainId ${destinationChainId}.` });
-      const deposit = { ...v3DepositTemplate, destinationChainId };
-
-      const { nativeGasCost: defaultNativeGasCost, tokenGasCost: defaultTokenGasCost } =
-        await profitClient.getTotalGasCost(deposit);
+    const chainId = chainIds[0];
+    const exampleQuery = new ExampleQueries();
+    profitClient.setRelayerFeeQueries({ [chainId]: exampleQuery });
+    spyLogger.debug({ message: `Verifying gas padding for chainId ${destinationChainId}.` });
+    const deposit = { ...v3DepositTemplate, destinationChainId: chainId };
 
-      for (const padding of gasPadding) {
-        profitClient.setGasPadding(padding);
+    for (const padding of gasPadding) {
+      profitClient.setGasPadding(padding);
 
-        const expectedNativeGasCost = defaultNativeGasCost.mul(padding).div(fixedPoint);
-        const expectedTokenGasCost = defaultTokenGasCost.mul(padding).div(fixedPoint);
-
-        const { nativeGasCost, tokenGasCost } = await profitClient.estimateFillCost(deposit);
-        expect(expectedNativeGasCost.eq(nativeGasCost)).to.be.true;
-        expect(expectedTokenGasCost.eq(tokenGasCost)).to.be.true;
-      }
+      const expectedGasPrice = exampleQuery.GAS_PRICE().mul(padding).div(fixedPoint);
+      const { gasPrice } = await profitClient.estimateFillCost(deposit);
+      expect(expectedGasPrice.eq(gasPrice)).to.be.true;
     }
   });
 

test/mocks/MockProfitClient.ts

@@ -1,4 +1,4 @@
-import { utils as sdkUtils } from "@across-protocol/sdk";
+import { utils as sdkUtils, relayFeeCalculator } from "@across-protocol/sdk";
 import { ProfitClient } from "../../src/clients";
 import { SpokePoolClientsByChain } from "../../src/interfaces";
 import { bnOne, isDefined, TOKEN_SYMBOLS_MAP } from "../../src/utils";
@@ -77,6 +77,10 @@ export class MockProfitClient extends ProfitClient {
     this.tokenSymbolMap[symbol] = address;
   }
 
+  setRelayerFeeQueries(queries: { [chainId: number]: relayFeeCalculator.QueryInterface }): void {
+    this.relayerFeeQueries = queries;
+  }
+
   setTokenPrice(token: string, price: BigNumber | undefined): void {
     const address = this.resolveTokenAddress(token);
     if (price) {