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

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -1,3 +1,4 @@
+import assert from "assert";
 import _ from "lodash";
 import {
   ProposedRootBundle,
@@ -24,7 +25,6 @@ import {
   bnZero,
   queryHistoricalDepositForFill,
   assign,
-  assert,
   fixedPointAdjustment,
   isDefined,
   toBN,
@@ -239,19 +239,6 @@ export class BundleDataClient {
     );
   }
 
-  private async getBundleDataFromArweave(blockRangesForChains: number[][]) {
-    const persistedData = await this.clients.arweaveClient.getByTopic(
-      this.getArweaveBundleDataClientKey(blockRangesForChains),
-      BundleDataSS
-    );
-    // If there is no data or the data is empty, return undefined because we couldn't
-    // pull info from the Arweave persistence layer.
-    if (!isDefined(persistedData) || persistedData.length < 1) {
-      return undefined;
-    }
-    return persistedData;
-  }
-
   private async loadPersistedDataFromArweave(
     blockRangesForChains: number[][]
   ): Promise<LoadDataReturnValue | undefined> {
@@ -259,8 +246,13 @@ export class BundleDataClient {
       return undefined;
     }
     const start = performance.now();
-    const persistedData = await this.getBundleDataFromArweave(blockRangesForChains);
-    if (!isDefined(persistedData)) {
+    const persistedData = await this.clients.arweaveClient.getByTopic(
+      this.getArweaveBundleDataClientKey(blockRangesForChains),
+      BundleDataSS
+    );
+    // If there is no data or the data is empty, return undefined because we couldn't
+    // pull info from the Arweave persistence layer.
+    if (!isDefined(persistedData) || persistedData.length < 1) {
       return undefined;
     }
 
@@ -399,7 +391,7 @@ export class BundleDataClient {
         const fill = await verifyFillRepayment(
           _fill,
           this.spokePoolClients[_fill.destinationChainId].spokePool.provider,
-          matchingDeposit!,
+          matchingDeposit,
           this.clients.hubPoolClient
         );
         if (!isDefined(fill)) {
@@ -410,7 +402,7 @@ export class BundleDataClient {
           this.clients.hubPoolClient,
           blockRanges,
           this.chainIdListForBundleEvaluationBlockNumbers,
-          matchingDeposit!.fromLiteChain // Use ! because we've already asserted that matchingDeposit is defined.
+          matchingDeposit.fromLiteChain
         );
         // 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
@@ -811,16 +803,20 @@ export class BundleDataClient {
               slowFillRequest: undefined,
             };
           } else {
-            v3RelayHashes[relayDataHash].deposits!.push(deposit);
+            const { deposits } = v3RelayHashes[relayDataHash];
+            assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+            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 newBundleDepositHash = `${relayDataHash}@${v3RelayHashes[relayDataHash].deposits!.length - 1}`;
+          const { deposits } = v3RelayHashes[relayDataHash];
+          assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+          const newBundleDepositHash = `${relayDataHash}@${deposits.length - 1}`;
           const decodedBundleDepositHash = decodeBundleDepositHash(newBundleDepositHash);
           assert(
             decodedBundleDepositHash.relayDataHash === relayDataHash &&
-              decodedBundleDepositHash.index === v3RelayHashes[relayDataHash].deposits!.length - 1,
+              decodedBundleDepositHash.index === deposits.length - 1,
             "Not using correct bundle deposit hash key"
           );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
@@ -889,7 +885,60 @@ export class BundleDataClient {
             fillCounter++;
             const relayDataHash = getRelayEventKey(fill);
             if (v3RelayHashes[relayDataHash]) {
-              if (v3RelayHashes[relayDataHash].fill) {
+              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 {
                 this.logger.debug({
                   at: "BundleDataClient#loadData",
                   message: "Duplicate fill detected",
@@ -897,61 +946,6 @@ export class BundleDataClient {
                 });
                 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;
             }
 
@@ -1051,7 +1045,26 @@ export class BundleDataClient {
             const relayDataHash = getRelayEventKey(slowFillRequest);
 
             if (v3RelayHashes[relayDataHash]) {
-              if (v3RelayHashes[relayDataHash].slowFillRequest) {
+              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 {
                 this.logger.debug({
                   at: "BundleDataClient#loadData",
                   message: "Duplicate slow fill request detected",
@@ -1059,26 +1072,6 @@ export class BundleDataClient {
                 });
                 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;
             }
 
@@ -1173,7 +1166,7 @@ export class BundleDataClient {
               const fillToRefund = await verifyFillRepayment(
                 fill,
                 destinationClient.spokePool.provider,
-                v3RelayHashes[relayDataHash].deposits![0],
+                deposits[0],
                 this.clients.hubPoolClient
               );
               if (!isDefined(fillToRefund)) {
@@ -1221,18 +1214,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 {
@@ -1355,14 +1348,16 @@ export class BundleDataClient {
       validatedBundleV3Fills.length > 0
         ? this.clients.hubPoolClient.batchComputeRealizedLpFeePct(
             validatedBundleV3Fills.map((fill) => {
-              const matchedDeposit = v3RelayHashes[getRelayEventKey(fill)].deposits![0];
+              const { deposits } = v3RelayHashes[getRelayEventKey(fill)];
+              assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+              const matchedDeposit = 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,
@@ -1399,14 +1394,16 @@ export class BundleDataClient {
     });
     v3FillLpFees.forEach(({ realizedLpFeePct }, idx) => {
       const fill = validatedBundleV3Fills[idx];
-      const associatedDeposit = v3RelayHashes[getRelayEventKey(fill)].deposits![0];
+      const { deposits } = v3RelayHashes[getRelayEventKey(fill)];
+      assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
+      const associatedDeposit = 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,15 +776,19 @@ export class HubPoolClient extends BaseAbstractClient {
     return endBlock > 0 ? endBlock + 1 : 0;
   }
 
-  getLatestExecutedRootBundleContainingL1Token(block: number, chain: number, l1Token: string): ExecutedRootBundle {
+  getLatestExecutedRootBundleContainingL1Token(
+    block: number,
+    chain: number,
+    l1Token: string
+  ): ExecutedRootBundle | undefined {
     // Search ExecutedRootBundles in descending block order to find the most recent event before the target block.
     return sortEventsDescending(this.executedRootBundles).find((executedLeaf: ExecutedRootBundle) => {
       return (
         executedLeaf.blockNumber <= block &&
         executedLeaf.chainId === chain &&
-        executedLeaf.l1Tokens.map((l1Token) => l1Token.toLowerCase()).includes(l1Token.toLowerCase())
+        executedLeaf.l1Tokens.some((token) => token.toLowerCase() === l1Token.toLowerCase())
       );
-    }) as ExecutedRootBundle;
+    });
   }
 
   getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: string): TokenRunningBalance {
@@ -793,18 +797,19 @@ export class HubPoolClient extends BaseAbstractClient {
     return this.getRunningBalanceForToken(l1Token, executedRootBundle);
   }
 
-  public getRunningBalanceForToken(l1Token: string, executedRootBundle: ExecutedRootBundle): TokenRunningBalance {
+  public getRunningBalanceForToken(
+    l1Token: string,
+    executedRootBundle: ExecutedRootBundle | undefined
+  ): 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, incentiveBalance };
+    return { runningBalance };
   }
 
   async _update(eventNames: HubPoolEvent[]): Promise<HubPoolUpdate> {
@@ -1009,8 +1014,6 @@ 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,9 +1,11 @@
+import assert from "assert";
 import { Contract, EventFilter } from "ethers";
 import winston from "winston";
 import {
   AnyObject,
   BigNumber,
   bnZero,
+  bnUint32Max,
   DefaultLogLevels,
   EventSearchConfig,
   MAX_BIG_INT,
@@ -54,7 +56,6 @@ import { getRepaymentChainId, forceDestinationRepayment } from "./BundleDataClie
 type SpokePoolUpdateSuccess = {
   success: true;
   currentTime: number;
-  oldestTime: number;
   firstDepositId: BigNumber;
   latestDepositId: BigNumber;
   events: Log[][];
@@ -72,7 +73,6 @@ 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[] } = {};
@@ -543,12 +543,11 @@ export class SpokePoolClient extends BaseAbstractClient {
 
     const timerStart = Date.now();
     const multicallFunctions = ["getCurrentTime", "numberOfDeposits"];
-    const [multicallOutput, oldestTime, ...events] = await Promise.all([
+    const [multicallOutput, ...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`);
@@ -571,7 +570,6 @@ 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,
@@ -597,7 +595,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     if (!update.success) {
       return;
     }
-    const { events: queryResults, currentTime, oldestTime, searchEndBlock } = update;
+    const { events: queryResults, currentTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
       // Temporarily query old spoke pool events as well to ease migration:
@@ -660,11 +658,7 @@ 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);
-            })
-          ) {
+          if (allDeposits.some((e) => duplicateEvent(deposit, e))) {
             duplicateEvents.push(event);
             continue;
           }
@@ -830,7 +824,6 @@ export class SpokePoolClient extends BaseAbstractClient {
 
     // 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;
@@ -920,11 +913,13 @@ export class SpokePoolClient extends BaseAbstractClient {
   }
 
   /**
-   * 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.
+   * Retrieves the time from the SpokePool contract at a particular block.
+   * @returns The time at the specified block tag.
    */
-  public getOldestTime(): number {
-    return this.oldestTime;
+  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();
   }
 
   async findDeposit(depositId: BigNumber, destinationChainId: number): Promise<DepositWithBlock> {

package/src/interfaces/HubPool.ts

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

package/src/utils/CachingUtils.ts

@@ -1,6 +1,6 @@
 import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL } from "../constants";
 import { CachingMechanismInterface, Deposit, Fill, SlowFillRequest } from "../interfaces";
-import { assert } from "./LogUtils";
+import assert from "assert";
 import { composeRevivers, objectWithBigNumberReviver } from "./ReviverUtils";
 import { getRelayEventKey } from "./SpokeUtils";
 import { getCurrentTime } from "./TimeUtils";

package/src/utils/LogUtils.ts

@@ -24,15 +24,3 @@ export function formattedLog(
     });
   }
 }
-
-/**
- * Asserts the truth of a condition. If the condition is false, an error is thrown with the provided message.
- * @param condition The condition to assert.
- * @param message The message to throw if the condition is false.
- * @throws Error if the condition is false.
- */
-export function assert(condition: boolean, message: string): void {
-  if (!condition) {
-    throw new Error(message);
-  }
-}

package/src/utils/Multicall.ts

@@ -34,6 +34,7 @@ const DETERMINISTIC_MULTICALL_CHAINS = [
   CHAIN_IDs.POLYGON_AMOY,
   CHAIN_IDs.SCROLL_SEPOLIA,
   CHAIN_IDs.SEPOLIA,
+  CHAIN_IDs.ARBITRUM_SEPOLIA,
 ];
 
 export function getMulticallAddress(chainId: number): string | undefined {