@across-protocol/sdk 4.3.143 → 4.3.145-alpha.0

package/dist/types/src/utils/common.d.ts

@@ -120,13 +120,25 @@ export declare const getSamplesBetween: (min: number, max: number, size: number)
  */
 export declare function delay(seconds: number): Promise<unknown>;
 /**
- * Attempt to retry a function call a number of times with a delay between each attempt
- * @param call The function to call
- * @param times The number of times to retry
- * @param delayS The number of seconds to delay between each attempt
+ * Configures {@link retry}. Retries always use exponential backoff
+ * (`delaySeconds * 2 ** attempt + random()` seconds) to play nicely with upstream
+ * rate-limits; callers that want tighter spacing should lower {@link delaySeconds}.
+ */
+export type RetryOptions = {
+    /** Maximum number of retry attempts after the initial call (total attempts = retries + 1). Defaults to 2 (3 total tries). */
+    retries?: number;
+    /** Base delay in seconds for the exponential backoff. Defaults to 1. */
+    delaySeconds?: number;
+    /** Predicate evaluated against the thrown error to decide whether to retry. Defaults to retrying every error. */
+    isRetryable?: (err: unknown) => boolean;
+};
+/**
+ * Attempt to retry a function call with exponential backoff and a retryability predicate.
+ * @param call The function to call.
+ * @param options Retry configuration — see {@link RetryOptions}. All fields are optional; omitted fields inherit the SDK defaults.
  * @returns The result of the function call.
  */
-export declare function retry<T>(call: () => Promise<T>, times: number, delayS: number): Promise<T>;
+export declare function retry<T>(call: () => Promise<T>, options?: RetryOptions): Promise<T>;
 export type TransactionCostEstimate = {
     nativeGasCost: BigNumber;
     tokenGasCost: BigNumber;

package/dist/types/src/utils/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/utils/common.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/utils/common.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.143",
+  "version": "4.3.145-alpha.0",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "repository": {

package/src/caching/Arweave/ArweaveClient.ts

@@ -6,38 +6,105 @@ 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 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>): 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}`,
+        });
+      }
+    }
+    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;
+      }
+    }
   }
 
   /**
@@ -47,10 +114,12 @@ 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(
+    // 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(
       { data: JSON.stringify(value, jsonReplacerWithBigNumbers) },
       this.arweaveJWT
     );
@@ -64,29 +133,32 @@ export class ArweaveClient {
     }
 
     // Sign the transaction
-    await this.client.transactions.sign(transaction, this.arweaveJWT);
+    await templateClient.transactions.sign(transaction, this.arweaveJWT);
     // Send the transaction
-    const result = await this.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);
-    } else {
+    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);
+      }
+
       this.logger.debug({
         at: "ArweaveClient:set",
         message: `Arweave transaction posted with ${transaction.id}`,
       });
-    }
-    return transaction.id;
+      return transaction.id;
+    });
   }
 
   /**
@@ -97,15 +169,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,15 +218,15 @@ export class ArweaveClient {
       ) { edges { node { id } } }
     }`;
 
-    const response = await this._retryRequest(async () => {
-      const response = await this.client.api.post<{
+    const response = await this._raceGateways("getByTopic", async ({ client }) => {
+      const response = await 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({
@@ -198,7 +267,9 @@ 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 ({ client }) => {
+      return await client.transactions.get(transactionID);
+    });
     if (!isDefined(transaction)) {
       return null;
     }
@@ -216,32 +287,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 +301,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 +315,6 @@ export class ArweaveClient {
       } else {
         return BigNumber.from(balanceInFloat);
       }
-    };
-    return await this._retryRequest(request, 0);
+    });
   }
 }

package/src/coingecko/Coingecko.ts

@@ -401,7 +401,10 @@ export class Coingecko {
     };
 
     // Note: If a pro API key is configured, there is no need to retry as the Pro API will act as the basic's fall back.
-    return retry(sendRequest, this.apiKey === undefined ? this.numRetries : 0, this.retryDelay);
+    return retry(sendRequest, {
+      retries: this.apiKey === undefined ? this.numRetries : 0,
+      delaySeconds: this.retryDelay,
+    });
   }
 
   protected getPriceCache(currency: string, platform_id: string): { [addr: string]: CoinGeckoPrice } {

package/src/utils/common.ts

@@ -221,20 +221,47 @@ export function delay(seconds: number) {
 }
 
 /**
- * Attempt to retry a function call a number of times with a delay between each attempt
- * @param call The function to call
- * @param times The number of times to retry
- * @param delayS The number of seconds to delay between each attempt
+ * Configures {@link retry}. Retries always use exponential backoff
+ * (`delaySeconds * 2 ** attempt + random()` seconds) to play nicely with upstream
+ * rate-limits; callers that want tighter spacing should lower {@link delaySeconds}.
+ */
+export type RetryOptions = {
+  /** Maximum number of retry attempts after the initial call (total attempts = retries + 1). Defaults to 2 (3 total tries). */
+  retries?: number;
+  /** Base delay in seconds for the exponential backoff. Defaults to 1. */
+  delaySeconds?: number;
+  /** Predicate evaluated against the thrown error to decide whether to retry. Defaults to retrying every error. */
+  isRetryable?: (err: unknown) => boolean;
+};
+
+const DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {
+  retries: 2,
+  delaySeconds: 1,
+  isRetryable: () => true,
+};
+
+/**
+ * Attempt to retry a function call with exponential backoff and a retryability predicate.
+ * @param call The function to call.
+ * @param options Retry configuration — see {@link RetryOptions}. All fields are optional; omitted fields inherit the SDK defaults.
  * @returns The result of the function call.
  */
-export function retry<T>(call: () => Promise<T>, times: number, delayS: number): Promise<T> {
-  let promiseChain = call();
-  for (let i = 0; i < times; i++)
-    promiseChain = promiseChain.catch(async () => {
-      await delay(delayS);
+export function retry<T>(call: () => Promise<T>, options: RetryOptions = {}): Promise<T> {
+  const resolved: Required<RetryOptions> = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  const backoffSeconds = (attempt: number): number => resolved.delaySeconds * 2 ** attempt + Math.random();
+
+  const attempt = async (nAttempts: number): Promise<T> => {
+    try {
       return await call();
-    });
-  return promiseChain;
+    } catch (err) {
+      if (nAttempts >= resolved.retries || !resolved.isRetryable(err)) {
+        throw err;
+      }
+      await delay(backoffSeconds(nAttempts));
+      return attempt(nAttempts + 1);
+    }
+  };
+  return attempt(0);
 }
 
 export type TransactionCostEstimate = {