@across-protocol/sdk 4.1.9 → 4.1.10-beta.0

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -1,4 +1,3 @@
-import assert from "assert";
 import _ from "lodash";
 import {
   ProposedRootBundle,
@@ -19,12 +18,13 @@ import {
   Deposit,
   DepositWithBlock,
 } from "../../interfaces";
-import { AcrossConfigStoreClient, SpokePoolClient } from "..";
+import { SpokePoolClient } from "..";
 import {
   BigNumber,
   bnZero,
   queryHistoricalDepositForFill,
   assign,
+  assert,
   fixedPointAdjustment,
   isDefined,
   toBN,
@@ -41,10 +41,10 @@ import {
   isZeroValueFillOrSlowFillRequest,
   chainIsEvm,
   isValidEvmAddress,
+  duplicateEvent,
 } from "../../utils";
 import winston from "winston";
 import {
-  _buildPoolRebalanceRoot,
   BundleData,
   BundleDataSS,
   getEndBlockBuffers,
@@ -52,7 +52,6 @@ import {
   getRefundsFromBundle,
   getWidestPossibleExpectedBlockRange,
   isChainDisabled,
-  PoolRebalanceRoot,
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
@@ -240,13 +239,7 @@ export class BundleDataClient {
     );
   }
 
-  private async loadPersistedDataFromArweave(
-    blockRangesForChains: number[][]
-  ): Promise<LoadDataReturnValue | undefined> {
-    if (!isDefined(this.clients?.arweaveClient)) {
-      return undefined;
-    }
-    const start = performance.now();
+  private async getBundleDataFromArweave(blockRangesForChains: number[][]) {
     const persistedData = await this.clients.arweaveClient.getByTopic(
       this.getArweaveBundleDataClientKey(blockRangesForChains),
       BundleDataSS
@@ -256,6 +249,20 @@ export class BundleDataClient {
     if (!isDefined(persistedData) || persistedData.length < 1) {
       return undefined;
     }
+    return persistedData;
+  }
+
+  private async loadPersistedDataFromArweave(
+    blockRangesForChains: number[][]
+  ): Promise<LoadDataReturnValue | undefined> {
+    if (!isDefined(this.clients?.arweaveClient)) {
+      return undefined;
+    }
+    const start = performance.now();
+    const persistedData = await this.getBundleDataFromArweave(blockRangesForChains);
+    if (!isDefined(persistedData)) {
+      return undefined;
+    }
 
     // A converter function to account for the fact that our SuperStruct schema does not support numeric
     // keys in records. Fundamentally, this is a limitation of superstruct itself.
@@ -392,7 +399,7 @@ export class BundleDataClient {
         const fill = await verifyFillRepayment(
           _fill,
           this.spokePoolClients[_fill.destinationChainId].spokePool.provider,
-          matchingDeposit,
+          matchingDeposit!,
           this.clients.hubPoolClient
         );
         if (!isDefined(fill)) {
@@ -403,7 +410,7 @@ export class BundleDataClient {
           this.clients.hubPoolClient,
           blockRanges,
           this.chainIdListForBundleEvaluationBlockNumbers,
-          matchingDeposit.fromLiteChain
+          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
@@ -431,52 +438,6 @@ export class BundleDataClient {
       }, toBN(0));
   }
 
-  private async getLatestProposedBundleData(): Promise<{ bundleData: LoadDataReturnValue; blockRanges: number[][] }> {
-    const hubPoolClient = this.clients.hubPoolClient;
-    // Determine which bundle we should fetch from arweave, either the pending bundle or the latest
-    // executed one. Both should have arweave data but if for some reason the arweave data is missing,
-    // this function will have to compute the bundle data from scratch which will be slow. We have to fallback
-    // to computing the bundle from scratch since this function needs to return the full bundle data so that
-    // it can be used to get the running balance proposed using its data.
-    const bundleBlockRanges = getImpliedBundleBlockRanges(
-      hubPoolClient,
-      this.clients.configStoreClient,
-      hubPoolClient.hasPendingProposal()
-        ? hubPoolClient.getLatestProposedRootBundle()
-        : hubPoolClient.getLatestFullyExecutedRootBundle(hubPoolClient.latestBlockSearched)! // ! because we know there is a bundle
-    );
-    return {
-      blockRanges: bundleBlockRanges,
-      bundleData: await this.loadData(
-        bundleBlockRanges,
-        this.spokePoolClients,
-        true // this bundle data should have been published to arweave
-      ),
-    };
-  }
-
-  async getLatestPoolRebalanceRoot(): Promise<{ root: PoolRebalanceRoot; blockRanges: number[][] }> {
-    const { bundleData, blockRanges } = await this.getLatestProposedBundleData();
-    const hubPoolClient = this.clients.hubPoolClient;
-    const root = _buildPoolRebalanceRoot(
-      hubPoolClient.latestBlockSearched,
-      blockRanges[0][1],
-      bundleData.bundleDepositsV3,
-      bundleData.bundleFillsV3,
-      bundleData.bundleSlowFillsV3,
-      bundleData.unexecutableSlowFills,
-      bundleData.expiredDepositsToRefundV3,
-      {
-        hubPoolClient,
-        configStoreClient: hubPoolClient.configStoreClient as AcrossConfigStoreClient,
-      }
-    );
-    return {
-      root,
-      blockRanges,
-    };
-  }
-
   // @dev This function should probably be moved to the InventoryClient since it bypasses loadData completely now.
   // Return refunds from the next valid bundle. This will contain any refunds that have been sent but are not included
   // in a valid bundle with all of its leaves executed. This contains refunds from:
@@ -850,23 +811,27 @@ export class BundleDataClient {
               slowFillRequest: undefined,
             };
           } else {
-            const { deposits } = v3RelayHashes[relayDataHash];
-            assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-            deposits.push(deposit);
+            v3RelayHashes[relayDataHash].deposits!.push(deposit);
           }
 
           // Account for duplicate deposits by concatenating the relayDataHash with the count of the number of times
           // we have seen it so far.
-          const { deposits } = v3RelayHashes[relayDataHash];
-          assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-          const newBundleDepositHash = `${relayDataHash}@${deposits.length - 1}`;
+          const newBundleDepositHash = `${relayDataHash}@${v3RelayHashes[relayDataHash].deposits!.length - 1}`;
           const decodedBundleDepositHash = decodeBundleDepositHash(newBundleDepositHash);
           assert(
             decodedBundleDepositHash.relayDataHash === relayDataHash &&
-              decodedBundleDepositHash.index === deposits.length - 1,
+              decodedBundleDepositHash.index === v3RelayHashes[relayDataHash].deposits!.length - 1,
             "Not using correct bundle deposit hash key"
           );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
+            if (bundleDepositsV3?.[originChainId]?.[deposit.inputToken]?.find((d) => duplicateEvent(deposit, d))) {
+              this.logger.debug({
+                at: "BundleDataClient#loadData",
+                message: "Duplicate deposit detected",
+                deposit,
+              });
+              throw new Error("Duplicate deposit detected");
+            }
             bundleDepositHashes.push(newBundleDepositHash);
             updateBundleDepositsV3(bundleDepositsV3, deposit);
           } else if (deposit.blockNumber < originChainBlockRange[0]) {
@@ -924,62 +889,69 @@ export class BundleDataClient {
             fillCounter++;
             const relayDataHash = getRelayEventKey(fill);
             if (v3RelayHashes[relayDataHash]) {
-              if (!v3RelayHashes[relayDataHash].fill) {
-                const { deposits } = v3RelayHashes[relayDataHash];
-                assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-                v3RelayHashes[relayDataHash].fill = fill;
-                if (fill.blockNumber >= destinationChainBlockRange[0]) {
-                  const fillToRefund = await verifyFillRepayment(
-                    fill,
-                    destinationClient.spokePool.provider,
-                    deposits[0],
-                    this.clients.hubPoolClient
-                  );
-                  if (!isDefined(fillToRefund)) {
-                    bundleUnrepayableFillsV3.push(fill);
-                    // We don't return here yet because we still need to mark unexecutable slow fill leaves
-                    // or duplicate deposits. However, we won't issue a fast fill refund.
-                  } else {
-                    v3RelayHashes[relayDataHash].fill = fillToRefund;
-                    validatedBundleV3Fills.push({
-                      ...fillToRefund,
-                      quoteTimestamp: deposits[0].quoteTimestamp,
-                    });
-
-                    // Now that we know this deposit has been filled on-chain, identify any duplicate deposits
-                    // sent for this fill and refund them to the filler, because this value would not be paid out
-                    // otherwise. These deposits can no longer expire and get refunded as an expired deposit,
-                    // and they won't trigger a pre-fill refund because the fill is in this bundle.
-                    // Pre-fill refunds only happen when deposits are sent in this bundle and the
-                    // fill is from a prior bundle. Paying out the filler keeps the behavior consistent for how
-                    // we deal with duplicate deposits regardless if the deposit is matched with a pre-fill or
-                    // a current bundle fill.
-                    const duplicateDeposits = deposits.slice(1);
-                    duplicateDeposits.forEach((duplicateDeposit) => {
-                      if (isSlowFill(fill)) {
-                        updateExpiredDepositsV3(expiredDepositsToRefundV3, duplicateDeposit);
-                      } else {
-                        validatedBundleV3Fills.push({
-                          ...fillToRefund,
-                          quoteTimestamp: duplicateDeposit.quoteTimestamp,
-                        });
-                      }
-                    });
-                  }
-
-                  // If fill replaced a slow fill request, then mark it as one that might have created an
-                  // unexecutable slow fill. We can't know for sure until we check the slow fill request
-                  // events.
-                  if (
-                    fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
-                    _canCreateSlowFillLeaf(deposits[0])
-                  ) {
-                    fastFillsReplacingSlowFills.push(relayDataHash);
-                  }
-                }
-              } else {
+              if (v3RelayHashes[relayDataHash].fill) {
+                this.logger.debug({
+                  at: "BundleDataClient#loadData",
+                  message: "Duplicate fill detected",
+                  fill,
+                });
                 throw new Error("Duplicate fill detected");
               }
+              assert(
+                isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits!.length > 0,
+                "Deposit should exist in relay hash dictionary."
+              );
+              v3RelayHashes[relayDataHash].fill = fill;
+              if (fill.blockNumber >= destinationChainBlockRange[0]) {
+                const fillToRefund = await verifyFillRepayment(
+                  fill,
+                  destinationClient.spokePool.provider,
+                  v3RelayHashes[relayDataHash].deposits![0],
+                  this.clients.hubPoolClient
+                );
+                if (!isDefined(fillToRefund)) {
+                  bundleUnrepayableFillsV3.push(fill);
+                  // We don't return here yet because we still need to mark unexecutable slow fill leaves
+                  // or duplicate deposits. However, we won't issue a fast fill refund.
+                } else {
+                  v3RelayHashes[relayDataHash].fill = fillToRefund;
+                  validatedBundleV3Fills.push({
+                    ...fillToRefund,
+                    quoteTimestamp: v3RelayHashes[relayDataHash].deposits![0].quoteTimestamp,
+                  });
+
+                  // Now that we know this deposit has been filled on-chain, identify any duplicate deposits
+                  // sent for this fill and refund them to the filler, because this value would not be paid out
+                  // otherwise. These deposits can no longer expire and get refunded as an expired deposit,
+                  // and they won't trigger a pre-fill refund because the fill is in this bundle.
+                  // Pre-fill refunds only happen when deposits are sent in this bundle and the
+                  // fill is from a prior bundle. Paying out the filler keeps the behavior consistent for how
+                  // we deal with duplicate deposits regardless if the deposit is matched with a pre-fill or
+                  // a current bundle fill.
+                  const duplicateDeposits = v3RelayHashes[relayDataHash].deposits!.slice(1);
+                  duplicateDeposits.forEach((duplicateDeposit) => {
+                    if (isSlowFill(fill)) {
+                      updateExpiredDepositsV3(expiredDepositsToRefundV3, duplicateDeposit);
+                    } else {
+                      validatedBundleV3Fills.push({
+                        ...fillToRefund,
+                        quoteTimestamp: duplicateDeposit.quoteTimestamp,
+                      });
+                    }
+                  });
+                }
+
+                // If fill replaced a slow fill request, then mark it as one that might have created an
+                // unexecutable slow fill. We can't know for sure until we check the slow fill request
+                // events.
+                if (
+                  fill.relayExecutionInfo.fillType === FillType.ReplacedSlowFill &&
+                  _canCreateSlowFillLeaf(v3RelayHashes[relayDataHash].deposits![0])
+                ) {
+                  fastFillsReplacingSlowFills.push(relayDataHash);
+                }
+              }
+
               return;
             }
 
@@ -1079,28 +1051,34 @@ export class BundleDataClient {
             const relayDataHash = getRelayEventKey(slowFillRequest);
 
             if (v3RelayHashes[relayDataHash]) {
-              if (!v3RelayHashes[relayDataHash].slowFillRequest) {
-                v3RelayHashes[relayDataHash].slowFillRequest = slowFillRequest;
-                const { deposits, fill } = v3RelayHashes[relayDataHash];
-                if (fill) {
-                  // Exiting here assumes that slow fill requests must precede fills, so if there was a fill
-                  // following this slow fill request, then we would have already seen it. We don't need to check
-                  // for a fill older than this slow fill request.
-                  return;
-                }
-                assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-                const matchedDeposit = deposits[0];
-
-                if (
-                  slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
-                  _canCreateSlowFillLeaf(matchedDeposit) &&
-                  !_depositIsExpired(matchedDeposit)
-                ) {
-                  validatedBundleSlowFills.push(matchedDeposit);
-                }
-              } else {
+              if (v3RelayHashes[relayDataHash].slowFillRequest) {
+                this.logger.debug({
+                  at: "BundleDataClient#loadData",
+                  message: "Duplicate slow fill request detected",
+                  slowFillRequest,
+                });
                 throw new Error("Duplicate slow fill request detected.");
               }
+              v3RelayHashes[relayDataHash].slowFillRequest = slowFillRequest;
+              if (v3RelayHashes[relayDataHash].fill) {
+                // Exiting here assumes that slow fill requests must precede fills, so if there was a fill
+                // following this slow fill request, then we would have already seen it. We don't need to check
+                // for a fill older than this slow fill request.
+                return;
+              }
+              assert(
+                isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits!.length > 0,
+                "Deposit should exist in relay hash dictionary."
+              );
+              const matchedDeposit = v3RelayHashes[relayDataHash].deposits![0];
+
+              if (
+                slowFillRequest.blockNumber >= destinationChainBlockRange[0] &&
+                _canCreateSlowFillLeaf(matchedDeposit) &&
+                !_depositIsExpired(matchedDeposit)
+              ) {
+                validatedBundleSlowFills.push(matchedDeposit);
+              }
               return;
             }
 
@@ -1195,7 +1173,7 @@ export class BundleDataClient {
               const fillToRefund = await verifyFillRepayment(
                 fill,
                 destinationClient.spokePool.provider,
-                deposits[0],
+                v3RelayHashes[relayDataHash].deposits![0],
                 this.clients.hubPoolClient
               );
               if (!isDefined(fillToRefund)) {
@@ -1243,18 +1221,18 @@ export class BundleDataClient {
             // then we wouldn't be in this branch of the code.
             const prefill = await this.findMatchingFillEvent(deposit, destinationClient);
             assert(isDefined(prefill), `findFillEvent# Cannot find prefill: ${relayDataHash}`);
-            assert(getRelayEventKey(prefill) === relayDataHash, "Relay hashes should match.");
+            assert(getRelayEventKey(prefill!) === relayDataHash, "Relay hashes should match.");
             const verifiedFill = await verifyFillRepayment(
-              prefill,
+              prefill!,
               destinationClient.spokePool.provider,
               deposit,
               this.clients.hubPoolClient
             );
             if (!isDefined(verifiedFill)) {
-              bundleUnrepayableFillsV3.push(prefill);
+              bundleUnrepayableFillsV3.push(prefill!);
             } else if (!isSlowFill(verifiedFill)) {
               validatedBundleV3Fills.push({
-                ...verifiedFill,
+                ...verifiedFill!,
                 quoteTimestamp: deposit.quoteTimestamp,
               });
             } else {
@@ -1377,16 +1355,14 @@ export class BundleDataClient {
       validatedBundleV3Fills.length > 0
         ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(
             validatedBundleV3Fills.map((fill) => {
-              const { deposits } = v3RelayHashes[getRelayEventKey(fill)];
-              assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-              const matchedDeposit = deposits[0];
+              const matchedDeposit = v3RelayHashes[getRelayEventKey(fill)].deposits![0];
               assert(isDefined(matchedDeposit), "Deposit should exist in relay hash dictionary.");
               const { chainToSendRefundTo: paymentChainId } = getRefundInformationFromFill(
                 fill,
                 this.clients.hubPoolClient,
                 blockRangesForChains,
                 chainIds,
-                matchedDeposit.fromLiteChain
+                matchedDeposit!.fromLiteChain
               );
               return {
                 ...fill,
@@ -1423,16 +1399,14 @@ export class BundleDataClient {
     });
     v3FillLpFees.forEach(({ realizedLpFeePct }, idx) => {
       const fill = validatedBundleV3Fills[idx];
-      const { deposits } = v3RelayHashes[getRelayEventKey(fill)];
-      assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
-      const associatedDeposit = deposits[0];
+      const associatedDeposit = v3RelayHashes[getRelayEventKey(fill)].deposits![0];
       assert(isDefined(associatedDeposit), "Deposit should exist in relay hash dictionary.");
       const { chainToSendRefundTo, repaymentToken } = getRefundInformationFromFill(
         fill,
         this.clients.hubPoolClient,
         blockRangesForChains,
         chainIds,
-        associatedDeposit.fromLiteChain
+        associatedDeposit!.fromLiteChain
       );
       updateBundleFillsV3(bundleFillsV3, fill, realizedLpFeePct, chainToSendRefundTo, repaymentToken, fill.relayer);
     });

package/src/clients/HubPoolClient.ts

@@ -776,31 +776,35 @@ export class HubPoolClient extends BaseAbstractClient {
     return endBlock > 0 ? endBlock + 1 : 0;
   }
 
-  getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: string): TokenRunningBalance {
+  getLatestExecutedRootBundleContainingL1Token(block: number, chain: number, l1Token: string): ExecutedRootBundle {
     // Search ExecutedRootBundles in descending block order to find the most recent event before the target block.
-    const executedRootBundle = sortEventsDescending(this.executedRootBundles).find(
-      (executedLeaf: ExecutedRootBundle) => {
-        return (
-          executedLeaf.blockNumber <= block &&
-          executedLeaf.chainId === chain &&
-          executedLeaf.l1Tokens.map((l1Token) => l1Token.toLowerCase()).includes(l1Token.toLowerCase())
-        );
-      }
-    ) as ExecutedRootBundle;
+    return sortEventsDescending(this.executedRootBundles).find((executedLeaf: ExecutedRootBundle) => {
+      return (
+        executedLeaf.blockNumber <= block &&
+        executedLeaf.chainId === chain &&
+        executedLeaf.l1Tokens.map((l1Token) => l1Token.toLowerCase()).includes(l1Token.toLowerCase())
+      );
+    }) as ExecutedRootBundle;
+  }
+
+  getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: string): TokenRunningBalance {
+    const executedRootBundle = this.getLatestExecutedRootBundleContainingL1Token(block, chain, l1Token);
 
     return this.getRunningBalanceForToken(l1Token, executedRootBundle);
   }
 
   public getRunningBalanceForToken(l1Token: string, executedRootBundle: ExecutedRootBundle): TokenRunningBalance {
     let runningBalance = toBN(0);
+    let incentiveBalance = toBN(0);
     if (executedRootBundle) {
       const indexOfL1Token = executedRootBundle.l1Tokens
         .map((l1Token) => l1Token.toLowerCase())
         .indexOf(l1Token.toLowerCase());
       runningBalance = executedRootBundle.runningBalances[indexOfL1Token];
+      incentiveBalance = executedRootBundle.incentiveBalances[indexOfL1Token];
     }
 
-    return { runningBalance };
+    return { runningBalance, incentiveBalance };
   }
 
   async _update(eventNames: HubPoolEvent[]): Promise<HubPoolUpdate> {
@@ -1005,6 +1009,8 @@ export class HubPoolClient extends BaseAbstractClient {
           );
         }
         executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
+        executedRootBundle.incentiveBalances =
+          runningBalances.length > nTokens ? runningBalances.slice(nTokens) : runningBalances.map(() => toBN(0));
         this.executedRootBundles.push(executedRootBundle);
       }
     }

package/src/clients/SpokePoolClient.ts

@@ -1,11 +1,9 @@
-import assert from "assert";
 import { Contract, EventFilter } from "ethers";
 import winston from "winston";
 import {
   AnyObject,
   BigNumber,
   bnZero,
-  bnUint32Max,
   DefaultLogLevels,
   EventSearchConfig,
   MAX_BIG_INT,
@@ -23,6 +21,7 @@ import {
   toAddress,
 } from "../utils";
 import {
+  duplicateEvent,
   paginatedEventQuery,
   sortEventsAscendingInPlace,
   spreadEvent,
@@ -55,6 +54,7 @@ import { getRepaymentChainId, forceDestinationRepayment } from "./BundleDataClie
 type SpokePoolUpdateSuccess = {
   success: true;
   currentTime: number;
+  oldestTime: number;
   firstDepositId: BigNumber;
   latestDepositId: BigNumber;
   events: Log[][];
@@ -72,6 +72,7 @@ export type SpokePoolUpdate = SpokePoolUpdateSuccess | SpokePoolUpdateFailure;
  */
 export class SpokePoolClient extends BaseAbstractClient {
   protected currentTime = 0;
+  protected oldestTime = 0;
   protected depositHashes: { [depositHash: string]: DepositWithBlock } = {};
   protected duplicateDepositHashes: { [depositHash: string]: DepositWithBlock[] } = {};
   protected depositHashesToFills: { [depositHash: string]: FillWithBlock[] } = {};
@@ -542,11 +543,12 @@ export class SpokePoolClient extends BaseAbstractClient {
 
     const timerStart = Date.now();
     const multicallFunctions = ["getCurrentTime", "numberOfDeposits"];
-    const [multicallOutput, ...events] = await Promise.all([
+    const [multicallOutput, oldestTime, ...events] = await Promise.all([
       spokePool.callStatic.multicall(
         multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
         { blockTag: searchConfig.toBlock }
       ),
+      this.spokePool.getCurrentTime({ blockTag: Math.max(searchConfig.fromBlock, this.deploymentBlock) }),
       ...eventSearchConfigs.map((config) => paginatedEventQuery(this.spokePool, config.filter, config.searchConfig)),
     ]);
     this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
@@ -569,6 +571,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     return {
       success: true,
       currentTime: currentTime.toNumber(), // uint32
+      oldestTime: oldestTime.toNumber(),
       firstDepositId,
       latestDepositId: _latestDepositId.gt(bnZero) ? _latestDepositId : bnZero,
       searchEndBlock: searchConfig.toBlock,
@@ -585,6 +588,7 @@ export class SpokePoolClient extends BaseAbstractClient {
    * @see _update
    */
   public async update(eventsToQuery = this.queryableEventNames): Promise<void> {
+    const duplicateEvents: Log[] = [];
     if (this.hubPoolClient !== null && !this.hubPoolClient.isUpdated) {
       throw new Error("HubPoolClient not updated");
     }
@@ -593,7 +597,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     if (!update.success) {
       return;
     }
-    const { events: queryResults, currentTime, searchEndBlock } = update;
+    const { events: queryResults, currentTime, oldestTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
       // Temporarily query old spoke pool events as well to ease migration:
@@ -654,6 +658,16 @@ export class SpokePoolClient extends BaseAbstractClient {
         }
 
         if (this.depositHashes[getRelayEventKey(deposit)] !== undefined) {
+          // Sanity check that this event is not a duplicate, even though the relay data hash is a duplicate.
+          const allDeposits = this._getDuplicateDeposits(deposit).concat(this.depositHashes[getRelayEventKey(deposit)]);
+          if (
+            allDeposits.some((e) => {
+              return duplicateEvent(deposit, e);
+            })
+          ) {
+            duplicateEvents.push(event);
+            continue;
+          }
           assign(this.duplicateDepositHashes, [getRelayEventKey(deposit)], [deposit]);
           continue;
         }
@@ -716,6 +730,13 @@ export class SpokePoolClient extends BaseAbstractClient {
         }
 
         const depositHash = getRelayEventKey({ ...slowFillRequest, destinationChainId: this.chainId });
+
+        // Sanity check that this event is not a duplicate.
+        if (this.slowFillRequests[depositHash] !== undefined) {
+          duplicateEvents.push(event);
+          continue;
+        }
+
         this.slowFillRequests[depositHash] ??= slowFillRequest;
       }
     };
@@ -749,6 +770,13 @@ export class SpokePoolClient extends BaseAbstractClient {
           fill.relayExecutionInfo.updatedMessageHash = getMessageHash(event.args.relayExecutionInfo.updatedMessage);
         }
 
+        // Sanity check that this event is not a duplicate.
+        const duplicateFill = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
+        if (duplicateFill) {
+          duplicateEvents.push(event);
+          continue;
+        }
+
         assign(this.fills, [fill.originChainId], [fill]);
         assign(this.depositHashesToFills, [this.getDepositHash(fill)], [fill]);
       }
@@ -793,8 +821,16 @@ export class SpokePoolClient extends BaseAbstractClient {
       }
     }
 
+    if (duplicateEvents.length > 0) {
+      this.log("debug", "Duplicate events listed", {
+        duplicateEvents,
+      });
+      this.log("error", "Duplicate events detected, check debug logs");
+    }
+
     // Next iteration should start off from where this one ended.
     this.currentTime = currentTime;
+    if (this.oldestTime === 0) this.oldestTime = oldestTime; // Set oldest time only after the first update.
     this.firstDepositIdForSpokePool = update.firstDepositId;
     this.latestBlockSearched = searchEndBlock;
     this.lastDepositIdForSpokePool = update.latestDepositId;
@@ -884,13 +920,11 @@ export class SpokePoolClient extends BaseAbstractClient {
   }
 
   /**
-   * Retrieves the time from the SpokePool contract at a particular block.
-   * @returns The time at the specified block tag.
+   * Retrieves the oldest time searched on the SpokePool contract.
+   * @returns The oldest time searched, which will be 0 if there has been no update() yet.
    */
-  public async getTimeAt(blockNumber: number): Promise<number> {
-    const currentTime = await this.spokePool.getCurrentTime({ blockTag: blockNumber });
-    assert(BigNumber.isBigNumber(currentTime) && currentTime.lt(bnUint32Max));
-    return currentTime.toNumber();
+  public getOldestTime(): number {
+    return this.oldestTime;
   }
 
   async findDeposit(depositId: BigNumber, destinationChainId: number): Promise<DepositWithBlock> {

package/src/interfaces/HubPool.ts

@@ -54,6 +54,7 @@ export interface ExecutedRootBundle extends SortableEvent {
   bundleLpFees: BigNumber[];
   netSendAmounts: BigNumber[];
   runningBalances: BigNumber[];
+  incentiveBalances: BigNumber[];
   leafId: number;
   l1Tokens: string[];
   proof: string[];
@@ -61,15 +62,17 @@ export interface ExecutedRootBundle extends SortableEvent {
 
 export type ExecutedRootBundleStringified = Omit<
   ExecutedRootBundle,
-  "bundleLpFees" | "netSendAmounts" | "runningBalances"
+  "bundleLpFees" | "netSendAmounts" | "runningBalances" | "incentiveBalances"
 > & {
   bundleLpFees: string[];
   netSendAmounts: string[];
   runningBalances: string[];
+  incentiveBalances: string[];
 };
 
 export type TokenRunningBalance = {
   runningBalance: BigNumber;
+  incentiveBalance: BigNumber;
 };
 
 export interface RelayerRefundLeafWithGroup extends RelayerRefundLeaf {

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -13,10 +13,10 @@ import {
   BigNumber,
   toBNWei,
   bnZero,
+  assert,
   chainIsOPStack,
   fixedPointAdjustment,
 } from "../../utils";
-import assert from "assert";
 import { Logger, QueryInterface } from "../relayFeeCalculator";
 import { Transport } from "viem";
 import { getGasPriceEstimate } from "../../gasPriceOracle/oracle";