@across-protocol/sdk 3.4.15 → 3.4.16

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -30,6 +30,7 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
+  filterAsync,
   bnUint32Max,
   isZeroValueDeposit,
   chainIsEvm,
@@ -48,6 +49,7 @@ import {
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
+  verifyFillRepayment,
 } from "./utils";
 
 // max(uint256) - 1
@@ -81,10 +83,11 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: string
+  repaymentToken: string,
+  repaymentAddress: string
 ): void {
   // It is impossible to refund a deposit if the repayment chain is EVM and the relayer is a non-evm address.
-  if (chainIsEvm(fill.repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
+  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(repaymentAddress)) {
     return;
   }
   if (!dict?.[repaymentChainId]?.[repaymentToken]) {
@@ -96,19 +99,19 @@ function updateBundleFillsV3(
     });
   }
 
-  const bundleFill: BundleFillV3 = { ...fill, lpFeePct };
+  const bundleFill: BundleFillV3 = { ...fill, lpFeePct, relayer: repaymentAddress };
 
   // Add all fills, slow and fast, to dictionary.
   assign(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
 
   // All fills update the bundle LP fees.
   const refundObj = dict[repaymentChainId][repaymentToken];
-  const realizedLpFee = fill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
+  const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
   // Only fast fills get refunded.
-  if (!isSlowFill(fill)) {
-    const refundAmount = fill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
+  if (!isSlowFill(bundleFill)) {
+    const refundAmount = bundleFill.inputAmount.mul(fixedPointAdjustment.sub(lpFeePct)).div(fixedPointAdjustment);
     refundObj.totalRefundAmount = refundObj.totalRefundAmount
       ? refundObj.totalRefundAmount.add(refundAmount)
       : refundAmount;
@@ -116,10 +119,10 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[fill.relayer]) {
-      refundObj.refunds[fill.relayer] = refundObj.refunds[fill.relayer].add(refundAmount);
+    if (refundObj.refunds[bundleFill.relayer]) {
+      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
     } else {
-      refundObj.refunds[fill.relayer] = refundAmount;
+      refundObj.refunds[bundleFill.relayer] = refundAmount;
     }
   }
 }
@@ -287,7 +290,7 @@ export class BundleDataClient {
     // so as not to affect this approximate refund count.
     const arweaveData = await this.loadArweaveData(bundleEvaluationBlockRanges);
     if (arweaveData === undefined) {
-      combinedRefunds = this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
+      combinedRefunds = await this.getApproximateRefundsForBlockRange(chainIds, bundleEvaluationBlockRanges);
     } else {
       const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
       combinedRefunds = getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3);
@@ -308,50 +311,63 @@ export class BundleDataClient {
   }
 
   // @dev This helper function should probably be moved to the InventoryClient
-  getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): CombinedRefunds {
+  async getApproximateRefundsForBlockRange(chainIds: number[], blockRanges: number[][]): Promise<CombinedRefunds> {
     const refundsForChain: CombinedRefunds = {};
     for (const chainId of chainIds) {
       if (this.spokePoolClients[chainId] === undefined) {
         continue;
       }
       const chainIndex = chainIds.indexOf(chainId);
-      this.spokePoolClients[chainId]
-        .getFills()
-        .filter((fill) => {
-          if (fill.blockNumber < blockRanges[chainIndex][0] || fill.blockNumber > blockRanges[chainIndex][1]) {
-            return false;
-          }
+      const fillsToCount = await filterAsync(this.spokePoolClients[chainId].getFills(), async (fill) => {
+        if (fill.blockNumber < blockRanges[chainIndex][0] || fill.blockNumber > blockRanges[chainIndex][1]) {
+          return false;
+        }
 
-          // If origin spoke pool client isn't defined, we can't validate it.
-          if (this.spokePoolClients[fill.originChainId] === undefined) {
-            return false;
-          }
-          const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-          const hasMatchingDeposit =
-            matchingDeposit !== undefined &&
-            this.getRelayHashFromEvent(fill) === this.getRelayHashFromEvent(matchingDeposit);
-          return hasMatchingDeposit;
-        })
-        .forEach((fill) => {
-          const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
-          assert(isDefined(matchingDeposit), "Deposit not found for fill.");
-          const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
+        // If origin spoke pool client isn't defined, we can't validate it.
+        if (this.spokePoolClients[fill.originChainId] === undefined) {
+          return false;
+        }
+        const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+        const hasMatchingDeposit =
+          matchingDeposit !== undefined &&
+          this.getRelayHashFromEvent(fill) === this.getRelayHashFromEvent(matchingDeposit);
+        if (hasMatchingDeposit) {
+          const validRepayment = await verifyFillRepayment(
             fill,
-            this.clients.hubPoolClient,
-            blockRanges,
-            this.chainIdListForBundleEvaluationBlockNumbers,
-            matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+            this.spokePoolClients[fill.destinationChainId].spokePool.provider,
+            matchingDeposit,
+            // @dev: to get valid repayment chain ID's, get all chain IDs for the bundle block range and remove
+            // disabled block ranges.
+            this.clients.configStoreClient
+              .getChainIdIndicesForBlock(blockRanges[0][1])
+              .filter((_chainId, i) => !isChainDisabled(blockRanges[i]))
           );
-          // Assume that lp fees are 0 for the sake of speed. In the future we could batch compute
-          // these or make hardcoded assumptions based on the origin-repayment chain direction. This might result
-          // in slight over estimations of refunds, but its not clear whether underestimating or overestimating is
-          // worst from the relayer's perspective.
-          const { relayer, inputAmount: refundAmount } = fill;
-          refundsForChain[chainToSendRefundTo] ??= {};
-          refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
-          const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
-          refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
-        });
+          if (!isDefined(validRepayment)) {
+            return false;
+          }
+        }
+        return hasMatchingDeposit;
+      });
+      fillsToCount.forEach((fill) => {
+        const matchingDeposit = this.spokePoolClients[fill.originChainId].getDeposit(fill.depositId);
+        assert(isDefined(matchingDeposit), "Deposit not found for fill.");
+        const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
+          fill,
+          this.clients.hubPoolClient,
+          blockRanges,
+          this.chainIdListForBundleEvaluationBlockNumbers,
+          matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+        );
+        // Assume that lp fees are 0 for the sake of speed. In the future we could batch compute
+        // these or make hardcoded assumptions based on the origin-repayment chain direction. This might result
+        // in slight over estimations of refunds, but its not clear whether underestimating or overestimating is
+        // worst from the relayer's perspective.
+        const { relayer, inputAmount: refundAmount } = fill;
+        refundsForChain[chainToSendRefundTo] ??= {};
+        refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
+        const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
+        refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
+      });
     }
     return refundsForChain;
   }
@@ -478,7 +494,7 @@ export class BundleDataClient {
       // ok for this use case.
       const arweaveData = await this.loadArweaveData(pendingBundleBlockRanges);
       if (arweaveData === undefined) {
-        combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
+        combinedRefunds.push(await this.getApproximateRefundsForBlockRange(chainIds, pendingBundleBlockRanges));
       } else {
         const { bundleFillsV3, expiredDepositsToRefundV3 } = arweaveData;
         combinedRefunds.push(getRefundsFromBundle(bundleFillsV3, expiredDepositsToRefundV3));
@@ -493,7 +509,7 @@ export class BundleDataClient {
     // - Only look up fills sent after the pending bundle's end blocks
     // - Skip LP fee computations and just assume the relayer is being refunded the full deposit.inputAmount
     const start = performance.now();
-    combinedRefunds.push(this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
+    combinedRefunds.push(await this.getApproximateRefundsForBlockRange(chainIds, widestBundleBlockRanges));
     this.logger.debug({
       at: "BundleDataClient#getNextBundleRefunds",
       message: `Loading approximate refunds for next bundle in ${Math.round(performance.now() - start) / 1000}s.`,
@@ -868,16 +884,28 @@ export class BundleDataClient {
             // tokens to the filler. We can't remove non-empty message deposit here in case there is a slow fill
             // request for the deposit, we'd want to see the fill took place.
             .filter((fill) => fill.blockNumber <= destinationChainBlockRange[1] && !isZeroValueDeposit(fill)),
-          async (fill) => {
-            const relayDataHash = this.getRelayHashFromEvent(fill);
+          async (_fill) => {
             fillCounter++;
-
+            const relayDataHash = this.getRelayHashFromEvent(_fill);
             if (v3RelayHashes[relayDataHash]) {
               if (!v3RelayHashes[relayDataHash].fill) {
                 assert(
                   isDefined(v3RelayHashes[relayDataHash].deposit),
                   "Deposit should exist in relay hash dictionary."
                 );
+                // `fill` will only possibly differ from `_fill` in the `relayer` field, which does not affect the
+                // relay hash, so it is safe to modify.
+                const fill = await verifyFillRepayment(
+                  _fill,
+                  destinationClient.spokePool.provider,
+                  v3RelayHashes[relayDataHash].deposit!,
+                  allChainIds
+                );
+                if (!isDefined(fill)) {
+                  bundleInvalidFillsV3.push(_fill);
+                  return;
+                }
+
                 // At this point, the v3RelayHashes entry already existed meaning that there is a matching deposit,
                 // so this fill is validated.
                 v3RelayHashes[relayDataHash].fill = fill;
@@ -903,10 +931,10 @@ export class BundleDataClient {
             }
 
             // At this point, there is no relay hash dictionary entry for this fill, so we need to
-            // instantiate the entry.
+            // instantiate the entry. We won't modify the fill.relayer until we match it with a deposit.
             v3RelayHashes[relayDataHash] = {
               deposit: undefined,
-              fill: fill,
+              fill: _fill,
               slowFillRequest: undefined,
             };
 
@@ -918,34 +946,34 @@ export class BundleDataClient {
             // older deposit in case the spoke pool client's lookback isn't old enough to find the matching deposit.
             // We can skip this step if the fill's fill deadline is not infinite, because we can assume that the
             // spoke pool clients have loaded deposits old enough to cover all fills with a non-infinite fill deadline.
-            if (fill.blockNumber >= destinationChainBlockRange[0]) {
+            if (_fill.blockNumber >= destinationChainBlockRange[0]) {
               // Fill has a non-infinite expiry, and we can assume our spoke pool clients have old enough deposits
               // to conclude that this fill is invalid if we haven't found a matching deposit in memory, so
               // skip the historical query.
-              if (!INFINITE_FILL_DEADLINE.eq(fill.fillDeadline)) {
-                bundleInvalidFillsV3.push(fill);
+              if (!INFINITE_FILL_DEADLINE.eq(_fill.fillDeadline)) {
+                bundleInvalidFillsV3.push(_fill);
                 return;
               }
-              // If the fill's repayment address is not a valid EVM address and the repayment chain is an EVM chain, the fill is invalid.
-              if (chainIsEvm(fill.repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
-                const fillTransaction = await originClient.spokePool.provider.getTransaction(fill.transactionHash);
-                const originRelayer = fillTransaction.from;
-                // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
-                if (!isValidEvmAddress(originRelayer)) {
-                  bundleInvalidFillsV3.push(fill);
-                  return;
-                }
-                // Otherwise, assume the relayer to be repaid is the msg.sender.
-                fill.relayer = originRelayer;
-              }
               // If deposit is using the deterministic relay hash feature, then the following binary search-based
               // algorithm will not work. However, it is impossible to emit an infinite fill deadline using
               // the unsafeDepositV3 function so there is no need to catch the special case.
-              const historicalDeposit = await queryHistoricalDepositForFill(originClient, fill);
+              const historicalDeposit = await queryHistoricalDepositForFill(originClient, _fill);
               if (!historicalDeposit.found) {
-                bundleInvalidFillsV3.push(fill);
+                bundleInvalidFillsV3.push(_fill);
               } else {
                 const matchedDeposit = historicalDeposit.deposit;
+                const fill = await verifyFillRepayment(
+                  _fill,
+                  destinationClient.spokePool.provider,
+                  matchedDeposit,
+                  allChainIds
+                );
+                if (!isDefined(fill)) {
+                  bundleInvalidFillsV3.push(_fill);
+                  return;
+                }
+                v3RelayHashes[relayDataHash].fill = fill;
+
                 // @dev Since queryHistoricalDepositForFill validates the fill by checking individual
                 // object property values against the deposit's, we
                 // sanity check it here by comparing the full relay hashes. If there's an error here then the
@@ -1286,7 +1314,7 @@ export class BundleDataClient {
         chainIds,
         associatedDeposit!.fromLiteChain
       );
-      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken);
+      updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken, fill.relayer);
     });
     v3SlowFillLpFees.forEach(({ realizedLpFeePct: lpFeePct }, idx) => {
       const deposit = validatedBundleSlowFills[idx];

package/src/clients/BundleDataClient/utils/FillUtils.ts

@@ -1,5 +1,7 @@
-import { Fill } from "../../../interfaces";
-import { getBlockRangeForChain, isSlowFill } from "../../../utils";
+import _ from "lodash";
+import { providers } from "ethers";
+import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
+import { getBlockRangeForChain, isSlowFill, chainIsEvm, isValidEvmAddress, isDefined } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 
 export function getRefundInformationFromFill(
@@ -44,3 +46,46 @@ export function getRefundInformationFromFill(
     repaymentToken,
   };
 }
+
+// Verify that a fill sent to an EVM chain has a 20 byte address. If the fill does not, then attempt
+// to repay the `msg.sender` of the relay transaction. Otherwise, return undefined.
+export async function verifyFillRepayment(
+  fill: FillWithBlock,
+  destinationChainProvider: providers.Provider,
+  matchedDeposit: DepositWithBlock,
+  possibleRepaymentChainIds: number[]
+): Promise<FillWithBlock | undefined> {
+  // Slow fills don't result in repayments so they're always valid.
+  if (isSlowFill(fill)) {
+    return fill;
+  }
+  // Lite chain deposits force repayment on origin chain.
+  const repaymentChainId = matchedDeposit.fromLiteChain ? fill.originChainId : fill.repaymentChainId;
+  // Return undefined if the requested repayment chain ID is not recognized by the hub pool.
+  if (!possibleRepaymentChainIds.includes(repaymentChainId)) {
+    return undefined;
+  }
+  const updatedFill = _.cloneDeep(fill);
+
+  // If the fill requests repayment on a chain where the repayment address is not valid, attempt to find a valid
+  // repayment address, otherwise return undefined.
+
+  // Case 1: repayment chain is an EVM chain but repayment address is not a valid EVM address.
+  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(updatedFill.relayer)) {
+    // TODO: Handle case where fill was sent on non-EVM chain, in which case the following call would fail
+    // or return something unexpected. We'd want to return undefined here.
+    const fillTransaction = await destinationChainProvider.getTransaction(updatedFill.transactionHash);
+    const destinationRelayer = fillTransaction?.from;
+    // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
+    if (!isDefined(destinationRelayer) || !isValidEvmAddress(destinationRelayer)) {
+      return undefined;
+    }
+    // Otherwise, assume the relayer to be repaid is the msg.sender. We don't need to modify the repayment chain since
+    // the getTransaction() call would only succeed if the fill was sent on an EVM chain and therefore the msg.sender
+    // is a valid EVM address and the repayment chain is an EVM chain.
+    updatedFill.relayer = destinationRelayer;
+  }
+
+  // Case 2: TODO repayment chain is an SVM chain and repayment address is not a valid SVM address.
+  return updatedFill;
+}

package/src/providers/index.ts

@@ -5,3 +5,4 @@ export * from "./speedProvider";
 export * from "./constants";
 export * from "./types";
 export * from "./utils";
+export * as mocks from "./mockProvider";

package/src/providers/mockProvider.ts

@@ -0,0 +1,77 @@
+import { BigNumber, providers } from "ethers";
+import { Block, BlockTag, FeeData, TransactionResponse } from "@ethersproject/abstract-provider";
+import { bnZero } from "../utils/BigNumberUtils";
+
+/**
+ * @notice Class used to test GasPriceOracle which makes ethers provider calls to the following implemented
+ * methods.
+ */
+export class MockedProvider extends providers.StaticJsonRpcProvider {
+  private transactions: { [hash: string]: TransactionResponse } = {};
+
+  constructor(
+    readonly stdLastBaseFeePerGas: BigNumber,
+    readonly stdMaxPriorityFeePerGas: BigNumber,
+    readonly defaultChainId = 1
+  ) {
+    super(undefined, defaultChainId);
+  }
+
+  getBlock(_blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block> {
+    const mockBlock: Block = {
+      transactions: [],
+      hash: "0x",
+      parentHash: "0x",
+      number: 0,
+      nonce: "0",
+      difficulty: 0,
+      _difficulty: bnZero,
+      timestamp: 0,
+      gasLimit: bnZero,
+      gasUsed: bnZero,
+      baseFeePerGas: this.stdLastBaseFeePerGas,
+      miner: "0x",
+      extraData: "0x",
+    };
+    return Promise.resolve(mockBlock);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  send(method: string, _params: Array<any>): Promise<any> {
+    switch (method) {
+      case "eth_maxPriorityFeePerGas":
+        return Promise.resolve(this.stdMaxPriorityFeePerGas);
+      default:
+        throw new Error(`MockedProvider#Unimplemented method: ${method}`);
+    }
+  }
+
+  getFeeData(): Promise<FeeData> {
+    return Promise.resolve({
+      lastBaseFeePerGas: this.stdLastBaseFeePerGas,
+      maxPriorityFeePerGas: this.stdMaxPriorityFeePerGas,
+      // Following fields unused in GasPrice oracle
+      maxFeePerGas: null,
+      gasPrice: null,
+    });
+  }
+
+  getTransaction(hash: string): Promise<TransactionResponse> {
+    return Promise.resolve(this.transactions[hash]);
+  }
+
+  getGasPrice(): Promise<BigNumber> {
+    return Promise.resolve(this.stdLastBaseFeePerGas.add(this.stdMaxPriorityFeePerGas));
+  }
+
+  getNetwork(): Promise<{ chainId: number; name: string }> {
+    return Promise.resolve({
+      name: "mocknetwork",
+      chainId: this.defaultChainId,
+    });
+  }
+
+  _setTransaction(hash: string, transaction: TransactionResponse) {
+    this.transactions[hash] = transaction;
+  }
+}