@across-protocol/sdk 4.4.0-alpha.8 → 4.4.0

package/src/caching/Arweave/ArweaveClient.ts

@@ -1,43 +1,194 @@
 import Arweave from "arweave";
+import Transaction from "arweave/node/lib/transaction";
 import { JWKInterface } from "arweave/node/lib/wallet";
 
 import { Struct, create } from "superstruct";
 import winston from "winston";
 import { ARWEAVE_TAG_APP_NAME, ARWEAVE_TAG_APP_VERSION, DEFAULT_ARWEAVE_STORAGE_ADDRESS } from "../../constants";
-import { BigNumber, delay, fetchWithTimeout, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
+import { BigNumber, toBN } from "../../utils/BigNumberUtils";
+import { delay } from "../../utils/common";
+import { fetchWithTimeout, isHttpError, postWithTimeout } from "../../utils/FetchUtils";
+import { jsonReplacerWithBigNumbers } from "../../utils/JSONUtils";
+import { isDefined } from "../../utils/TypeGuards";
+
+export interface ArweaveGatewayConfig {
+  host: string;
+  protocol?: string;
+  port?: number;
+}
+
+export const DEFAULT_ARWEAVE_GATEWAYS: ArweaveGatewayConfig[] = [{ host: "arweave.net" }, { host: "ar-io.net" }];
+
+interface Gateway {
+  client: Arweave;
+  url: string;
+}
+
+interface ArweaveTransactionTag {
+  name: string;
+  value: string;
+}
+
+interface ArweaveTransactionResponse {
+  tags?: ArweaveTransactionTag[];
+}
+
+function decodeBase64UrlUtf8(value: string): string {
+  // `/tx/{id}` returns tag names and values in RFC 4648 base64url form.
+  // Node's built-in `base64url` decoder handles the URL-safe alphabet and
+  // omitted padding for us, so this matches the SDK's
+  // `tag.get(..., { decode: true, string: true })` behavior without a custom transform.
+  return Buffer.from(value, "base64url").toString("utf-8");
+}
+
+interface GraphQLTransactionsResponse {
+  data?: {
+    transactions?: {
+      edges?: { node: { id: string } }[];
+    };
+  };
+}
+
+type WritePhase = "createTransaction" | "sign" | "post";
+
+class ArweaveWriteError extends Error {
+  constructor(
+    message: string,
+    readonly phase: WritePhase,
+    readonly gateway: string,
+    readonly status?: number
+  ) {
+    super(message);
+    this.name = "ArweaveWriteError";
+  }
+}
 
 export class ArweaveClient {
-  private client: Arweave;
-  private gatewayUrl: string;
+  private gateways: Gateway[];
 
   public constructor(
     private arweaveJWT: JWKInterface,
     private logger: winston.Logger,
-    public gatewayURL = "arweave.net",
-    public protocol = "https",
-    port = 443,
+    gateways: ArweaveGatewayConfig[] = DEFAULT_ARWEAVE_GATEWAYS,
     private readonly retries = 2,
     private readonly retryDelaySeconds = 1
   ) {
-    this.gatewayUrl = `${protocol}://${gatewayURL}:${port}`;
-    this.client = new Arweave({
-      host: gatewayURL,
-      port,
-      protocol,
-      timeout: 20000,
-      logging: false,
-    });
-    this.logger.debug({
-      at: "ArweaveClient:constructor",
-      message: "Arweave client initialized",
-      gateway: this.gatewayUrl,
-    });
+    if (gateways.length === 0) {
+      throw new Error("At least one gateway must be provided");
+    }
     if (this.retries < 0) {
       throw new Error(`retries cannot be < 0 and must be an integer. Currently set to ${this.retries}`);
     }
     if (this.retryDelaySeconds < 0) {
       throw new Error(`delay cannot be < 0. Currently set to ${this.retryDelaySeconds}`);
     }
+    this.gateways = gateways.map(({ host, protocol = "https", port = 443 }) => ({
+      client: new Arweave({ host, port, protocol, timeout: 20000, logging: false }),
+      url: `${protocol}://${host}:${port}`,
+    }));
+    this.logger.debug({
+      at: "ArweaveClient:constructor",
+      message: "Arweave client initialized",
+      gateways: this.gateways.map((g) => g.url),
+    });
+  }
+
+  /**
+   * Races a request across all gateways, returning the first successful response.
+   * If all gateways fail, throws an error with details from each gateway.
+   */
+  private async _raceGateways<T>(label: string, fn: (gw: Gateway) => Promise<T>, topicTag?: string): Promise<T> {
+    try {
+      return await Promise.any(this.gateways.map((gw) => this._retryRequest(() => fn(gw), 0, label, gw.url, topicTag)));
+    } catch (e) {
+      if (e instanceof AggregateError) {
+        const details = this.gateways.map((gw, i) => `${gw.url}: ${e.errors[i]}`).join("; ");
+        throw new Error(`All Arweave gateways failed for ${label}: ${details}`);
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Tries gateways sequentially, returning the first successful response.
+   * Used for write operations where we want exactly one successful submission.
+   */
+  private async _failoverGateways<T>(
+    label: string,
+    fn: (gw: Gateway, attempt: number) => Promise<T>,
+    topicTag?: string
+  ): Promise<T> {
+    const errors: Error[] = [];
+    for (const [index, gw] of this.gateways.entries()) {
+      try {
+        return await this._retryRequest(() => fn(gw, index + 1), 0, label, gw.url, topicTag);
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        errors.push(error);
+        this.logger.debug({
+          at: "ArweaveClient:failoverGateways",
+          message: `Gateway ${gw.url} failed for ${label}, trying next gateway`,
+          gateway: gw.url,
+          attempt: index + 1,
+          error: String(error),
+        });
+      }
+    }
+    const details = this.gateways.map((gw, i) => `${gw.url}: ${errors[i]}`).join("; ");
+    throw new Error(`All Arweave gateways failed for ${label}: ${details}`);
+  }
+
+  private async _retryRequest<T>(
+    request: () => Promise<T>,
+    retryCount: number,
+    label: string,
+    gateway: string,
+    topicTag?: string
+  ): Promise<T> {
+    try {
+      return await request();
+    } catch (e) {
+      if (retryCount < this.retries) {
+        // Implement a slightly aggressive exponential backoff to account for fierce parallelism.
+        const baseDelay = this.retryDelaySeconds * Math.pow(2, retryCount);
+        const delayS = baseDelay + baseDelay * Math.random();
+        this.logger.debug({
+          at: "ArweaveClient:retryRequest",
+          message: `Arweave request failed, retrying after waiting ${delayS} seconds`,
+          label,
+          gateway,
+          topicTag,
+          retryCount,
+          retryAttempt: retryCount + 1,
+          maxRetries: this.retries,
+          nextRetryDelaySeconds: delayS,
+          error: String(e),
+        });
+        await delay(delayS);
+        return this._retryRequest(request, retryCount + 1, label, gateway, topicTag);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  private _isNotFoundError(error: unknown): boolean {
+    if (isHttpError(error)) {
+      return error.status === 404;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /404/i.test(message);
+  }
+
+  private _wrapWriteError(error: unknown, phase: WritePhase, gateway: string): ArweaveWriteError {
+    if (error instanceof ArweaveWriteError) {
+      return error;
+    }
+    if (isHttpError(error)) {
+      return new ArweaveWriteError(error.message, phase, gateway, error.status);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new ArweaveWriteError(message, phase, gateway);
   }
 
   /**
@@ -47,46 +198,72 @@ export class ArweaveClient {
    * @param value The value to store
    * @param topicTag An optional topic tag to add to the transaction
    * @returns The transaction ID of the stored value
-   * @
    */
   async set(value: Record<string, unknown>, topicTag?: string | undefined): Promise<string | undefined> {
-    const transaction = await this.client.createTransaction(
-      { data: JSON.stringify(value, jsonReplacerWithBigNumbers) },
-      this.arweaveJWT
-    );
+    const payload = JSON.stringify(value, jsonReplacerWithBigNumbers);
+    let signedTransaction: Transaction | undefined;
 
-    // Add tags to the transaction
-    transaction.addTag("Content-Type", "application/json");
-    transaction.addTag("App-Name", ARWEAVE_TAG_APP_NAME);
-    transaction.addTag("App-Version", ARWEAVE_TAG_APP_VERSION.toString());
-    if (isDefined(topicTag)) {
-      transaction.addTag("Topic", topicTag);
-    }
+    try {
+      return await this._failoverGateways(
+        "set",
+        async ({ client, url }, attempt) => {
+          if (!signedTransaction) {
+            let createdTransaction: Transaction;
+            try {
+              createdTransaction = await client.createTransaction({ data: payload }, this.arweaveJWT);
+            } catch (error) {
+              throw this._wrapWriteError(error, "createTransaction", url);
+            }
 
-    // Sign the transaction
-    await this.client.transactions.sign(transaction, this.arweaveJWT);
-    // Send the transaction
-    const result = await this.client.transactions.post(transaction);
+            createdTransaction.addTag("Content-Type", "application/json");
+            createdTransaction.addTag("App-Name", ARWEAVE_TAG_APP_NAME);
+            createdTransaction.addTag("App-Version", ARWEAVE_TAG_APP_VERSION.toString());
+            if (isDefined(topicTag)) {
+              createdTransaction.addTag("Topic", topicTag);
+            }
 
-    // Ensure that the result is successful
-    if (result.status !== 200) {
-      const message = result?.data?.error?.msg ?? "Unknown error";
-      this.logger.error({
-        at: "ArweaveClient:set",
-        message,
-        result,
-        txn: transaction.id,
-        address: await this.getAddress(),
-        balance: (await this.getBalance()).toString(),
-      });
-      throw new Error(message);
-    } else {
-      this.logger.debug({
+            try {
+              await client.transactions.sign(createdTransaction, this.arweaveJWT);
+            } catch (error) {
+              throw this._wrapWriteError(error, "sign", url);
+            }
+
+            signedTransaction = createdTransaction;
+          }
+
+          let result: Awaited<ReturnType<Arweave["transactions"]["post"]>>;
+          try {
+            result = await client.transactions.post(signedTransaction);
+          } catch (error) {
+            throw this._wrapWriteError(error, "post", url);
+          }
+
+          if (result.status !== 200) {
+            const message = result?.data?.error?.msg ?? result.statusText ?? `HTTP ${result.status}`;
+            throw new ArweaveWriteError(message, "post", url, result.status);
+          }
+
+          this.logger.debug({
+            at: "ArweaveClient:set",
+            message: `Arweave transaction posted with ${signedTransaction.id}`,
+            gateway: url,
+            attempt,
+            phase: "post",
+            txn: signedTransaction.id,
+          });
+          return signedTransaction.id;
+        },
+        topicTag
+      );
+    } catch (error) {
+      this.logger.warn({
         at: "ArweaveClient:set",
-        message: `Arweave transaction posted with ${transaction.id}`,
+        message: "Failed to persist data to Arweave after exhausting all gateways",
+        topicTag,
+        error: String(error),
       });
+      throw error;
     }
-    return transaction.id;
   }
 
   /**
@@ -97,15 +274,12 @@ export class ArweaveClient {
    * @returns The record if it exists, otherwise null
    */
   async get<T>(transactionID: string, validator: Struct<T>): Promise<T | null> {
-    // Resolve the URL of the transaction
-    const transactionUrl = `${this.gatewayUrl}/${transactionID}`;
-    // We should query in via Axios directly to the gateway URL. The reasoning behind this is
+    // We query via fetchWithTimeout directly to the gateway URL. The reasoning behind this is
     // that the Arweave SDK's `getData` method is too slow and does not provide a way to set a timeout.
     // Therefore, something that could take milliseconds to complete could take tens of minutes.
-    const request = async () => {
-      return await fetchWithTimeout(transactionUrl, {}, {}, 20_000);
-    };
-    const data = await this._retryRequest(request, 0);
+    const data = await this._raceGateways("get", async ({ url }) => {
+      return await fetchWithTimeout(`${url}/${transactionID}`, {}, {}, 20_000);
+    });
     try {
       // We should validate the data and perform any logical coercion here.
       return create(data, validator);
@@ -149,17 +323,15 @@ export class ArweaveClient {
       ) { edges { node { id } } }
     }`;
 
-    const response = await this._retryRequest(async () => {
-      const response = await this.client.api.post<{
-        data: { transactions: { edges: { node: { id: string } }[] } };
-      }>("/graphql", { query });
-      if (!response.ok) {
-        throw new Error(`Arweave GraphQL request failed with status ${response.status}`);
-      }
-      return response;
-    }, 0);
+    const response = await this._raceGateways(
+      "getByTopic",
+      async ({ url }) => {
+        return await postWithTimeout<GraphQLTransactionsResponse>(`${url}/graphql`, { query }, {}, {}, 20_000);
+      },
+      tag
+    );
 
-    const entries = response?.data?.data?.transactions?.edges ?? [];
+    const entries = response?.data?.transactions?.edges ?? [];
     this.logger.debug({
       at: "ArweaveClient:getByTopic",
       message: `Retrieved ${entries.length} matching transactions from Arweave`,
@@ -170,6 +342,7 @@ export class ArweaveClient {
         appVersion: ARWEAVE_TAG_APP_VERSION,
       },
     });
+    const failures: { hash: string; error: unknown }[] = [];
     const results = await Promise.all(
       entries.map(async (edge) => {
         try {
@@ -181,14 +354,35 @@ export class ArweaveClient {
               }
             : null;
         } catch (e) {
-          this.logger.warn({
-            at: "ArweaveClient:getByTopic",
-            message: `Bad request for Arweave topic ${edge.node.id}: ${e}`,
-          });
+          failures.push({ hash: edge.node.id, error: e });
           return null;
         }
       })
     );
+    const notFoundFailures = failures.filter(({ error }) => this._isNotFoundError(error));
+    const unexpectedFailures = failures.filter(({ error }) => !this._isNotFoundError(error));
+
+    if (notFoundFailures.length > 0) {
+      this.logger.debug({
+        at: "ArweaveClient:getByTopic",
+        message: `Skipped ${notFoundFailures.length} Arweave topic entries that were not yet available`,
+        tag,
+        transactions: notFoundFailures.map(({ hash }) => hash),
+      });
+    }
+
+    if (unexpectedFailures.length > 0) {
+      this.logger.warn({
+        at: "ArweaveClient:getByTopic",
+        message: `Failed to fetch ${unexpectedFailures.length} Arweave topic entries`,
+        tag,
+        failures: unexpectedFailures.map(({ hash, error }) => ({
+          hash,
+          error: String(error),
+        })),
+      });
+    }
+
     return results.filter(isDefined);
   }
 
@@ -198,15 +392,14 @@ export class ArweaveClient {
    * @returns The metadata of the transaction if it exists, otherwise null
    */
   async getMetadata(transactionID: string): Promise<Record<string, string> | null> {
-    const transaction = await this.client.transactions.get(transactionID);
+    const transaction = await this._raceGateways("getMetadata", async ({ url }) => {
+      return await fetchWithTimeout<ArweaveTransactionResponse>(`${url}/tx/${transactionID}`, {}, {}, 20_000);
+    });
     if (!isDefined(transaction)) {
       return null;
     }
     const tags = Object.fromEntries(
-      transaction.tags.map((tag) => [
-        tag.get("name", { decode: true, string: true }),
-        tag.get("value", { decode: true, string: true }),
-      ])
+      (transaction.tags ?? []).map((tag) => [decodeBase64UrlUtf8(tag.name), decodeBase64UrlUtf8(tag.value)])
     );
     return {
       contentType: tags["Content-Type"],
@@ -216,32 +409,12 @@ export class ArweaveClient {
   }
 
   /**
-   * Returns the address of the signer of the JWT
+   * Returns the address of the signer of the JWT. This is a local crypto
+   * operation and does not require a network call.
    * @returns The address of the signer in this client
    */
   getAddress(): Promise<string> {
-    return this.client.wallets.jwkToAddress(this.arweaveJWT);
-  }
-
-  private async _retryRequest<T>(request: () => Promise<T>, retryCount: number): Promise<T> {
-    try {
-      return await request();
-    } catch (e) {
-      if (retryCount < this.retries) {
-        // Implement a slightly aggressive exponential backoff to account for fierce parallelism.
-        const baseDelay = this.retryDelaySeconds * Math.pow(2, retryCount); // ms; attempt = [0, 1, 2, ...]
-        const delayS = baseDelay + baseDelay * Math.random();
-        this.logger.debug({
-          at: "ArweaveClient:retryRequest",
-          message: `Arweave request failed, retrying after waiting ${delayS} seconds: ${e}`,
-          retryCount,
-        });
-        await delay(delayS);
-        return this._retryRequest(request, retryCount + 1);
-      } else {
-        throw e;
-      }
-    }
+    return this.gateways[0].client.wallets.jwkToAddress(this.arweaveJWT);
   }
 
   /**
@@ -250,9 +423,9 @@ export class ArweaveClient {
    */
   async getBalance(): Promise<BigNumber> {
     const address = await this.getAddress();
-    const request = async () => {
-      const balanceInFloat = await this.client.wallets.getBalance(address);
-      // @dev The reason we add in the BN.from into this retry loop is because the client.getBalance call
+    return this._raceGateways("getBalance", async ({ client }) => {
+      const balanceInFloat = await client.wallets.getBalance(address);
+      // @dev The reason we add in the BN.from here is because the client.getBalance call
       // does not correctly throw an error if the request fails, instead it will return the error string as the
       // balanceInFloat.
       // Sometimes the balance is returned in scientific notation, so we need to
@@ -264,7 +437,6 @@ export class ArweaveClient {
       } else {
         return BigNumber.from(balanceInFloat);
       }
-    };
-    return await this._retryRequest(request, 0);
+    });
   }
 }

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -1,5 +1,6 @@
 import assert from "assert";
 import _ from "lodash";
+import { create } from "superstruct";
 import {
   SlowFillRequestWithBlock,
   SpokePoolClientsByChain,
@@ -16,6 +17,7 @@ import {
   FillWithBlock,
   Deposit,
   DepositWithBlock,
+  CachingMechanismInterface,
 } from "../../interfaces";
 import { SpokePoolClient } from "..";
 import { findFillEvent as findEvmFillEvent } from "../../arch/evm";
@@ -42,10 +44,13 @@ import {
   convertRelayDataParamsToBytes32,
   convertFillParamsToBytes32,
   chainIsTvm,
+  getArweaveTopicCacheKey,
+  jsonReplacerWithBigNumbers,
 } from "../../utils";
 import winston from "winston";
 import {
   BundleDataSS,
+  BundleData as PersistedArweaveBundleData,
   getRefundInformationFromFill,
   isChainDisabledAtBlock,
   isChainPaused,
@@ -56,7 +61,7 @@ import {
 } from "./utils";
 import { isEVMSpokePoolClient, isSVMSpokePoolClient } from "../SpokePoolClient";
 import { SpokePoolManager } from "../SpokePoolClient/SpokePoolClientManager";
-
+import { DEFAULT_CACHING_TTL } from "../../constants";
 type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 
 // V3 dictionary helper functions
@@ -164,7 +169,8 @@ export class BundleDataClient {
     readonly clients: Clients,
     spokePoolClients: { [chainId: number]: SpokePoolClient },
     readonly chainIdListForBundleEvaluationBlockNumbers: number[],
-    readonly blockRangeEndBlockBuffer: { [chainId: number]: number } = {}
+    readonly blockRangeEndBlockBuffer: { [chainId: number]: number } = {},
+    readonly arweaveTopicCache?: CachingMechanismInterface
   ) {
     this.spokePoolClientManager = new SpokePoolManager(logger, spokePoolClients);
   }
@@ -204,6 +210,50 @@ export class BundleDataClient {
     return `bundles-${BundleDataClient.getArweaveClientKey(blockRangesForChains)}`;
   }
 
+  private async getPersistedArweaveTopicFromCache(tag: string): Promise<PersistedArweaveBundleData | undefined> {
+    if (!isDefined(this.arweaveTopicCache)) {
+      return undefined;
+    }
+
+    try {
+      const cachedPayload = await this.arweaveTopicCache.get<string>(getArweaveTopicCacheKey(tag));
+      if (!isDefined(cachedPayload)) {
+        return undefined;
+      }
+
+      return create(JSON.parse(cachedPayload), BundleDataSS);
+    } catch (error) {
+      this.logger.debug({
+        at: "BundleDataClient#getPersistedArweaveTopicFromCache",
+        message: "Failed to restore persisted bundle data from topic cache, falling back to Arweave",
+        tag,
+        error: String(error),
+      });
+      return undefined;
+    }
+  }
+
+  private async backfillPersistedArweaveTopicCache(tag: string, data: PersistedArweaveBundleData): Promise<void> {
+    if (!isDefined(this.arweaveTopicCache)) {
+      return;
+    }
+
+    try {
+      await this.arweaveTopicCache.set(
+        getArweaveTopicCacheKey(tag),
+        JSON.stringify(data, jsonReplacerWithBigNumbers),
+        DEFAULT_CACHING_TTL
+      );
+    } catch (error) {
+      this.logger.debug({
+        at: "BundleDataClient#backfillPersistedArweaveTopicCache",
+        message: "Failed to backfill persisted bundle data into topic cache",
+        tag,
+        error: String(error),
+      });
+    }
+  }
+
   private async loadPersistedDataFromArweave(
     blockRangesForChains: number[][]
   ): Promise<LoadDataReturnValue | undefined> {
@@ -211,14 +261,25 @@ export class BundleDataClient {
       return undefined;
     }
     const start = performance.now();
-    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;
+    const tag = this.getArweaveBundleDataClientKey(blockRangesForChains);
+    let data = await this.getPersistedArweaveTopicFromCache(tag);
+
+    if (!isDefined(data)) {
+      const persistedData = await this.clients.arweaveClient.getByTopic(tag, 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;
+      }
+      data = persistedData[0].data;
+      await this.backfillPersistedArweaveTopicCache(tag, data);
+    } else {
+      this.logger.debug({
+        at: "BundleDataClient#loadPersistedDataFromArweave",
+        message: "Loaded persisted bundle data from topic cache",
+        blockRanges: JSON.stringify(blockRangesForChains),
+        tag,
+      });
     }
 
     // A converter function to account for the fact that our SuperStruct schema does not support numeric
@@ -302,8 +363,6 @@ export class BundleDataClient {
       );
     };
 
-    const data = persistedData[0].data;
-
     // This section processes and transforms bundle data loaded from Arweave storage into the correct format:
     // 1. Each field (bundleFillsV3, expiredDepositsToRefundV3, etc.) contains nested records keyed by chainId and token
     // 2. The chainId keys are converted from strings to numbers using convertTypedStringRecordIntoNumericRecord
@@ -365,7 +424,10 @@ export class BundleDataClient {
     const arweaveKey = this.getArweaveBundleDataClientKey(blockRangesForChains);
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     if (!this.arweaveDataCache[arweaveKey]) {
-      this.arweaveDataCache[arweaveKey] = this.loadPersistedDataFromArweave(blockRangesForChains);
+      this.arweaveDataCache[arweaveKey] = this.loadPersistedDataFromArweave(blockRangesForChains).catch((error) => {
+        delete this.arweaveDataCache[arweaveKey];
+        throw error;
+      });
     }
     const arweaveData = _.cloneDeep(await this.arweaveDataCache[arweaveKey]);
     return arweaveData!;
@@ -382,11 +444,18 @@ export class BundleDataClient {
     const key = JSON.stringify(blockRangesForChains);
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     if (!this.loadDataCache[key]) {
-      let arweaveData;
+      let arweaveData: LoadDataReturnValue | undefined;
       if (attemptArweaveLoad) {
-        arweaveData = await this.loadArweaveData(blockRangesForChains);
-      } else {
-        arweaveData = undefined;
+        try {
+          arweaveData = await this.loadArweaveData(blockRangesForChains);
+        } catch (error) {
+          this.logger.warn({
+            at: "BundleDataClient#loadData",
+            message: "Failed to load bundle data from Arweave, falling back to on-chain reconstruction",
+            blockRanges: JSON.stringify(blockRangesForChains),
+            error: String(error),
+          });
+        }
       }
       const data = isDefined(arweaveData)
         ? // We can return the data to a Promise to keep the return type consistent.
@@ -1310,8 +1379,16 @@ export class BundleDataClient {
         spokePoolClient.logger
       );
     } else if (isEVMSpokePoolClient(spokePoolClient)) {
-      const findFillEventHandler = chainIsTvm(spokePoolClient.chainId) ? findTvmFillEvent : findEvmFillEvent;
-      return await findFillEventHandler(
+      if (chainIsTvm(spokePoolClient.chainId)) {
+        return await findTvmFillEvent(
+          spokePoolClient.spokePool,
+          deposit,
+          spokePoolClient.deploymentBlock,
+          spokePoolClient.latestHeightSearched,
+          { maxLookBack: spokePoolClient.eventSearchConfig.maxLookBack }
+        );
+      }
+      return await findEvmFillEvent(
         spokePoolClient.spokePool,
         deposit,
         spokePoolClient.deploymentBlock,