improve(relayer): Drop slow fill request queries

src/relayer/Relayer.ts

@@ -128,17 +128,6 @@ export class Relayer {
         return false;
       }
 
-      const destSpokePool = this.clients.spokePoolClients[destinationChainId].spokePool;
-      const fillStatus = await sdkUtils.relayFillStatus(destSpokePool, deposit, "latest", destinationChainId);
-      if (fillStatus === FillStatus.Filled) {
-        this.logger.debug({
-          at: "Relayer::getUnfilledDeposits",
-          message: "Skipping deposit that was already filled.",
-          deposit,
-        });
-        return false;
-      }
-
       // Skip deposit with message if sending fills with messages is not supported.
       if (!this.config.sendingMessageRelaysEnabled && !isMessageEmpty(resolveDepositMessage(deposit))) {
         this.logger.warn({
@@ -244,21 +233,98 @@ export class Relayer {
       mdcPerChain,
       minDepositConfirmations,
     });
+
     return mdcPerChain;
   }
 
+  // Iterate over all unfilled deposits. For each unfilled deposit, check that:
+  // a) it exceeds the minimum number of required block confirmations,
+  // b) the token balance client has enough tokens to fill it,
+  // c) the fill is profitable.
+  // If all hold true then complete the fill. If there is insufficient balance to complete the fill and slow fills are
+  // enabled then request a slow fill instead.
+  async evaluateFill(
+    deposit: V3DepositWithBlock,
+    fillStatus: number,
+    maxBlockNumber: number,
+    sendSlowRelays: boolean
+  ): Promise<void> {
+    const { depositId, depositor, recipient, destinationChainId, originChainId, inputToken, outputAmount } = deposit;
+    const { hubPoolClient, profitClient, tokenClient } = this.clients;
+    const { slowDepositors } = this.config;
+
+    // If the deposit does not meet the minimum number of block confirmations, skip it.
+    if (deposit.blockNumber > maxBlockNumber) {
+      const chain = getNetworkName(originChainId);
+      this.logger.debug({
+        at: "Relayer",
+        message: `Skipping ${chain} deposit ${depositId} due to insufficient deposit confirmations.`,
+        depositId,
+        blockNumber: deposit.blockNumber,
+        maxBlockNumber,
+        transactionHash: deposit.transactionHash,
+      });
+      return;
+    }
+
+    // If depositor is on the slow deposit list, then send a zero fill to initiate a slow relay and return early.
+    if (slowDepositors?.includes(depositor) && fillStatus === FillStatus.Unfilled) {
+      this.logger.debug({
+        at: "Relayer",
+        message: "Initiating slow fill for grey listed depositor",
+        depositor,
+      });
+      this.requestSlowFill(deposit);
+      return;
+    }
+
+    const l1Token = hubPoolClient.getL1TokenInfoForL2Token(inputToken, originChainId);
+    const selfRelay = [depositor, recipient].every((address) => address === this.relayerAddress);
+    if (tokenClient.hasBalanceForFill(deposit, outputAmount) && !selfRelay) {
+      const {
+        repaymentChainId,
+        realizedLpFeePct,
+        relayerFeePct,
+        gasLimit: _gasLimit,
+        gasCost,
+      } = await this.resolveRepaymentChain(deposit, l1Token);
+      if (isDefined(repaymentChainId)) {
+        const gasLimit = isMessageEmpty(resolveDepositMessage(deposit)) ? undefined : _gasLimit;
+        this.fillRelay(deposit, repaymentChainId, realizedLpFeePct, gasLimit);
+      } else {
+        profitClient.captureUnprofitableFill(deposit, realizedLpFeePct, relayerFeePct, gasCost);
+      }
+    } else if (selfRelay) {
+      const { realizedLpFeePct } = await hubPoolClient.computeRealizedLpFeePct({
+        ...deposit,
+        paymentChainId: destinationChainId,
+      });
+
+      // A relayer can fill its own deposit without an ERC20 transfer. Only bypass profitability requirements if the
+      // relayer is both the depositor and the recipient, because a deposit on a cheap SpokePool chain could cause
+      // expensive fills on (for example) mainnet.
+      this.fillRelay(deposit, destinationChainId, realizedLpFeePct);
+    } else {
+      // TokenClient.getBalance returns that we don't have enough balance to submit the fast fill.
+      // At this point, capture the shortfall so that the inventory manager can rebalance the token inventory.
+      tokenClient.captureTokenShortfallForFill(deposit, outputAmount);
+      if (sendSlowRelays && fillStatus === FillStatus.Unfilled) {
+        this.requestSlowFill(deposit);
+      }
+    }
+  }
+
   async checkForUnfilledDepositsAndFill(sendSlowRelays = true): Promise<void> {
     // Fetch all unfilled deposits, order by total earnable fee.
-    const { config } = this;
-    const { hubPoolClient, profitClient, spokePoolClients, tokenClient, multiCallerClient } = this.clients;
+    const { profitClient, spokePoolClients, tokenClient, multiCallerClient } = this.clients;
 
     // Flush any pre-existing enqueued transactions that might not have been executed.
     multiCallerClient.clearTransactionQueue();
 
     // Fetch unfilled deposits and filter out deposits upfront before we compute the minimum deposit confirmation
     // per chain, which is based on the deposit volume we could fill.
     const unfilledDeposits = await this._getUnfilledDeposits();
-    const allUnfilledDeposits = Object.values(unfilledDeposits.map(({ deposit }) => deposit));
+    const allUnfilledDeposits = unfilledDeposits.map(({ deposit, fillStatus }) => ({ ...deposit, fillStatus }));
     this.logger.debug({
       at: "Relayer#checkForUnfilledDepositsAndFill",
       message: `${allUnfilledDeposits.length} unfilled deposits found.`,
@@ -268,82 +334,12 @@ export class Relayer {
     }
 
     const mdcPerChain = this.computeRequiredDepositConfirmations(allUnfilledDeposits);
-
-    // Iterate over all unfilled deposits. For each unfilled deposit, check that:
-    // a) it exceeds the minimum number of required block confirmations,
-    // b) the token balance client has enough tokens to fill it,
-    // c) the fill is profitable.
-    // If all hold true then complete the fill. If there is insufficient balance to complete the fill and slow fills are
-    // enabled then request a slow fill instead.
-    const { slowDepositors } = config;
-    for (const deposit of allUnfilledDeposits) {
-      const { depositId, depositor, recipient, destinationChainId, originChainId, inputToken, outputAmount } = deposit;
-
-      // If the deposit does not meet the minimum number of block confirmations, skip it.
+    for (const { fillStatus, ...deposit } of allUnfilledDeposits) {
+      const { originChainId } = deposit;
       const maxBlockNumber = spokePoolClients[originChainId].latestBlockSearched - mdcPerChain[originChainId];
-      if (deposit.blockNumber > maxBlockNumber) {
-        const chain = getNetworkName(originChainId);
-        this.logger.debug({
-          at: "Relayer#checkForUnfilledDepositsAndFill",
-          message: `Skipping ${chain} deposit ${depositId} due to insufficient deposit confirmations.`,
-          depositId,
-          blockNumber: deposit.blockNumber,
-          maxBlockNumber,
-          transactionHash: deposit.transactionHash,
-        });
-        continue;
-      }
-
-      // If depositor is on the slow deposit list, then send a zero fill to initiate a slow relay and return early.
-      if (slowDepositors?.includes(depositor)) {
-        if (sendSlowRelays) {
-          this.logger.debug({
-            at: "Relayer#checkForUnfilledDepositsAndFill",
-            message: "Initiating slow fill for grey listed depositor",
-            depositor,
-          });
-          this.requestSlowFill(deposit);
-        }
-        // Regardless of whether we should send a slow fill or not for this depositor, exit early at this point
-        // so we don't fast fill an already slow filled deposit from the slow fill-only list.
-        continue;
-      }
-
-      const l1Token = hubPoolClient.getL1TokenInfoForL2Token(inputToken, originChainId);
-      const selfRelay = [depositor, recipient].every((address) => address === this.relayerAddress);
-      if (tokenClient.hasBalanceForFill(deposit, outputAmount) && !selfRelay) {
-        const {
-          repaymentChainId,
-          realizedLpFeePct,
-          relayerFeePct,
-          gasLimit: _gasLimit,
-          gasCost,
-        } = await this.resolveRepaymentChain(deposit, l1Token);
-        if (isDefined(repaymentChainId)) {
-          const gasLimit = isMessageEmpty(resolveDepositMessage(deposit)) ? undefined : _gasLimit;
-          this.fillRelay(deposit, repaymentChainId, realizedLpFeePct, gasLimit);
-        } else {
-          profitClient.captureUnprofitableFill(deposit, realizedLpFeePct, relayerFeePct, gasCost);
-        }
-      } else if (selfRelay) {
-        const { realizedLpFeePct } = await hubPoolClient.computeRealizedLpFeePct({
-          ...deposit,
-          paymentChainId: destinationChainId,
-        });
-
-        // A relayer can fill its own deposit without an ERC20 transfer. Only bypass profitability requirements if the
-        // relayer is both the depositor and the recipient, because a deposit on a cheap SpokePool chain could cause
-        // expensive fills on (for example) mainnet.
-        this.fillRelay(deposit, destinationChainId, realizedLpFeePct);
-      } else {
-        // TokenClient.getBalance returns that we don't have enough balance to submit the fast fill.
-        // At this point, capture the shortfall so that the inventory manager can rebalance the token inventory.
-        tokenClient.captureTokenShortfallForFill(deposit, outputAmount);
-        if (sendSlowRelays) {
-          this.requestSlowFill(deposit);
-        }
-      }
+      await this.evaluateFill(deposit, fillStatus, maxBlockNumber, sendSlowRelays);
     }
+
     // If during the execution run we had shortfalls or unprofitable fills then handel it by producing associated logs.
     if (tokenClient.anyCapturedShortFallFills()) {
       this.handleTokenShortfall();

src/relayer/RelayerClientHelper.ts

@@ -159,7 +159,6 @@ export async function updateRelayerClients(clients: RelayerClients, config: Rela
   await updateSpokePoolClients(spokePoolClients, [
     "V3FundsDeposited",
     "RequestedSpeedUpV3Deposit",
-    "RequestedV3SlowFill",
     "FilledV3Relay",
     "EnabledDepositRoute",
   ]);

src/utils/FillUtils.ts

@@ -4,6 +4,7 @@ import { HubPoolClient, SpokePoolClient } from "../clients";
 import {
   Fill,
   FillsToRefund,
+  FillStatus,
   FillWithBlock,
   SpokePoolClientsByChain,
   V2DepositWithBlock,
@@ -258,11 +259,12 @@ export function getFillsInRange(
 // @todo Better alignment with the upstream UnfilledDeposit type.
 export type RelayerUnfilledDeposit = {
   deposit: V3DepositWithBlock;
+  fillStatus: number;
   version: number;
   invalidFills: Fill[];
 };
 
-// @description Returns an array of unfilled deposits over all spokePoolClients.
+// @description Returns all unfilled deposits, indexed by destination chain.
 // @param spokePoolClients  Mapping of chainIds to SpokePoolClient objects.
 // @param configStoreClient ConfigStoreClient instance.
 // @param depositLookBack   Deposit lookback (in seconds) since SpokePoolClient time as at last update.
@@ -291,34 +293,39 @@ export async function getUnfilledDeposits(
   }
 
   // Iterate over each chainId and check for unfilled deposits.
-  chainIds.forEach((destinationChainId) => {
+  await sdkUtils.mapAsync(chainIds, async (destinationChainId) => {
     const destinationClient = spokePoolClients[destinationChainId];
 
-    unfilledDeposits[destinationChainId] = chainIds
+    // For each destination chain, query each _other_ SpokePool for deposits within the lookback.
+    const deposits = chainIds
       .filter((chainId) => chainId !== destinationChainId)
       .map((originChainId) => {
         const originClient = spokePoolClients[originChainId];
         const earliestBlockNumber = originFromBlocks[originChainId];
+        const { deploymentBlock, latestBlockSearched } = originClient;
 
         // Basic sanity check...
-        assert(
-          earliestBlockNumber >= originClient.deploymentBlock && earliestBlockNumber <= originClient.latestBlockSearched
-        );
+        assert(earliestBlockNumber >= deploymentBlock && earliestBlockNumber <= latestBlockSearched);
 
-        // Find all unfilled deposits for the current loops originChain -> destinationChain. Note that this also
-        // validates that the deposit is filled "correctly" for the given deposit information. This includes validation
-        // of the all deposit -> relay props, the realizedLpFeePct and the origin->destination token mapping.
+        // Find all unfilled deposits for the current loops originChain -> destinationChain.
         return originClient
           .getDepositsForDestinationChain(destinationChainId)
           .filter((deposit) => deposit.blockNumber >= earliestBlockNumber)
-          .filter(sdkUtils.isV3Deposit<V3DepositWithBlock, V2DepositWithBlock>) // @todo: Remove after v2 deprecated.
-          .map((deposit) => {
-            const version = hubPoolClient.configStoreClient.getConfigStoreVersionForTimestamp(deposit.quoteTimestamp);
-            return { ...destinationClient.getValidUnfilledAmountForDeposit(deposit), deposit, version };
-          })
-          .filter(({ unfilledAmount }) => unfilledAmount.gt(bnZero));
+          .filter(sdkUtils.isV3Deposit<V3DepositWithBlock, V2DepositWithBlock>); // @todo: Remove after v2 deprecated.
       })
       .flat();
+
+    // Resolve the latest fill status for each deposit and filter out any that are now filled.
+    const { spokePool } = destinationClient;
+    const fillStatus = await sdkUtils.fillStatusArray(spokePool, deposits);
+    unfilledDeposits[destinationChainId] = deposits
+      .map((deposit, idx) => ({ deposit, fillStatus: fillStatus[idx] }))
+      .filter(({ fillStatus }) => fillStatus !== FillStatus.Filled)
+      .map(({ deposit, fillStatus }) => {
+        const version = hubPoolClient.configStoreClient.getConfigStoreVersionForTimestamp(deposit.quoteTimestamp);
+        const { invalidFills } = destinationClient.getValidUnfilledAmountForDeposit(deposit);
+        return { deposit, version, fillStatus, invalidFills };
+      });
   });
 
   return unfilledDeposits;

test/Relayer.BasicFill.ts

@@ -2,7 +2,7 @@ import { clients, constants, utils as sdkUtils } from "@across-protocol/sdk-v2";
 import { AcrossApiClient, ConfigStoreClient, MultiCallerClient, TokenClient } from "../src/clients";
 import { V2FillWithBlock, V3FillWithBlock } from "../src/interfaces";
 import { CONFIG_STORE_VERSION } from "../src/common";
-import { bnOne } from "../src/utils";
+import { bnOne, getUnfilledDeposits } from "../src/utils";
 import { Relayer } from "../src/relayer/Relayer";
 import { RelayerConfig } from "../src/relayer/RelayerConfig"; // Tested
 import {
@@ -28,6 +28,7 @@ import {
   enableRoutesOnHubPool,
   ethers,
   expect,
+  fillV3Relay,
   getLastBlockTime,
   getV3RelayHash,
   lastSpyLogIncludes,
@@ -235,6 +236,39 @@ describe("Relayer: Check for Unfilled Deposits and Fill", async function () {
       expect(multiCallerClient.transactionCount()).to.equal(0); // no new transactions were enqueued.
     });
 
+    it("Queries the latest onchain fill status for all deposits", async function () {
+      const deposit = await depositV3(
+        spokePool_1,
+        destinationChainId,
+        depositor,
+        inputToken,
+        inputAmount,
+        outputToken,
+        outputAmount
+      );
+      await updateAllClients();
+      let unfilledDeposits = await getUnfilledDeposits(spokePoolClients, hubPoolClient);
+      expect(Object.values(unfilledDeposits).flat().length).to.equal(1);
+
+      await relayerInstance.checkForUnfilledDepositsAndFill();
+      expect(lastSpyLogIncludes(spy, "Filling v3 deposit")).to.be.true;
+      expect(multiCallerClient.transactionCount()).to.equal(1); // One transaction, filling the one deposit.
+
+      // Verify that the deposit is still unfilled (relayer didn't execute it).
+      unfilledDeposits = await getUnfilledDeposits(spokePoolClients, hubPoolClient);
+      expect(Object.values(unfilledDeposits).flat().length).to.equal(1);
+
+      // Fill the deposit and immediately check for unfilled deposits (without SpokePoolClient update).
+      await fillV3Relay(spokePool_2, deposit, relayer);
+      unfilledDeposits = await getUnfilledDeposits(spokePoolClients, hubPoolClient);
+      expect(Object.values(unfilledDeposits).flat().length).to.equal(0);
+
+      // Verify that the relayer now sees that the deposit has been filled.
+      await relayerInstance.checkForUnfilledDepositsAndFill();
+      expect(lastSpyLogIncludes(spy, "0 unfilled deposits")).to.be.true;
+      expect(multiCallerClient.transactionCount()).to.equal(0);
+    });
+
     it("Respects configured relayer routes", async function () {
       relayerInstance = new Relayer(
         relayer.address,

test/Relayer.UnfilledDeposits.ts

@@ -1,6 +1,7 @@
 import * as contracts from "@across-protocol/contracts-v2/dist/test-utils";
 import { clients, utils as sdkUtils } from "@across-protocol/sdk-v2";
 import { AcrossApiClient, ConfigStoreClient, MultiCallerClient, TokenClient } from "../src/clients";
+import { FillStatus } from "../src/interfaces";
 import {
   CHAIN_ID_TEST_LIST,
   amountToLp,
@@ -183,9 +184,8 @@ describe("Relayer: Unfilled Deposits", async function () {
         [...deposits]
           .sort((a, b) => (a.destinationChainId > b.destinationChainId ? 1 : -1))
           .map((deposit) => ({
-            unfilledAmount: deposit.outputAmount,
             deposit,
-            fillCount: 0,
+            fillStatus: FillStatus.Unfilled,
             invalidFills: [],
             version: configStoreClient.configStoreVersion,
           }))
@@ -216,9 +216,8 @@ describe("Relayer: Unfilled Deposits", async function () {
       .excludingEvery(["realizedLpFeePct", "quoteBlockNumber"])
       .to.deep.equal([
         {
-          unfilledAmount: deposit.outputAmount,
-          deposit: deposit,
-          fillCount: 0,
+          deposit,
+          fillStatus: FillStatus.Unfilled,
           invalidFills: [invalidFill],
           version: configStoreClient.configStoreVersion,
         },
@@ -372,9 +371,8 @@ describe("Relayer: Unfilled Deposits", async function () {
       .excludingEvery(["realizedLpFeePct", "quoteBlockNumber"])
       .to.deep.equal([
         {
-          unfilledAmount: deposit.outputAmount,
-          deposit: deposit,
-          fillCount: 0,
+          deposit,
+          fillStatus: FillStatus.Unfilled,
           invalidFills: [invalidFill],
           version: configStoreClient.configStoreVersion,
         },