feat(profitability): Remove hardcoded min revenue map and add logic to consider gas cost

src/clients/MultiCallerClient.ts

@@ -26,7 +26,7 @@ export interface AugmentedTransaction {
 export class MultiCallerClient {
   private transactions: AugmentedTransaction[] = [];
   // eslint-disable-next-line no-useless-constructor
-  constructor(readonly logger: winston.Logger, readonly gasEstimator: any, readonly maxTxWait: number = 180) {}
+  constructor(readonly logger: winston.Logger) {}
 
   // Adds all information associated with a transaction to the transaction queue. This is the intention of the
   // caller to send a transaction. The transaction might not be executable, which should be filtered later.

src/clients/ProfitClient.ts

@@ -2,36 +2,26 @@ import { BigNumber, winston, toBNWei, toBN, assign } from "../utils";
 import { HubPoolClient } from ".";
 import { Deposit, L1Token } from "../interfaces";
 import { Coingecko } from "@uma/sdk";
+import * as _ from "lodash";
 
-// Define the minimum revenue, in USD, that a relay must yield in order to be considered "profitable". This is a short
-// term solution to enable us to avoid DOS relays that yield negative profits. In the future this should be updated
-// to actual factor in the cost of sending transactions on the associated target chains.
-const chainIdToMinRevenue = {
-  // Mainnet and L1 testnets.
-  1: toBNWei(10),
-  4: toBNWei(10),
-  5: toBNWei(10),
-  42: toBNWei(10),
-  // Rollups/L2s/sidechains & their testnets.
-  10: toBNWei(1),
-  69: toBNWei(1),
-  288: toBNWei(1),
-  28: toBNWei(1),
-  42161: toBNWei(1),
-  137: toBNWei(1),
-  80001: toBNWei(1),
+// We use wrapped ERC-20 versions instead of the native tokens such as ETH, MATIC for ease of computing prices.
+export const WMATIC = "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270";
+const GAS_TOKEN_BY_CHAIN_ID = {
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+  10: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+  137: WMATIC,
+  288: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+  42161: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
 };
+// TODO: Make this dynamic once we support chains with gas tokens that have different decimals.
+const GAS_TOKEN_DECIMALS = 18;
 
 export class ProfitClient {
   private readonly coingecko;
   protected tokenPrices: { [l1Token: string]: BigNumber } = {};
   private unprofitableFills: { [chainId: number]: { deposit: Deposit; fillAmount: BigNumber }[] } = {};
 
-  constructor(
-    readonly logger: winston.Logger,
-    readonly hubPoolClient: HubPoolClient,
-    readonly relayerDiscount: BigNumber = toBNWei(0)
-  ) {
+  constructor(readonly logger: winston.Logger, readonly hubPoolClient: HubPoolClient) {
     this.coingecko = new Coingecko();
   }
 
@@ -41,7 +31,7 @@ export class ProfitClient {
 
   getPriceOfToken(token: string) {
     if (!this.tokenPrices[token]) {
-      this.logger.warn({ at: "ProfitClient", message: `Token ${token} not found in state. Using 0` });
+      this.logger.debug({ at: "ProfitClient", message: `Token ${token} not found in state. Using 0` });
       return toBN(0);
     }
     return this.tokenPrices[token];
@@ -55,12 +45,7 @@ export class ProfitClient {
     this.unprofitableFills = {};
   }
 
-  isFillProfitable(deposit: Deposit, fillAmount: BigNumber) {
-    if (toBN(this.relayerDiscount).eq(toBNWei(1))) {
-      this.logger.debug({ at: "ProfitClient", message: "Relayer discount set to 100%. Accepting relay" });
-      return true;
-    }
-
+  isFillProfitable(deposit: Deposit, fillAmount: BigNumber, gasUsed: BigNumber) {
     if (toBN(deposit.relayerFeePct).eq(toBN(0))) {
       this.logger.debug({ at: "ProfitClient", message: "Deposit set 0 relayerFeePct. Rejecting relay" });
       return false;
@@ -69,10 +54,15 @@ export class ProfitClient {
     const tokenPriceInUsd = this.getPriceOfToken(l1Token);
     const fillRevenueInRelayedToken = toBN(deposit.relayerFeePct).mul(fillAmount).div(toBN(10).pow(decimals));
     const fillRevenueInUsd = fillRevenueInRelayedToken.mul(tokenPriceInUsd).div(toBNWei(1));
+
+    // Consider gas cost.
+    const gasCostInUsd = gasUsed
+      .mul(this.getPriceOfToken(GAS_TOKEN_BY_CHAIN_ID[deposit.destinationChainId]))
+      .div(toBN(10).pow(GAS_TOKEN_DECIMALS));
+
     // How much minimumAcceptableRevenue is scaled. If relayer discount is 0 then need minimumAcceptableRevenue at min.
-    const revenueScalar = toBNWei(1).sub(this.relayerDiscount);
-    const minimumAcceptableRevenue = chainIdToMinRevenue[deposit.destinationChainId].mul(revenueScalar).div(toBNWei(1));
-    const fillProfitable = fillRevenueInUsd.gte(minimumAcceptableRevenue);
+    const fillProfitInUsd = fillRevenueInUsd.sub(gasCostInUsd);
+    const fillProfitable = fillProfitInUsd.gte(toBN(0));
     this.logger.debug({
       at: "ProfitClient",
       message: "Considered fill profitability",
@@ -81,8 +71,9 @@ export class ProfitClient {
       tokenPriceInUsd,
       fillRevenueInRelayedToken,
       fillRevenueInUsd,
-      minimumAcceptableRevenue,
-      discount: this.relayerDiscount,
+      gasUsed,
+      gasCostInUsd,
+      fillProfitInUsd,
       fillProfitable,
     });
     return fillProfitable;
@@ -98,26 +89,48 @@ export class ProfitClient {
   }
 
   async update() {
-    const l1Tokens = this.hubPoolClient.getL1Tokens();
+    // Clone because we'll be adding WMATIC to the list for logging purposes later below.
+    const l1Tokens = _.cloneDeep(this.hubPoolClient.getL1Tokens());
     this.logger.debug({ at: "ProfitClient", message: "Updating Profit client", l1Tokens });
-    const prices = await Promise.allSettled(l1Tokens.map((l1Token: L1Token) => this.coingeckoPrice(l1Token.address)));
+    const priceFetches = l1Tokens.map((l1Token: L1Token) => this.coingeckoPrice(l1Token.address));
+    // Add WMATIC for gas cost calculations.
+    priceFetches.push(this.coingeckoPrice(WMATIC, "polygon-pos"));
+    const prices = await Promise.allSettled(priceFetches);
+    // Add to l1Tokens after the fetches, so prices and l1Tokens have the same entries, for any error logging later.
+    l1Tokens.push({
+      address: WMATIC,
+      symbol: "WMATIC",
+      decimals: 18,
+    });
 
     const errors = [];
     for (const [index, priceResponse] of prices.entries()) {
       if (priceResponse.status === "rejected") errors.push(l1Tokens[index]);
       else this.tokenPrices[l1Tokens[index].address] = toBNWei(priceResponse.value[1]);
     }
     if (errors.length > 0) {
-      let mrkdwn = "The following L1 token prices could not be fetched:\n";
+      let warningMrkdwn = "";
+      let debugMrkdwn = "";
       errors.forEach((token: L1Token) => {
-        mrkdwn += `- ${token.symbol} Not found. Using last known price of ${this.getPriceOfToken(token.address)}.\n`;
+        const lastPrice = this.getPriceOfToken(token.address);
+        if (lastPrice && lastPrice.eq(toBN(0))) {
+          warningMrkdwn += `- ${token.symbol} Not found.\n`;
+        } else {
+          debugMrkdwn += `- ${token.symbol} Not found. Using last known price of ${debugMrkdwn}.\n`;
+        }
       });
-      this.logger.warn({ at: "ProfitClient", message: "Could not fetch all token prices 💳", mrkdwn });
+
+      if (warningMrkdwn) {
+        warningMrkdwn = "The following L1 token prices could not be fetched:\n" + warningMrkdwn;
+        this.logger.warn({ at: "ProfitClient", message: "Could not fetch all token prices 💳", mrkdwn: warningMrkdwn });
+      } else {
+        this.logger.debug({ at: "ProfitClient", message: "Could not fetch all token prices", mrkdwn: debugMrkdwn });
+      }
     }
     this.logger.debug({ at: "ProfitClient", message: "Updated Profit client", tokenPrices: this.tokenPrices });
   }
 
-  private async coingeckoPrice(token: string) {
-    return await this.coingecko.getCurrentPriceByContract(token, "usd");
+  private async coingeckoPrice(token: string, platform_id?: string) {
+    return await this.coingecko.getCurrentPriceByContract(token, "usd", platform_id);
   }
 }

src/common/ClientHelper.ts

@@ -169,7 +169,7 @@ export async function constructClients(logger: winston.Logger, config: CommonCon
   );
 
   // const gasEstimator = new GasEstimator() // todo when this is implemented in the SDK.
-  const multiCallerClient = new MultiCallerClient(logger, null, config.maxTxWait);
+  const multiCallerClient = new MultiCallerClient(logger);
 
   const profitClient = new ProfitClient(logger, hubPoolClient);
 

src/relayer/Relayer.ts

@@ -1,8 +1,17 @@
-import { BigNumber, winston, buildFillRelayProps, getNetworkName, getUnfilledDeposits, getCurrentTime } from "../utils";
+import {
+  BigNumber,
+  winston,
+  buildFillRelayProps,
+  getNetworkName,
+  getUnfilledDeposits,
+  getCurrentTime,
+  estimateGas,
+} from "../utils";
 import { createFormatFunction, etherscanLink, toBN } from "../utils";
 import { RelayerClients } from "./RelayerClientHelper";
 
 import { Deposit } from "../interfaces";
+import { AugmentedTransaction } from "../clients";
 
 const UNPROFITABLE_DEPOSIT_NOTICE_PERIOD = 60 * 60; // 1 hour
 
@@ -59,8 +68,16 @@ export class Relayer {
       }
 
       if (this.clients.tokenClient.hasBalanceForFill(deposit, unfilledAmount)) {
-        if (this.clients.profitClient.isFillProfitable(deposit, unfilledAmount)) {
-          this.fillRelay(deposit, unfilledAmount);
+        // Fetch the repayment chain from the inventory client. Sanity check that it is one of the known chainIds.
+        const repaymentChain = this.clients.inventoryClient.determineRefundChainId(deposit);
+        // Create the transaction, so we can simulate to get the gas cost for profitability calculation.
+        const fillTransaction = this.createFillTransaction(deposit, unfilledAmount, repaymentChain);
+        // TODO: Potentially skip the entire sequence if the transaction would fail. We currently handle this in
+        // fillRelay separately, so we'll need to figure out how to consolidate the logic.
+        const fillSimulation = await estimateGas(fillTransaction);
+
+        if (this.clients.profitClient.isFillProfitable(deposit, unfilledAmount, fillSimulation.gasUsed)) {
+          this.fillRelay(deposit, unfilledAmount, repaymentChain, fillTransaction);
         } else {
           this.clients.profitClient.captureUnprofitableFill(deposit, unfilledAmount);
         }
@@ -77,23 +94,25 @@ export class Relayer {
     if (this.clients.profitClient.anyCapturedUnprofitableFills()) this.handleUnprofitableFill();
   }
 
-  fillRelay(deposit: Deposit, fillAmount: BigNumber) {
+  createFillTransaction(deposit: Deposit, fillAmount: BigNumber, repaymentChain: number): AugmentedTransaction {
+    return {
+      contract: this.clients.spokePoolClients[deposit.destinationChainId].spokePool, // target contract
+      chainId: deposit.destinationChainId,
+      method: "fillRelay", // method called.
+      args: buildFillRelayProps(deposit, repaymentChain, fillAmount), // props sent with function call.
+      message: "Relay instantly sent 🚀", // message sent to logger.
+      mrkdwn: this.constructRelayFilledMrkdwn(deposit, repaymentChain, fillAmount), // message details mrkdwn
+    };
+  }
+
+  fillRelay(deposit: Deposit, fillAmount: BigNumber, repaymentChain: number, transaction: AugmentedTransaction) {
     try {
-      // Fetch the repayment chain from the inventory client. Sanity check that it is one of the known chainIds.
-      const repaymentChain = this.clients.inventoryClient.determineRefundChainId(deposit);
       if (!Object.keys(this.clients.spokePoolClients).includes(deposit.destinationChainId.toString()))
         throw new Error("Fatal error! Repayment chain set to a chain that is not part of the defined sets of chains!");
 
       this.logger.debug({ at: "Relayer", message: "Filling deposit", deposit, repaymentChain });
       // Add the fill transaction to the multiCallerClient so it will be executed with the next batch.
-      this.clients.multiCallerClient.enqueueTransaction({
-        contract: this.clients.spokePoolClients[deposit.destinationChainId].spokePool, // target contract
-        chainId: deposit.destinationChainId,
-        method: "fillRelay", // method called.
-        args: buildFillRelayProps(deposit, repaymentChain, fillAmount), // props sent with function call.
-        message: "Relay instantly sent 🚀", // message sent to logger.
-        mrkdwn: this.constructRelayFilledMrkdwn(deposit, repaymentChain, fillAmount), // message details mrkdwn
-      });
+      this.clients.multiCallerClient.enqueueTransaction(transaction);
 
       // Decrement tokens in token client used in the fill. This ensures that we dont try and fill more than we have.
       this.clients.tokenClient.decrementLocalBalance(deposit.destinationChainId, deposit.destinationToken, fillAmount);

src/relayer/RelayerClientHelper.ts

@@ -29,7 +29,7 @@ export async function constructRelayerClients(logger: winston.Logger, config: Re
 
   const tokenClient = new TokenClient(logger, baseSigner.address, spokePoolClients, commonClients.hubPoolClient);
 
-  const profitClient = new ProfitClient(logger, commonClients.hubPoolClient, config.relayerDiscount);
+  const profitClient = new ProfitClient(logger, commonClients.hubPoolClient);
 
   const adapterManager = new AdapterManager(logger, spokePoolClients, commonClients.hubPoolClient, [
     baseSigner.address,

src/relayer/RelayerConfig.ts

@@ -4,21 +4,13 @@ import { InventoryConfig } from "../interfaces";
 
 export class RelayerConfig extends CommonConfig {
   readonly inventoryConfig: InventoryConfig;
-  readonly relayerDiscount: BigNumber;
   readonly sendingRelaysEnabled: boolean;
   readonly sendingSlowRelaysEnabled: boolean;
   readonly relayerTokens: string[];
   readonly relayerDestinationChains: number[];
 
   constructor(env: ProcessEnv) {
-    const {
-      RELAYER_DESTINATION_CHAINS,
-      RELAYER_DISCOUNT,
-      RELAYER_INVENTORY_CONFIG,
-      RELAYER_TOKENS,
-      SEND_RELAYS,
-      SEND_SLOW_RELAYS,
-    } = env;
+    const { RELAYER_DESTINATION_CHAINS, RELAYER_INVENTORY_CONFIG, RELAYER_TOKENS, SEND_RELAYS, SEND_SLOW_RELAYS } = env;
     super(env);
 
     // Empty means all chains.
@@ -55,7 +47,6 @@ export class RelayerConfig extends CommonConfig {
         });
       });
     }
-    this.relayerDiscount = RELAYER_DISCOUNT ? toBNWei(RELAYER_DISCOUNT) : toBNWei(0);
     this.sendingRelaysEnabled = SEND_RELAYS === "true";
     this.sendingSlowRelaysEnabled = SEND_SLOW_RELAYS === "true";
   }

src/utils/TransactionUtils.ts

@@ -63,6 +63,23 @@ export async function willSucceed(
   }
 }
 
+export async function estimateGas(
+  transaction: AugmentedTransaction
+): Promise<{ transaction: AugmentedTransaction; succeed: boolean; reason: string; gasUsed: BigNumber }> {
+  try {
+    const args = transaction.value ? [...transaction.args, { value: transaction.value }] : transaction.args;
+    const [gasUsed, gasFee] = await Promise.all([
+      transaction.contract.estimateGas[transaction.method](...args),
+      transaction.contract.provider.getGasPrice(),
+    ]);
+
+    return { transaction, succeed: true, reason: null, gasUsed: gasUsed.mul(gasFee) };
+  } catch (error) {
+    console.error(error);
+    return { transaction, succeed: false, reason: error.reason, gasUsed: toBN(0) };
+  }
+}
+
 export function getTarget(targetAddress: string) {
   try {
     return { targetAddress, ...getContractInfoFromAddress(targetAddress) };

test/Monitor.ts

@@ -10,7 +10,7 @@ import {
   TokenTransferClient,
   BalanceAllocator,
 } from "../src/clients";
-import { CrossChainTransferClient, AdapterManager } from "../src/clients/bridges";
+import { CrossChainTransferClient } from "../src/clients/bridges";
 import { Monitor, ALL_CHAINS_NAME, UNKNOWN_TRANSFERS_NAME } from "../src/monitor/Monitor";
 import { MonitorConfig } from "../src/monitor/MonitorConfig";
 import { amountToDeposit, destinationChainId, mockTreeRoot, originChainId, repaymentChainId } from "./constants";