Merge branch 'master' into pxrl/bigintBuffer

Author: pxrl

.gitignore

@@ -44,3 +44,6 @@ yarn-error.log
 yarn-debug.log*
 gasReporterOutput.json
 logs
+
+# AI
+.claude

e2e/priceClient.e2e.ts

@@ -1,5 +1,4 @@
 import assert from "assert";
-import axios from "axios";
 import dotenv from "dotenv";
 import winston from "winston";
 import { Logger, msToS, PriceCache, PriceClient, PriceFeedAdapter, TokenPrice } from "../src/priceClient/priceClient";
@@ -104,20 +103,22 @@ describe("PriceClient: BaseHTTPAdapter", function () {
       const baseAdapter = new TestBaseHTTPAdapter(name, "127.0.0.1", { timeout: 1, retries });
       expect(baseAdapter.nRetries).to.be.eq(0);
 
-      // Instantiate callback for HTTP response != 2xx.
-      const interceptor = axios.interceptors.response.use(
-        undefined, // HTTP 2xx.
-        function (error) {
-          const result = retries && baseAdapter.nRetries === retries ? Promise.resolve({}) : Promise.reject(error);
-          return result;
+      // Mock fetch to succeed on the final retry.
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = (...args: Parameters<typeof fetch>) => {
+        if (retries && baseAdapter.nRetries === retries) {
+          return new Response(JSON.stringify({}), { status: 200 });
         }
-      );
-
-      const response = baseAdapter._query("", { retries });
-      await assertPromisePasses(response);
-      axios.interceptors.response.eject(interceptor); // Cleanup ASAP.
+        return originalFetch(...args);
+      };
 
-      expect(baseAdapter.nRetries).to.be.eq(retries);
+      try {
+        const response = baseAdapter._query("", { retries });
+        await assertPromisePasses(response);
+        expect(baseAdapter.nRetries).to.be.eq(retries);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
     }
   });
 });

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.136",
+  "version": "4.3.138",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "repository": {
@@ -115,7 +115,6 @@
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",
     "@nktkas/hyperliquid": "^0.25.9",
-    "@pinata/sdk": "^2.1.0",
     "@solana-program/compute-budget": "^0.11.0",
     "@solana-program/system": "^0.10.0",
     "@solana-program/token": "^0.9.0",
@@ -124,11 +123,10 @@
     "@uma/contracts-node": "^0.4.0",
     "arweave": "^1.14.4",
     "async": "^3.2.5",
-    "axios": "^0.27.2",
     "bs58": "^6.0.0",
     "decimal.js": "^10.3.1",
     "ethers": "^5.7.2",
-    "lodash": "^4.17.23",
+    "lodash": "^4.18.1",
     "lodash.get": "^4.4.2",
     "superstruct": "^0.15.4",
     "tslib": "^2.6.2",

src/addressAggregator/adapters/abstract.ts

@@ -1,6 +1,5 @@
-import axios from "axios";
 import { AdapterOptions, AddressListAdapter } from "../types";
-import { Logger } from "../../utils";
+import { Logger, fetchWithTimeout } from "../../utils";
 
 const { ACROSS_USER_AGENT = "across-protocol" } = process.env;
 
@@ -28,18 +27,13 @@ export abstract class AbstractAdapter implements AddressListAdapter {
   }
 
   protected async fetch(name: string, url: string, timeout = 2000, retries = 1): Promise<unknown> {
-    const args = {
-      headers: { "User-Agent": ACROSS_USER_AGENT },
-      timeout,
-    };
-
     const errs: string[] = [];
     let tries = 0;
     do {
       try {
-        return (await axios(url, args)).data;
+        return await fetchWithTimeout(url, {}, { "User-Agent": ACROSS_USER_AGENT }, timeout);
       } catch (err) {
-        const errMsg = axios.isAxiosError(err) || err instanceof Error ? err.message : "unknown error";
+        const errMsg = err instanceof Error ? err.message : "unknown error";
         errs.push(errMsg);
         if (++tries <= retries) await this.sleep(Math.pow(1.5, tries) * 1000); // simple backoff
       }

src/apiClient/productionClient.ts

@@ -1,13 +1,24 @@
-import axios from "axios";
 import AbstractApiClient from "./abstractClient";
-import { BigNumber, parseEther } from "../utils";
+import { BigNumber, fetchWithTimeout, parseEther } from "../utils";
 import {
   CoingeckoDataReturnType,
   SuggestedFeeReturnType,
   BridgeLimitsReturnType,
   AcrossBridgeStatisticsType,
 } from "./types";
 
+type SuggestedFeesApiResponse = {
+  relayFeePct: string;
+  relayFeeTotal: string;
+  capitalFeePct: string;
+  capitalFeeTotal: string;
+  relayGasFeePct: string;
+  relayGasFeeTotal: string;
+  isAmountTooLow: boolean;
+  timestamp: string;
+  quoteBlock: string;
+};
+
 /**
  * An implementation of AbstractApiClient that uses the production API.
  * @class
@@ -20,13 +31,10 @@ export default class ProductionApiClient extends AbstractApiClient {
   }
 
   public async getCoinGeckoData(l1Token: string, baseCurrency: string): Promise<CoingeckoDataReturnType> {
-    const response = await axios.get(`${this.getServerlessApiUrl()}/api/coingecko`, {
-      params: {
-        l1Token,
-        baseCurrency,
-      },
+    const result = await fetchWithTimeout<{ price: string }>(`${this.getServerlessApiUrl()}/api/coingecko`, {
+      l1Token,
+      baseCurrency,
     });
-    const result = response.data;
     const price = baseCurrency === "usd" ? parseEther(String(result.price)) : BigNumber.from(result.price);
     return {
       price,
@@ -38,16 +46,16 @@ export default class ProductionApiClient extends AbstractApiClient {
     toChainid: number,
     fromChainid: number
   ): Promise<SuggestedFeeReturnType> {
-    const response = await axios.get(`${this.getServerlessApiUrl()}/api/suggested-fees`, {
-      params: {
+    const result = await fetchWithTimeout<SuggestedFeesApiResponse>(
+      `${this.getServerlessApiUrl()}/api/suggested-fees`,
+      {
         token: originToken,
         destinationChainId: toChainid,
         originChainId: fromChainid,
         amount: amount.toString(),
         skipAmountLimit: true,
-      },
-    });
-    const result = response.data;
+      }
+    );
     const relayFeePct = BigNumber.from(result["relayFeePct"]);
     const relayFeeTotal = BigNumber.from(result["relayFeeTotal"]);
 
@@ -85,13 +93,15 @@ export default class ProductionApiClient extends AbstractApiClient {
     fromChainId: string | number,
     toChainId: string | number
   ): Promise<BridgeLimitsReturnType> {
-    const { data } = await axios.get<BridgeLimitsReturnType>(
-      `${this.getServerlessApiUrl()}/api/limits?token=${token}&originChainId=${fromChainId}&destinationChainId=${toChainId}`
-    );
+    const data = await fetchWithTimeout<BridgeLimitsReturnType>(`${this.getServerlessApiUrl()}/api/limits`, {
+      token,
+      originChainId: fromChainId,
+      destinationChainId: toChainId,
+    });
     return data;
   }
   public async getAcrossStats(): Promise<AcrossBridgeStatisticsType> {
-    const axiosResponse = await axios.get<AcrossBridgeStatisticsType>(`${this.getScraperApiUrl()}/deposits/stats`);
-    return axiosResponse.data;
+    const data = await fetchWithTimeout<AcrossBridgeStatisticsType>(`${this.getScraperApiUrl()}/deposits/stats`);
+    return data;
   }
 }

src/caching/Arweave/ArweaveClient.ts

@@ -1,10 +1,10 @@
 import Arweave from "arweave";
 import { JWKInterface } from "arweave/node/lib/wallet";
-import axios from "axios";
+
 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, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
+import { BigNumber, delay, fetchWithTimeout, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
 
 export class ArweaveClient {
   private client: Arweave;
@@ -103,8 +103,7 @@ export class ArweaveClient {
     // 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 () => {
-      const { data: requestData } = await axios.get(transactionUrl);
-      return requestData;
+      return await fetchWithTimeout(transactionUrl);
     };
     const data = await this._retryRequest(request, 0);
     try {

src/caching/IPFS/PinataIPFSClient.ts

@@ -1,3 +1,2 @@
-export * from "./IPFS";
 export * from "./Arweave";
 export * from "./Memory";

src/caching/IPFS/index.ts

@@ -1,7 +1,5 @@
-import axios, { AxiosError } from "axios";
 import assert from "assert";
-import get from "lodash.get";
-import { getCoingeckoTokenIdByAddress, retry } from "../utils";
+import { fetchWithTimeout, getCoingeckoTokenIdByAddress, retry } from "../utils";
 import { Logger } from "../relayFeeCalculator";
 
 export function msToS(ms: number) {
@@ -386,19 +384,19 @@ export class Coingecko {
 
       // If no pro api key, only send basic request:
       if (this.apiKey === undefined) {
-        return (await this._callBasic(path)) as T;
+        return await this._callBasic<T>(path);
       }
 
       // If pro api key, try basic and use pro as fallback.
       try {
-        return (await this._callBasic(path, this.basicApiTimeout)) as T;
+        return await this._callBasic<T>(path, this.basicApiTimeout);
       } catch (err) {
         this.logger.debug({
           at: "sdk/coingecko",
           message: `Basic CG url request failed, falling back to CG PRO host ${proHost}`,
-          errMessage: (err as AxiosError).message,
+          errMessage: (err as Error).message,
         });
-        return await this._callPro(path);
+        return await this._callPro<T>(path);
       }
     };
 
@@ -502,29 +500,15 @@ export class Coingecko {
     }
   }
 
-  private async _callBasic(path: string, timeout?: number) {
+  private async _callBasic<T>(path: string, timeout?: number): Promise<T> {
     const url = `${this.host}/${path}`;
 
-    try {
-      // Don't use timeout if there is no pro API to fallback to.
-      const result = await axios(url, { timeout });
-      return result.data;
-    } catch (err) {
-      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
-      throw new Error(msg);
-    }
+    // Don't use timeout if there is no pro API to fallback to.
+    return await fetchWithTimeout<T>(url, {}, {}, timeout);
   }
 
-  private async _callPro(path: string) {
+  private async _callPro<T>(path: string): Promise<T> {
     const url = `${this.proHost}/${path}`;
-
-    try {
-      // Don't use timeout if there is no pro API to fallback to.
-      const result = await axios(url, { params: { x_cg_pro_api_key: this.apiKey } });
-      return result.data;
-    } catch (err) {
-      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
-      throw new Error(msg);
-    }
+    return await fetchWithTimeout<T>(url, { x_cg_pro_api_key: this.apiKey });
   }
 }