@across-protocol/sdk 3.4.14 → 3.4.16

package/dist/types/providers/index.d.ts

@@ -5,4 +5,5 @@ export * from "./speedProvider";
 export * from "./constants";
 export * from "./types";
 export * from "./utils";
+export * as mocks from "./mockProvider";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/providers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC"}

package/dist/types/providers/mockProvider.d.ts

@@ -0,0 +1,24 @@
+import { BigNumber, providers } from "ethers";
+import { Block, BlockTag, FeeData, TransactionResponse } from "@ethersproject/abstract-provider";
+/**
+ * @notice Class used to test GasPriceOracle which makes ethers provider calls to the following implemented
+ * methods.
+ */
+export declare class MockedProvider extends providers.StaticJsonRpcProvider {
+    readonly stdLastBaseFeePerGas: BigNumber;
+    readonly stdMaxPriorityFeePerGas: BigNumber;
+    readonly defaultChainId: number;
+    private transactions;
+    constructor(stdLastBaseFeePerGas: BigNumber, stdMaxPriorityFeePerGas: BigNumber, defaultChainId?: number);
+    getBlock(_blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    send(method: string, _params: Array<any>): Promise<any>;
+    getFeeData(): Promise<FeeData>;
+    getTransaction(hash: string): Promise<TransactionResponse>;
+    getGasPrice(): Promise<BigNumber>;
+    getNetwork(): Promise<{
+        chainId: number;
+        name: string;
+    }>;
+    _setTransaction(hash: string, transaction: TransactionResponse): void;
+}
+//# sourceMappingURL=mockProvider.d.ts.map

package/dist/types/providers/mockProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/mockProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAGjG;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,qBAAqB;IAI/D,QAAQ,CAAC,oBAAoB,EAAE,SAAS;IACxC,QAAQ,CAAC,uBAAuB,EAAE,SAAS;IAC3C,QAAQ,CAAC,cAAc;IALzB,OAAO,CAAC,YAAY,CAA+C;gBAGxD,oBAAoB,EAAE,SAAS,EAC/B,uBAAuB,EAAE,SAAS,EAClC,cAAc,SAAI;IAK7B,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC;IAoB9F,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;IASvD,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAU9B,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI1D,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC;IAIjC,UAAU,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAOxD,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB;CAG/D"}

package/dist/types/utils/AddressUtils.d.ts

@@ -8,4 +8,5 @@ import { providers } from "ethers";
 export declare function isContractDeployedToAddress(address: string, provider: providers.Provider): Promise<boolean>;
 export declare function compareAddresses(addressA: string, addressB: string): 1 | -1 | 0;
 export declare function compareAddressesSimple(addressA?: string, addressB?: string): boolean;
+export declare function isValidEvmAddress(address: string): boolean;
 //# sourceMappingURL=AddressUtils.d.ts.map

package/dist/types/utils/AddressUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AddressUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/AddressUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAS,MAAM,QAAQ,CAAC;AAG1C;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjH;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAY/E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAKpF"}
+{"version":3,"file":"AddressUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/AddressUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAS,MAAM,QAAQ,CAAC;AAG1C;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjH;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAY/E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAKpF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAc1D"}

package/dist/types/utils/DepositUtils.d.ts

@@ -3,7 +3,8 @@ import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, SlowFillReq
 export declare enum InvalidFill {
     DepositIdInvalid = 0,
     DepositIdNotFound = 1,
-    FillMismatch = 2
+    FillMismatch = 2,
+    DepositIdOutOfRange = 3
 }
 export type DepositSearchResult = {
     found: true;

package/dist/types/utils/DepositUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DepositUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/DepositUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,yBAAyB,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAY5G,oBAAY,WAAW;IACrB,gBAAgB,IAAI;IACpB,iBAAiB,IAAA;IACjB,YAAY,IAAA;CACb;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,GAC1C;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,wBAAsB,6BAA6B,CACjD,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,IAAI,GAAG,eAAe,EAC5B,KAAK,CAAC,EAAE,yBAAyB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CAoF9B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC,GAAG,OAAO,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAgB,GAAG,OAAO,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAI9D"}
+{"version":3,"file":"DepositUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/DepositUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,yBAAyB,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAa5G,oBAAY,WAAW;IACrB,gBAAgB,IAAI;IACpB,iBAAiB,IAAA;IACjB,YAAY,IAAA;IACZ,mBAAmB,IAAA;CACpB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,GAC1C;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,wBAAsB,6BAA6B,CACjD,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,IAAI,GAAG,eAAe,EAC5B,KAAK,CAAC,EAAE,yBAAyB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CA2F9B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC,GAAG,OAAO,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAgB,GAAG,OAAO,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAI9D"}

package/dist/types/utils/NetworkUtils.d.ts

@@ -76,6 +76,12 @@ export declare function chainIsLinea(chainId: number): boolean;
  * @returns True if chain corresponding to chainId has a hub pool implementation.
  */
 export declare function chainIsL1(chainId: number): boolean;
+/**
+ * Determines whether a chain ID runs on an EVM-like execution layer.
+ * @param chainId Chain ID to evaluate.
+ * @returns True if chain corresponding to chainId has an EVM-like execution layer.
+ */
+export declare function chainIsEvm(chainId: number): boolean;
 /**
  * Determines whether a chain ID has the capacity for having its USDC bridged via CCTP.
  * @param chainId Chain ID to evaluate.

package/dist/types/utils/NetworkUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMpD"}
+{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAInD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMpD"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "3.4.14",
+  "version": "3.4.16",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -30,8 +30,11 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
+  filterAsync,
   bnUint32Max,
   isZeroValueDeposit,
+  chainIsEvm,
+  isValidEvmAddress,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -46,6 +49,7 @@ import {
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
+  verifyFillRepayment,
 } from "./utils";
 
 // max(uint256) - 1
@@ -55,6 +59,10 @@ type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 
 // V3 dictionary helper functions
 function updateExpiredDepositsV3(dict: ExpiredDepositsToRefundV3, deposit: V3DepositWithBlock): void {
+  // A deposit refund for a deposit is invalid if the depositor has a bytes32 address input for an EVM chain. It is valid otherwise.
+  if (chainIsEvm(deposit.originChainId) && !isValidEvmAddress(deposit.depositor)) {
+    return;
+  }
   const { originChainId, inputToken } = deposit;
   if (!dict?.[originChainId]?.[inputToken]) {
     assign(dict, [originChainId, inputToken], []);
@@ -75,8 +83,13 @@ 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(repaymentChainId) && !isValidEvmAddress(repaymentAddress)) {
+    return;
+  }
   if (!dict?.[repaymentChainId]?.[repaymentToken]) {
     assign(dict, [repaymentChainId, repaymentToken], {
       fills: [],
@@ -86,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;
@@ -106,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;
     }
   }
 }
@@ -277,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);
@@ -298,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;
   }
@@ -468,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));
@@ -483,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.`,
@@ -807,6 +833,8 @@ export class BundleDataClient {
 
           // If deposit block is within origin chain bundle block range, then save as bundle deposit.
           // If deposit is in bundle and it has expired, additionally save it as an expired deposit.
+          // Note: if the `depositor` field in the expired deposit is an invalid address, e.g. a bytes32 address on an EVM
+          // chain, then the deposit refund is invalid and ignored.
           // If deposit is not in the bundle block range, then save it as an older deposit that
           // may have expired.
           if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
@@ -856,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;
@@ -891,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,
             };
 
@@ -906,22 +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 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
@@ -1262,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;
+  }
+}

package/src/utils/AddressUtils.ts

@@ -38,3 +38,19 @@ export function compareAddressesSimple(addressA?: string, addressB?: string): bo
   }
   return addressA.toLowerCase() === addressB.toLowerCase();
 }
+
+export function isValidEvmAddress(address: string): boolean {
+  if (utils.isAddress(address)) {
+    return true;
+  }
+  // We may throw an error here if hexZeroPadFails. This will happen if the address to pad is greater than 20 bytes long, indicating
+  // that the address had less than 12 leading zero bytes.
+  // We may also throw at getAddress if the input cannot be converted into a checksummed EVM address for some reason.
+  // For both cases, this indicates that the address cannot be casted as a bytes20 EVM address, so we should return false.
+  try {
+    const evmAddress = utils.hexZeroPad(utils.hexStripZeros(address), 20);
+    return utils.isAddress(utils.getAddress(evmAddress));
+  } catch (_e) {
+    return false;
+  }
+}

package/src/utils/DepositUtils.ts

@@ -5,6 +5,7 @@ import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, SlowFillReq
 import { getNetworkName } from "./NetworkUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
 import { validateFillForDeposit } from "./FlowUtils";
+import { isUnsafeDepositId } from "./SpokeUtils";
 import { getCurrentTime } from "./TimeUtils";
 import { isDefined } from "./TypeGuards";
 import { isDepositFormedCorrectly } from "./ValidatorUtils";
@@ -17,6 +18,7 @@ export enum InvalidFill {
   DepositIdInvalid = 0, // Deposit ID seems invalid for origin SpokePool
   DepositIdNotFound, // Deposit ID not found (bad RPC data?)
   FillMismatch, // Fill does not match deposit parameters for deposit ID.
+  DepositIdOutOfRange, // Fill is for a deterministic deposit.
 }
 
 export type DepositSearchResult =
@@ -40,6 +42,13 @@ export async function queryHistoricalDepositForFill(
   fill: Fill | SlowFillRequest,
   cache?: CachingMechanismInterface
 ): Promise<DepositSearchResult> {
+  if (isUnsafeDepositId(fill.depositId)) {
+    return {
+      found: false,
+      code: InvalidFill.DepositIdOutOfRange,
+      reason: `Cannot find historical deposit for fill with unsafe deposit ID ${fill.depositId}.`,
+    };
+  }
   if (fill.originChainId !== spokePoolClient.chainId) {
     throw new Error(`OriginChainId mismatch (${fill.originChainId} != ${spokePoolClient.chainId})`);
   }

package/src/utils/NetworkUtils.ts

@@ -123,6 +123,17 @@ export function chainIsL1(chainId: number): boolean {
   return [CHAIN_IDs.MAINNET, CHAIN_IDs.SEPOLIA].includes(chainId);
 }
 
+/**
+ * Determines whether a chain ID runs on an EVM-like execution layer.
+ * @param chainId Chain ID to evaluate.
+ * @returns True if chain corresponding to chainId has an EVM-like execution layer.
+ */
+export function chainIsEvm(chainId: number): boolean {
+  chainId;
+  // TODO: Fix when we support non-EVM chains.
+  return true;
+}
+
 /**
  * Determines whether a chain ID has the capacity for having its USDC bridged via CCTP.
  * @param chainId Chain ID to evaluate.

package/src/utils/SpokeUtils.ts

@@ -208,7 +208,7 @@ export async function getBlockRangeForDepositId(
 export async function getDepositIdAtBlock(contract: Contract, blockTag: number): Promise<BigNumber> {
   const _depositIdAtBlock = await contract.numberOfDeposits({ blockTag });
   const depositIdAtBlock = toBN(_depositIdAtBlock);
-  // Sanity check to ensure that the deposit ID is an integer and is greater than or equal to zero.
+  // Sanity check to ensure that the deposit ID is greater than or equal to zero.
   if (depositIdAtBlock.lt(bnZero)) {
     throw new Error("Invalid deposit count");
   }