Merge branch 'master' into pxrl/listenerCrash

Author: pxrl

src/relayer/Relayer.ts

@@ -3,6 +3,7 @@ import { utils as sdkUtils } from "@across-protocol/sdk";
 import { utils as ethersUtils } from "ethers";
 import { FillStatus, L1Token, V3Deposit, V3DepositWithBlock } from "../interfaces";
 import {
+  averageBlockTime,
   BigNumber,
   bnZero,
   bnUint256Max,
@@ -481,15 +482,15 @@ export class Relayer {
     sendSlowRelays: boolean
   ): Promise<void> {
     const { depositId, depositor, recipient, destinationChainId, originChainId, inputToken } = deposit;
-    const { hubPoolClient, profitClient, tokenClient } = this.clients;
+    const { hubPoolClient, profitClient, spokePoolClients, tokenClient } = this.clients;
     const { slowDepositors } = this.config;
 
     // If the deposit does not meet the minimum number of block confirmations, skip it.
+    const originChain = getNetworkName(originChainId);
     if (deposit.blockNumber > maxBlockNumber) {
-      const chain = getNetworkName(originChainId);
       this.logger.debug({
         at: "Relayer::evaluateFill",
-        message: `Skipping ${chain} deposit ${depositId} due to insufficient deposit confirmations.`,
+        message: `Skipping ${originChain} deposit ${depositId} due to insufficient deposit confirmations.`,
         depositId,
         blockNumber: deposit.blockNumber,
         maxBlockNumber,
@@ -513,6 +514,28 @@ export class Relayer {
       return;
     }
 
+    // If the operator configured a minimum fill time for a destination chain, ensure that the deposit
+    // is at least that old before filling it. This is mainly useful on chains with long block times,
+    // where there is a high chance of fill collisions in the first blocks after a deposit is made.
+    const minFillTime = this.config.minFillTime?.[destinationChainId] ?? 0;
+    if (minFillTime > 0 && deposit.exclusiveRelayer !== this.relayerAddress) {
+      const originSpoke = spokePoolClients[originChainId];
+      const { average: avgBlockTime } = await averageBlockTime(originSpoke.spokePool.provider);
+      const depositAge = Math.floor(avgBlockTime * (originSpoke.latestBlockSearched - deposit.blockNumber));
+
+      if (minFillTime > depositAge) {
+        const dstChain = getNetworkName(destinationChainId);
+        this.logger.debug({
+          at: "Relayer::evaluateFill",
+          message: `Skipping ${originChain} deposit due to insufficient fill time for ${dstChain}.`,
+          depositAge,
+          minFillTime,
+          transactionHash: deposit.transactionHash,
+        });
+        return;
+      }
+    }
+
     const l1Token = hubPoolClient.getL1TokenInfoForL2Token(inputToken, originChainId);
     const selfRelay = [depositor, recipient].every((address) => address === this.relayerAddress);
     if (tokenClient.hasBalanceForFill(deposit) && !selfRelay) {
@@ -531,7 +554,6 @@ export class Relayer {
 
         // Ensure that a limit was identified, and that no upper thresholds would be breached by filling this deposit.
         if (this.originChainOvercommitted(originChainId, fillAmountUsd, limitIdx)) {
-          const originChain = getNetworkName(originChainId);
           const limits = this.fillLimits[originChainId].slice(limitIdx);
           this.logger.debug({
             at: "Relayer::evaluateFill",

src/relayer/RelayerConfig.ts

@@ -46,6 +46,7 @@ export class RelayerConfig extends CommonConfig {
   readonly relayerGasMultiplier: BigNumber;
   readonly relayerMessageGasMultiplier: BigNumber;
   readonly minRelayerFeePct: BigNumber;
+  readonly minFillTime: { [chainId: number]: number } = {};
   readonly acceptInvalidFills: boolean;
   // List of depositors we only want to send slow fills for.
   readonly slowDepositors: string[];
@@ -333,6 +334,10 @@ export class RelayerConfig extends CommonConfig {
       });
     }
 
+    chainIds.forEach(
+      (chainId) => (this.minFillTime[chainId] = Number(process.env[`RELAYER_MIN_FILL_TIME_${chainId}`] ?? 0))
+    );
+
     // Only validate config for chains that the relayer cares about.
     super.validate(relayerChainIds, logger);
   }

src/utils/SDKUtils.ts

@@ -7,6 +7,7 @@ export class PriceClient extends sdk.priceClient.PriceClient {}
 export const { acrossApi, coingecko, defiLlama } = sdk.priceClient.adapters;
 
 export const {
+  averageBlockTime,
   bnZero,
   bnOne,
   bnUint32Max,

test/Relayer.BasicFill.ts

@@ -2,7 +2,7 @@ import { clients, constants, utils as sdkUtils } from "@across-protocol/sdk";
 import { AcrossApiClient, ConfigStoreClient, MultiCallerClient, TokenClient } from "../src/clients";
 import { FillStatus, V3Deposit, V3RelayData } from "../src/interfaces";
 import { CONFIG_STORE_VERSION } from "../src/common";
-import { bnZero, bnOne, bnUint256Max, getNetworkName, getAllUnfilledDeposits } from "../src/utils";
+import { averageBlockTime, bnZero, bnOne, bnUint256Max, getNetworkName, getAllUnfilledDeposits } from "../src/utils";
 import { Relayer } from "../src/relayer/Relayer";
 import { RelayerConfig } from "../src/relayer/RelayerConfig"; // Tested
 import {
@@ -499,6 +499,67 @@ describe("Relayer: Check for Unfilled Deposits and Fill", async function () {
       expect(lastSpyLogIncludes(spy, "0 unfilled deposits found.")).to.be.true;
     });
 
+    it("Correctly defers destination chain fills", async function () {
+      let { average: avgBlockTime } = await averageBlockTime(spokePool_2.provider);
+      avgBlockTime = Math.ceil(avgBlockTime);
+      const minFillTime = 4 * avgBlockTime; // Fill after deposit has aged 4 blocks.
+
+      relayerInstance = new Relayer(
+        relayer.address,
+        spyLogger,
+        {
+          spokePoolClients,
+          hubPoolClient,
+          configStoreClient,
+          tokenClient,
+          profitClient,
+          multiCallerClient,
+          inventoryClient: new MockInventoryClient(null, null, null, null, null, hubPoolClient),
+          acrossApiClient: new AcrossApiClient(spyLogger, hubPoolClient, chainIds),
+        },
+        {
+          minFillTime: { [destinationChainId]: minFillTime },
+          relayerTokens: [],
+          minDepositConfirmations: defaultMinDepositConfirmations,
+          sendingRelaysEnabled: true,
+        } as unknown as RelayerConfig
+      );
+
+      const deposit = await depositV3(
+        spokePool_1,
+        destinationChainId,
+        depositor,
+        inputToken,
+        inputAmount,
+        outputToken,
+        outputAmount
+      );
+      await updateAllClients();
+      let txnReceipts = await relayerInstance.checkForUnfilledDepositsAndFill();
+      for (const receipts of Object.values(txnReceipts)) {
+        expect((await receipts).length).to.equal(0);
+      }
+      expect(lastSpyLogIncludes(spy, "due to insufficient fill time for")).to.be.true;
+
+      // SpokePool time is overridden and does not increment; it must be cranked manually.
+      const startTime = Number(await spokePool_2.getCurrentTime());
+      let nextTime: number;
+      do {
+        await fillV3Relay(
+          spokePool_2,
+          { ...deposit, depositId: deposit.depositId + 1, outputAmount: bnZero, recipient: randomAddress() },
+          relayer
+        );
+        nextTime = Number(await spokePool_2.getCurrentTime()) + avgBlockTime;
+        await spokePool_2.setCurrentTime(nextTime);
+      } while (startTime + minFillTime > nextTime);
+
+      await updateAllClients();
+      txnReceipts = await relayerInstance.checkForUnfilledDepositsAndFill();
+      const receipts = await txnReceipts[destinationChainId];
+      expect(receipts.length).to.equal(1);
+    });
+
     it("Correctly tracks origin chain fill commitments", async function () {
       await erc20_2.connect(relayer).approve(spokePool_2.address, MAX_SAFE_ALLOWANCE);