@across-protocol/sdk 4.3.143-alpha.3 → 4.3.143

package/dist/types/src/clients/BundleDataClient/utils/SuperstructUtils.d.ts

@@ -1,5 +1,6 @@
 import { Infer } from "superstruct";
-import { BigNumber, EvmAddress, RawAddress, SvmAddress } from "../../../utils";
+import { BigNumber, EvmAddress, RawAddress, SvmAddress, TvmAddress } from "../../../utils";
+export declare const AddressType: import("superstruct").Struct<SvmAddress | EvmAddress | TvmAddress | RawAddress, null>;
 export declare const SortableEventSS: {
     blockNumber: import("superstruct").Struct<number, null>;
     logIndex: import("superstruct").Struct<number, null>;
@@ -13,13 +14,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -31,7 +32,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         blockNumber: number;
         logIndex: number;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -44,23 +45,23 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         fills: {
             destinationChainId: number;
             originChainId: number;
-            depositor: SvmAddress | EvmAddress | RawAddress;
-            recipient: SvmAddress | EvmAddress | RawAddress;
-            inputToken: SvmAddress | EvmAddress | RawAddress;
-            outputToken: SvmAddress | EvmAddress | RawAddress;
+            depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             inputAmount: BigNumber;
             outputAmount: BigNumber;
-            exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+            exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             quoteTimestamp: number;
             fillDeadline: number;
             depositId: BigNumber;
             exclusivityDeadline: number;
             repaymentChainId: number;
-            relayer: SvmAddress | EvmAddress | RawAddress;
+            relayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             messageHash: string;
             relayExecutionInfo: {
                 updatedOutputAmount: BigNumber;
-                updatedRecipient: SvmAddress | EvmAddress | RawAddress;
+                updatedRecipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
                 updatedMessageHash: string;
                 fillType: number;
                 updatedMessage?: string | undefined;
@@ -82,13 +83,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -101,7 +102,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         logIndex: number;
         lpFeePct: BigNumber;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -114,13 +115,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -132,7 +133,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         blockNumber: number;
         logIndex: number;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -145,13 +146,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -164,7 +165,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         logIndex: number;
         lpFeePct: BigNumber;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -178,13 +179,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -196,7 +197,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         blockNumber: number;
         logIndex: number;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -209,13 +210,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -227,7 +228,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         blockNumber: number;
         logIndex: number;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -240,13 +241,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -259,7 +260,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         logIndex: number;
         lpFeePct: BigNumber;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -272,13 +273,13 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         message: string;
         destinationChainId: number;
         originChainId: number;
-        depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
-        inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         inputAmount: BigNumber;
         outputAmount: BigNumber;
-        exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+        exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
         quoteTimestamp: number;
         fillDeadline: number;
         depositId: BigNumber;
@@ -291,7 +292,7 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         logIndex: number;
         lpFeePct: BigNumber;
         updatedOutputAmount?: BigNumber | undefined;
-        updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
+        updatedRecipient?: SvmAddress | EvmAddress | TvmAddress | RawAddress | undefined;
         updatedMessage?: string | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
@@ -304,23 +305,23 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         fills: {
             destinationChainId: number;
             originChainId: number;
-            depositor: SvmAddress | EvmAddress | RawAddress;
-            recipient: SvmAddress | EvmAddress | RawAddress;
-            inputToken: SvmAddress | EvmAddress | RawAddress;
-            outputToken: SvmAddress | EvmAddress | RawAddress;
+            depositor: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            recipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            inputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
+            outputToken: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             inputAmount: BigNumber;
             outputAmount: BigNumber;
-            exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
+            exclusiveRelayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             quoteTimestamp: number;
             fillDeadline: number;
             depositId: BigNumber;
             exclusivityDeadline: number;
             repaymentChainId: number;
-            relayer: SvmAddress | EvmAddress | RawAddress;
+            relayer: SvmAddress | EvmAddress | TvmAddress | RawAddress;
             messageHash: string;
             relayExecutionInfo: {
                 updatedOutputAmount: BigNumber;
-                updatedRecipient: SvmAddress | EvmAddress | RawAddress;
+                updatedRecipient: SvmAddress | EvmAddress | TvmAddress | RawAddress;
                 updatedMessageHash: string;
                 fillType: number;
                 updatedMessage?: string | undefined;

package/dist/types/src/clients/BundleDataClient/utils/SuperstructUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SuperstructUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/clients/BundleDataClient/utils/SuperstructUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAcN,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAA4B,MAAM,gBAAgB,CAAC;AAiDzG,eAAO,MAAM,eAAe;;;;;;;CAS3B,CAAC;AA6EF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"SuperstructUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/clients/BundleDataClient/utils/SuperstructUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAcN,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,SAAS,EAAQ,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAa,MAAM,gBAAgB,CAAC;AAuB5G,eAAO,MAAM,WAAW,uFAatB,CAAC;AAuBH,eAAO,MAAM,eAAe;;;;;;;CAS3B,CAAC;AA6EF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.143-alpha.3",
+  "version": "4.3.143",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "repository": {
@@ -81,7 +81,7 @@
   },
   "dependencies": {
     "@across-protocol/constants": "^3.1.109",
-    "@across-protocol/contracts": "5.0.6",
+    "@across-protocol/contracts": "5.0.7",
     "@coral-xyz/anchor": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",

package/src/caching/Arweave/ArweaveClient.ts

@@ -6,104 +6,37 @@ 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";
 
-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;
-}
-
 export class ArweaveClient {
-  private gateways: Gateway[];
+  private client: Arweave;
+  private gatewayUrl: string;
 
   public constructor(
     private arweaveJWT: JWKInterface,
     private logger: winston.Logger,
-    gateways: ArweaveGatewayConfig[] = DEFAULT_ARWEAVE_GATEWAYS,
+    public gatewayURL = "arweave.net",
+    public protocol = "https",
+    port = 443,
     private readonly retries = 2,
     private readonly retryDelaySeconds = 1
   ) {
-    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.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",
-      gateways: this.gateways.map((g) => g.url),
+      gateway: this.gatewayUrl,
     });
-  }
-
-  /**
-   * 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>): Promise<T> {
-    try {
-      return await Promise.any(this.gateways.map((gw) => this._retryRequest(() => fn(gw), 0)));
-    } 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) => Promise<T>): Promise<T> {
-    const errors: Error[] = [];
-    for (const gw of this.gateways) {
-      try {
-        return await this._retryRequest(() => fn(gw), 0);
-      } catch (e) {
-        errors.push(e as Error);
-        this.logger.debug({
-          at: "ArweaveClient:failoverGateways",
-          message: `Gateway ${gw.url} failed for ${label}, trying next: ${e}`,
-        });
-      }
+    if (this.retries < 0) {
+      throw new Error(`retries cannot be < 0 and must be an integer. Currently set to ${this.retries}`);
     }
-    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): 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: ${e}`,
-          retryCount,
-        });
-        await delay(delayS);
-        return this._retryRequest(request, retryCount + 1);
-      } else {
-        throw e;
-      }
+    if (this.retryDelaySeconds < 0) {
+      throw new Error(`delay cannot be < 0. Currently set to ${this.retryDelaySeconds}`);
     }
   }
 
@@ -114,12 +47,10 @@ 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> {
-    // Get a template client to use for creating a transaction. Since clients are equal up to the gateway URL,
-    // it does not matter which gateway is used, so we just choose the first one.
-    const templateClient = this.gateways[0].client;
-    const transaction = await templateClient.createTransaction(
+    const transaction = await this.client.createTransaction(
       { data: JSON.stringify(value, jsonReplacerWithBigNumbers) },
       this.arweaveJWT
     );
@@ -133,32 +64,29 @@ export class ArweaveClient {
     }
 
     // Sign the transaction
-    await templateClient.transactions.sign(transaction, this.arweaveJWT);
+    await this.client.transactions.sign(transaction, this.arweaveJWT);
     // Send the transaction
+    const result = await this.client.transactions.post(transaction);
 
-    return await this._failoverGateways("set", async ({ client }) => {
-      const result = await client.transactions.post(transaction);
-
-      // 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);
-      }
-
+    // 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({
         at: "ArweaveClient:set",
         message: `Arweave transaction posted with ${transaction.id}`,
       });
-      return transaction.id;
-    });
+    }
+    return transaction.id;
   }
 
   /**
@@ -169,12 +97,15 @@ export class ArweaveClient {
    * @returns The record if it exists, otherwise null
    */
   async get<T>(transactionID: string, validator: Struct<T>): Promise<T | null> {
-    // We query via fetchWithTimeout directly to the gateway URL. The reasoning behind this is
+    // 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
     // 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 data = await this._raceGateways("get", async ({ url }) => {
-      return await fetchWithTimeout(`${url}/${transactionID}`, {}, {}, 20_000);
-    });
+    const request = async () => {
+      return await fetchWithTimeout(transactionUrl, {}, {}, 20_000);
+    };
+    const data = await this._retryRequest(request, 0);
     try {
       // We should validate the data and perform any logical coercion here.
       return create(data, validator);
@@ -218,15 +149,15 @@ export class ArweaveClient {
       ) { edges { node { id } } }
     }`;
 
-    const response = await this._raceGateways("getByTopic", async ({ client }) => {
-      const response = await client.api.post<{
+    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 entries = response?.data?.data?.transactions?.edges ?? [];
     this.logger.debug({
@@ -267,9 +198,7 @@ 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._raceGateways("getMetadata", async ({ client }) => {
-      return await client.transactions.get(transactionID);
-    });
+    const transaction = await this.client.transactions.get(transactionID);
     if (!isDefined(transaction)) {
       return null;
     }
@@ -287,12 +216,32 @@ export class ArweaveClient {
   }
 
   /**
-   * 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 of the JWT
    * @returns The address of the signer in this client
    */
   getAddress(): Promise<string> {
-    return this.gateways[0].client.wallets.jwkToAddress(this.arweaveJWT);
+    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;
+      }
+    }
   }
 
   /**
@@ -301,9 +250,9 @@ export class ArweaveClient {
    */
   async getBalance(): Promise<BigNumber> {
     const address = await this.getAddress();
-    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
+    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
       // 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
@@ -315,6 +264,7 @@ export class ArweaveClient {
       } else {
         return BigNumber.from(balanceInFloat);
       }
-    });
+    };
+    return await this._retryRequest(request, 0);
   }
 }

package/src/clients/BundleDataClient/utils/SuperstructUtils.ts

@@ -14,8 +14,12 @@ import {
   union,
   type,
 } from "superstruct";
-import { CHAIN_IDs, UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType, toBytes32 } from "../../../utils";
+import { utils as ethersUtils } from "ethers";
+import { isAddress as isValidEvmAddress } from "viem";
+import { isAddress as isValidSvmAddress } from "@solana/kit";
+import { TronWeb } from "tronweb";
+import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
+import { BigNumber, bs58, EvmAddress, RawAddress, SvmAddress, TvmAddress, toBytes32 } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
 const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{64}$/);
@@ -31,16 +35,26 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   }
 });
 
-// Accept any concrete implementation of `Address` (Evm, Svm, or Raw) but avoid using the
-// abstract `Address` class directly to keep TypeScript happy.
-const AddressInstanceSS = union([instance(EvmAddress), instance(SvmAddress), instance(RawAddress)]);
-
-const AddressType = coerce(AddressInstanceSS, string(), (value) => {
-  // Addresses are posted to arweave in their native format (base16 for EVM, base58 for SVM). The chainId for
-  // for the event data is not directly available, so infer it based on the shape of the address. RawAddress
-  // will be instantiated if the address format does not match the expected family.
-  const chainId = value.startsWith("0x") ? CHAIN_IDs.MAINNET : CHAIN_IDs.SOLANA;
-  return toAddressType(value, chainId);
+const AddressInstanceSS = union([
+  instance(EvmAddress),
+  instance(SvmAddress),
+  instance(TvmAddress),
+  instance(RawAddress),
+]);
+
+export const AddressType = coerce(AddressInstanceSS, string(), (value) => {
+  // Each family is matched by its native-format validator plus a length gate where it
+  // disambiguates. Unknown shapes fall to `RawAddress`, forcing future families into explicit
+  // branches rather than being absorbed silently.
+  try {
+    // strict: false preserves the prior byte-level acceptance of all-upper / non-checksummed hex.
+    if (value.length === 42 && isValidEvmAddress(value, { strict: false })) return EvmAddress.from(value);
+    if (value.length === 34 && TronWeb.isAddress(value)) return TvmAddress.from(value);
+    if (isValidSvmAddress(value)) return SvmAddress.from(value);
+  } catch {
+    // Validator accepted but `from()` rejected (e.g. SVM 12-zero EVM-masquerade) → RawAddress.
+  }
+  return new RawAddress(value.startsWith("0x") ? ethersUtils.arrayify(value) : bs58.decode(value));
 });
 
 const Web3AddressType = coerce(Web3AddressSS, string(), (value) => {