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

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -18,7 +18,7 @@ import {
   Deposit,
   DepositWithBlock,
 } from "../../interfaces";
-import { AcrossConfigStoreClient, SpokePoolClient } from "..";
+import { SpokePoolClient } from "..";
 import {
   BigNumber,
   bnZero,
@@ -41,10 +41,10 @@ import {
   isZeroValueFillOrSlowFillRequest,
   chainIsEvm,
   isValidEvmAddress,
+  duplicateEvent,
 } from "../../utils";
 import winston from "winston";
 import {
-  _buildPoolRebalanceRoot,
   BundleData,
   BundleDataSS,
   getEndBlockBuffers,
@@ -52,13 +52,12 @@ import {
   getRefundsFromBundle,
   getWidestPossibleExpectedBlockRange,
   isChainDisabled,
-  PoolRebalanceRoot,
   prettyPrintV3SpokePoolEvents,
   V3DepositWithBlock,
   V3FillWithBlock,
   verifyFillRepayment,
 } from "./utils";
-import { PRE_FILL_MIN_CONFIG_STORE_VERSION, UNDEFINED_MESSAGE_HASH } from "../../constants";
+import { UNDEFINED_MESSAGE_HASH } from "../../constants";
 
 // max(uint256) - 1
 export const INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -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.
@@ -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:
@@ -827,22 +788,6 @@ export class BundleDataClient {
       return { relayDataHash, index: Number(i) };
     };
 
-    // We use the following toggle to aid with the migration to pre-fills. The first bundle proposed using this
-    // pre-fill logic can double refund pre-fills that have already been filled in the last bundle, because the
-    // last bundle did not recognize a fill as a pre-fill. Therefore the developer should ensure that the version
-    // is bumped to the PRE_FILL_MIN_CONFIG_STORE_VERSION version before the first pre-fill bundle is proposed.
-    // To test the following bundle after this, the developer can set the FORCE_REFUND_PREFILLS environment variable
-    // to "true" simulate the bundle with pre-fill refunds.
-    // @todo Remove this logic once we have advanced sufficiently past the pre-fill migration.
-    const startBlockForMainnet = getBlockRangeForChain(
-      blockRangesForChains,
-      this.clients.hubPoolClient.chainId,
-      this.chainIdListForBundleEvaluationBlockNumbers
-    )[0];
-    const versionAtProposalBlock = this.clients.configStoreClient.getConfigStoreVersionForBlock(startBlockForMainnet);
-    const canRefundPrefills =
-      versionAtProposalBlock >= PRE_FILL_MIN_CONFIG_STORE_VERSION || process.env.FORCE_REFUND_PREFILLS === "true";
-
     // Prerequisite step: Load all deposit events from the current or older bundles into the v3RelayHashes dictionary
     // for convenient matching with fills.
     for (const originChainId of allChainIds) {
@@ -879,6 +824,14 @@ export class BundleDataClient {
             "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]) {
@@ -936,64 +889,69 @@ export class BundleDataClient {
             fillCounter++;
             const relayDataHash = getRelayEventKey(fill);
             if (v3RelayHashes[relayDataHash]) {
-              if (!v3RelayHashes[relayDataHash].fill) {
-                assert(
-                  isDefined(v3RelayHashes[relayDataHash].deposits) && v3RelayHashes[relayDataHash].deposits!.length > 0,
-                  "Deposit should exist in relay hash dictionary."
+              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
                 );
-                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);
-                  }
+                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);
                 }
-              } else {
-                throw new Error("Duplicate fill detected");
               }
+
               return;
             }
 
@@ -1093,30 +1051,34 @@ export class BundleDataClient {
             const relayDataHash = getRelayEventKey(slowFillRequest);
 
             if (v3RelayHashes[relayDataHash]) {
-              if (!v3RelayHashes[relayDataHash].slowFillRequest) {
-                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);
-                }
-              } 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;
             }
 
@@ -1207,7 +1169,7 @@ export class BundleDataClient {
           // If fill is in the current bundle then we can assume there is already a refund for it, so only
           // include this pre fill if the fill is in an older bundle.
           if (fill) {
-            if (canRefundPrefills && fill.blockNumber < destinationChainBlockRange[0]) {
+            if (fill.blockNumber < destinationChainBlockRange[0]) {
               const fillToRefund = await verifyFillRepayment(
                 fill,
                 destinationClient.spokePool.provider,
@@ -1238,7 +1200,6 @@ export class BundleDataClient {
             if (_depositIsExpired(deposit)) {
               updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
             } else if (
-              canRefundPrefills &&
               slowFillRequest.blockNumber < destinationChainBlockRange[0] &&
               _canCreateSlowFillLeaf(deposit) &&
               validatedBundleSlowFills.every((d) => getRelayEventKey(d) !== relayDataHash)
@@ -1261,23 +1222,21 @@ export class BundleDataClient {
             const prefill = await this.findMatchingFillEvent(deposit, destinationClient);
             assert(isDefined(prefill), `findFillEvent# Cannot find prefill: ${relayDataHash}`);
             assert(getRelayEventKey(prefill!) === relayDataHash, "Relay hashes should match.");
-            if (canRefundPrefills) {
-              const verifiedFill = await verifyFillRepayment(
-                prefill!,
-                destinationClient.spokePool.provider,
-                deposit,
-                this.clients.hubPoolClient
-              );
-              if (!isDefined(verifiedFill)) {
-                bundleUnrepayableFillsV3.push(prefill!);
-              } else if (!isSlowFill(verifiedFill)) {
-                validatedBundleV3Fills.push({
-                  ...verifiedFill!,
-                  quoteTimestamp: deposit.quoteTimestamp,
-                });
-              } else {
-                updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
-              }
+            const verifiedFill = await verifyFillRepayment(
+              prefill!,
+              destinationClient.spokePool.provider,
+              deposit,
+              this.clients.hubPoolClient
+            );
+            if (!isDefined(verifiedFill)) {
+              bundleUnrepayableFillsV3.push(prefill!);
+            } else if (!isSlowFill(verifiedFill)) {
+              validatedBundleV3Fills.push({
+                ...verifiedFill!,
+                quoteTimestamp: deposit.quoteTimestamp,
+              });
+            } else {
+              updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
             }
           } else if (_depositIsExpired(deposit)) {
             updateExpiredDepositsV3(expiredDepositsToRefundV3, deposit);
@@ -1286,7 +1245,7 @@ export class BundleDataClient {
             // Don't create duplicate slow fill requests for the same deposit.
             validatedBundleSlowFills.every((d) => getRelayEventKey(d) !== relayDataHash)
           ) {
-            if (canRefundPrefills && _canCreateSlowFillLeaf(deposit)) {
+            if (_canCreateSlowFillLeaf(deposit)) {
               validatedBundleSlowFills.push(deposit);
             }
           }

package/src/clients/HubPoolClient.ts

@@ -776,17 +776,19 @@ 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);
   }

package/src/clients/SpokePoolClient.ts

@@ -21,6 +21,7 @@ import {
   toAddress,
 } from "../utils";
 import {
+  duplicateEvent,
   paginatedEventQuery,
   sortEventsAscendingInPlace,
   spreadEvent,
@@ -587,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");
     }
@@ -656,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;
         }
@@ -718,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;
       }
     };
@@ -751,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]);
       }
@@ -795,6 +821,13 @@ 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.

package/src/constants.ts

@@ -29,8 +29,6 @@ export const HUBPOOL_CHAIN_ID = 1;
 // List of versions where certain UMIP features were deprecated or activated
 export const TRANSFER_THRESHOLD_MAX_CONFIG_STORE_VERSION = 1;
 
-export const PRE_FILL_MIN_CONFIG_STORE_VERSION = 5;
-
 // A hardcoded identifier used, by default, to tag all Arweave records.
 export const ARWEAVE_TAG_APP_NAME = "across-protocol";
 

package/src/utils/BlockUtils.ts

@@ -34,11 +34,11 @@ const defaultHighBlockOffset = 10;
 const cacheTTL = 60 * 15;
 const now = getCurrentTime(); // Seed the cache with initial values.
 const blockTimes: { [chainId: number]: BlockTimeAverage } = {
-  [CHAIN_IDs.DOCTOR_WHO]: { average: 1, timestamp: now, blockRange: 1 },
   [CHAIN_IDs.INK]: { average: 1, timestamp: now, blockRange: 1 },
   [CHAIN_IDs.LINEA]: { average: 3, timestamp: now, blockRange: 1 },
   [CHAIN_IDs.MAINNET]: { average: 12.5, timestamp: now, blockRange: 1 },
   [CHAIN_IDs.OPTIMISM]: { average: 2, timestamp: now, blockRange: 1 },
+  [CHAIN_IDs.UNICHAIN]: { average: 1, timestamp: now, blockRange: 1 },
 };
 
 /**

package/src/utils/EventUtils.ts

@@ -266,3 +266,7 @@ export function isEventOlder<T extends SortableEvent>(ex: T, ey: T): boolean {
 export function getTransactionHashes(events: SortableEvent[]): string[] {
   return [...Array.from(new Set(events.map((e) => e.transactionHash)))];
 }
+
+export function duplicateEvent(a: SortableEvent, b: SortableEvent): boolean {
+  return a.transactionHash === b.transactionHash && a.logIndex === b.logIndex;
+}

package/src/utils/NetworkUtils.ts

@@ -144,9 +144,9 @@ export function chainIsCCTPEnabled(chainId: number): boolean {
     // Mainnets
     CHAIN_IDs.ARBITRUM,
     CHAIN_IDs.BASE,
-    CHAIN_IDs.DOCTOR_WHO,
     CHAIN_IDs.OPTIMISM,
     CHAIN_IDs.POLYGON,
+    CHAIN_IDs.UNICHAIN,
     // Testnets
     CHAIN_IDs.BASE_SEPOLIA,
     CHAIN_IDs.OPTIMISM_SEPOLIA,