aftermath-ts-sdk 2.2.0 → 2.2.1-dev.32c4013

package/dist/index.js

@@ -1868,6 +1868,148 @@ var init_helpers = __esm({
   }
 });
 
+// src/general/utils/transportError.ts
+function defaultMessage(kind, status) {
+  if (kind === "http") {
+    return status === void 0 ? "Aftermath HTTP request failed" : `Aftermath HTTP request failed with status ${status}`;
+  }
+  if (kind === "network") {
+    return "Aftermath network request failed";
+  }
+  if (kind === "abort") {
+    return "Aftermath request was aborted";
+  }
+  if (kind === "timeout") {
+    return "Aftermath request timed out";
+  }
+  return "Aftermath response could not be decoded";
+}
+function isAftermathTransportError(error) {
+  return error instanceof AftermathTransportError;
+}
+function getProperty(value, property) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  try {
+    return value[property];
+  } catch {
+    return void 0;
+  }
+}
+function getStringProperty(value, property) {
+  const propertyValue = getProperty(value, property);
+  return typeof propertyValue === "string" ? propertyValue : void 0;
+}
+function getStringCode(value) {
+  return getStringProperty(value, "code");
+}
+function isTimeoutCode(code) {
+  return code !== void 0 && TIMEOUT_CODES.has(code);
+}
+function isTimeoutReason(reason) {
+  if (isAftermathTransportError(reason) && (reason.kind === "timeout" || reason.abortSource === "timeout")) {
+    return true;
+  }
+  return getProperty(reason, "name") === "TimeoutError" || isTimeoutCode(getStringCode(reason));
+}
+function parseRetryAfter(headerValue, nowMs = Date.now()) {
+  if (headerValue === null) {
+    return void 0;
+  }
+  const value = headerValue.trim();
+  if (value === "") {
+    return void 0;
+  }
+  if (DELTA_SECONDS_REGEX.test(value)) {
+    const milliseconds = BigInt(value) * 1000n;
+    return milliseconds <= MAX_SAFE_INTEGER_BIGINT ? Number(milliseconds) : void 0;
+  }
+  if (!HTTP_DATE_REGEX.test(value)) {
+    return void 0;
+  }
+  const dateMs = Date.parse(value);
+  if (!Number.isFinite(dateMs)) {
+    return void 0;
+  }
+  const retryAfterMs = dateMs - nowMs;
+  return retryAfterMs >= 0 && Number.isSafeInteger(retryAfterMs) ? retryAfterMs : void 0;
+}
+function normalizeAftermathTransportError(error, signal) {
+  if (isAftermathTransportError(error)) {
+    return error;
+  }
+  const errorCode = getStringCode(error);
+  const signalReason = signal?.aborted ? signal.reason : void 0;
+  const signalReasonCode = getStringCode(signalReason);
+  const code = errorCode ?? signalReasonCode;
+  if (signal?.aborted) {
+    const timeout = isTimeoutReason(signalReason) || isTimeoutReason(error);
+    return new AftermathTransportError(timeout ? "timeout" : "abort", {
+      abortSource: timeout ? "timeout" : "caller",
+      cause: error,
+      code
+    });
+  }
+  if (isTimeoutReason(error)) {
+    return new AftermathTransportError("timeout", {
+      abortSource: "timeout",
+      cause: error,
+      code: errorCode
+    });
+  }
+  return new AftermathTransportError("network", {
+    cause: error,
+    code: errorCode
+  });
+}
+var MAX_SAFE_INTEGER_BIGINT, DELTA_SECONDS_REGEX, HTTP_DATE_REGEX, TIMEOUT_CODES, AftermathTransportError;
+var init_transportError = __esm({
+  "src/general/utils/transportError.ts"() {
+    "use strict";
+    MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    DELTA_SECONDS_REGEX = /^\d+$/;
+    HTTP_DATE_REGEX = /^(?:[A-Za-z]{3}, \d{2} [A-Za-z]{3} \d{4} \d{2}:\d{2}:\d{2} GMT|[A-Za-z]+, \d{2}-[A-Za-z]{3}-\d{2} \d{2}:\d{2}:\d{2} GMT|[A-Za-z]{3} [A-Za-z]{3} {1,2}\d{1,2} \d{2}:\d{2}:\d{2} \d{4})$/;
+    TIMEOUT_CODES = /* @__PURE__ */ new Set([
+      "UND_ERR_BODY_TIMEOUT",
+      "UND_ERR_CONNECT_TIMEOUT",
+      "UND_ERR_HEADERS_TIMEOUT",
+      "ETIMEDOUT"
+    ]);
+    AftermathTransportError = class extends Error {
+      constructor(kind, options = {}) {
+        const causeMessage = getStringProperty(options.cause, "message");
+        super(
+          options.message ?? causeMessage ?? defaultMessage(kind, options.status)
+        );
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = options.name ?? getStringProperty(options.cause, "name") ?? "AftermathTransportError";
+        this.kind = kind;
+        if (options.status !== void 0) {
+          this.status = options.status;
+        }
+        if (options.retryAfterMs !== void 0) {
+          this.retryAfterMs = options.retryAfterMs;
+        }
+        if (options.code !== void 0) {
+          this.code = options.code;
+        }
+        if (options.abortSource !== void 0) {
+          this.abortSource = options.abortSource;
+        }
+        if (options.cause !== void 0) {
+          Object.defineProperty(this, "cause", {
+            configurable: true,
+            enumerable: false,
+            value: options.cause,
+            writable: false
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/general/utils/caller.ts
 import { Transaction as Transaction3 } from "@mysten/sui/transactions";
 function bigIntReplacer(_key, value) {
@@ -1881,6 +2023,7 @@ var init_caller = __esm({
   "src/general/utils/caller.ts"() {
     "use strict";
     init_helpers();
+    init_transportError();
     _Caller = class _Caller {
       // =========================================================================
       //  Constructor
@@ -1908,11 +2051,26 @@ var init_caller = __esm({
       static async fetchResponseToType(response, disableBigIntJsonParsing) {
         if (!response.ok) {
           const status = response.status;
+          const retryAfterMs = parseRetryAfter(response.headers.get("Retry-After"));
+          const statusText = response.statusText;
           const body = await response.text();
-          throw new Error(`HTTP ${status} ${response.statusText}: ${body}`);
+          throw new AftermathTransportError("http", {
+            message: `HTTP ${status} ${statusText}: ${body}`,
+            name: "Error",
+            retryAfterMs,
+            status
+          });
         }
         const text = await response.text();
-        const output = disableBigIntJsonParsing ? JSON.parse(text, (_key, value) => value === null ? void 0 : value) : Helpers.parseJsonWithBigint(text);
+        let output;
+        try {
+          output = disableBigIntJsonParsing ? JSON.parse(
+            text,
+            (_key, value) => value === null ? void 0 : value
+          ) : Helpers.parseJsonWithBigint(text);
+        } catch (cause) {
+          throw new AftermathTransportError("decode", { cause });
+        }
         return output ?? void 0;
       }
       /**
@@ -1937,21 +2095,25 @@ var init_caller = __esm({
       //  Api Calling
       // =========================================================================
       async fetchApi(url, body, signal, options) {
-        const apiCallUrl = this.urlForApiCall(url);
-        const headers = {
-          "Content-Type": "application/json",
-          ...this.config.accessToken ? { Authorization: `Bearer ${this.config.accessToken}` } : {}
-        };
-        const uncastResponse = await (body === void 0 ? fetch(apiCallUrl, { headers, signal }) : fetch(apiCallUrl, {
-          method: "POST",
-          body: JSON.stringify(body, bigIntReplacer),
-          headers,
-          signal
-        }));
-        return _Caller.fetchResponseToType(
-          uncastResponse,
-          !!options?.disableBigIntJsonParsing
-        );
+        try {
+          const apiCallUrl = this.urlForApiCall(url);
+          const headers = {
+            "Content-Type": "application/json",
+            ...this.config.accessToken ? { Authorization: `Bearer ${this.config.accessToken}` } : {}
+          };
+          const uncastResponse = await (body === void 0 ? fetch(apiCallUrl, { headers, signal }) : fetch(apiCallUrl, {
+            method: "POST",
+            body: JSON.stringify(body, bigIntReplacer),
+            headers,
+            signal
+          }));
+          return await _Caller.fetchResponseToType(
+            uncastResponse,
+            !!options?.disableBigIntJsonParsing
+          );
+        } catch (error) {
+          throw normalizeAftermathTransportError(error, signal);
+        }
       }
       async fetchApiTransaction(url, body, signal, options) {
         const txKind = await this.fetchApi(
@@ -2117,10 +2279,13 @@ var init_prices = __esm({
        * console.log(suiPriceInfo.price, suiPriceInfo.priceChange24HoursPercentage);
        * ```
        */
-      async getCoinPriceInfo(inputs) {
-        const coinsToPriceInfo = await this.getCoinsToPriceInfo({
-          coins: [inputs.coin]
-        });
+      async getCoinPriceInfo(inputs, abortSignal) {
+        const coinsToPriceInfo = await this.getCoinsToPriceInfo(
+          {
+            coins: [inputs.coin]
+          },
+          abortSignal
+        );
         return Object.values(coinsToPriceInfo)[0];
       }
       /**
@@ -2139,8 +2304,8 @@ var init_prices = __esm({
        * console.log(info);
        * ```
        */
-      async getCoinsToPriceInfo(inputs) {
-        return this.fetchApi("", inputs);
+      async getCoinsToPriceInfo(inputs, abortSignal) {
+        return this.fetchApi("", inputs, abortSignal);
       }
       /**
        * Fetches only the current price in USD for a single coin.
@@ -2155,8 +2320,8 @@ var init_prices = __esm({
        * console.log("SUI price in USD:", suiPrice);
        * ```
        */
-      async getCoinPrice(inputs) {
-        const priceInfo = await this.getCoinPriceInfo(inputs);
+      async getCoinPrice(inputs, abortSignal) {
+        const priceInfo = await this.getCoinPriceInfo(inputs, abortSignal);
         return priceInfo.price;
       }
       /**
@@ -2172,8 +2337,11 @@ var init_prices = __esm({
        * console.log(multiPrices["0x2::sui::SUI"]); // e.g. 1.23
        * ```
        */
-      async getCoinsToPrice(inputs) {
-        const coinsToPriceInfo = await this.getCoinsToPriceInfo(inputs);
+      async getCoinsToPrice(inputs, abortSignal) {
+        const coinsToPriceInfo = await this.getCoinsToPriceInfo(
+          inputs,
+          abortSignal
+        );
         const coinsToPrice = Object.entries(coinsToPriceInfo).reduce(
           (acc, [coinType, info]) => ({
             ...acc,
@@ -2234,9 +2402,9 @@ var init_coin = __esm({
        * console.log(decimals); // { "0x2::sui::SUI": 9, "0x<...>": 6 }
        * ```
        */
-      async getCoinsToDecimals(inputs) {
+      async getCoinsToDecimals(inputs, abortSignal) {
         const { coins } = inputs;
-        const metadatas = await this.getCoinMetadatas(inputs);
+        const metadatas = await this.getCoinMetadatas(inputs, abortSignal);
         const coinsToDecimals = metadatas.map((data) => data.decimals).reduce((acc, decimals, index) => {
           return { ...acc, [coins[index]]: decimals };
         }, {});
@@ -2256,7 +2424,7 @@ var init_coin = __esm({
        * console.log(metadata.name, metadata.symbol, metadata.decimals);
        * ```
        */
-      async getCoinMetadata(coin) {
+      async getCoinMetadata(coin, abortSignal) {
         if (this.metadata) {
           return this.metadata;
         }
@@ -2264,7 +2432,10 @@ var init_coin = __esm({
         if (!coinType) {
           throw new Error("no valid coin type");
         }
-        const [metadata] = await this.getCoinMetadatas({ coins: [coinType] });
+        const [metadata] = await this.getCoinMetadatas(
+          { coins: [coinType] },
+          abortSignal
+        );
         this.setCoinMetadata(metadata);
         return metadata;
       }
@@ -2283,12 +2454,13 @@ var init_coin = __esm({
        * console.log(metas[0].symbol, metas[1].symbol);
        * ```
        */
-      async getCoinMetadatas(inputs) {
+      async getCoinMetadatas(inputs, abortSignal) {
         return this.fetchApi(
           "metadata",
           {
             coins: inputs.coins.map((coin) => Helpers.addLeadingZeroesToType(coin))
-          }
+          },
+          abortSignal
         );
       }
       /**
@@ -2313,7 +2485,7 @@ var init_coin = __esm({
        * console.log(priceInfo.price, priceInfo.priceChange24HoursPercentage);
        * ```
        */
-      async getPrice(coin) {
+      async getPrice(coin, abortSignal) {
         if (this.priceInfo !== void 0) {
           return this.priceInfo;
         }
@@ -2321,9 +2493,12 @@ var init_coin = __esm({
         if (!coinType) {
           throw new Error("no valid coin type");
         }
-        const priceInfo = await new Prices(this.config).getCoinPriceInfo({
-          coin: coinType
-        });
+        const priceInfo = await new Prices(this.config).getCoinPriceInfo(
+          {
+            coin: coinType
+          },
+          abortSignal
+        );
         this.setPriceInfo(priceInfo);
         return priceInfo;
       }
@@ -4794,6 +4969,7 @@ var init_utils = __esm({
     init_casting();
     init_grpcCasting();
     init_helpers();
+    init_transportError();
   }
 });
 
@@ -5292,10 +5468,13 @@ var init_farmsStakingPool = __esm({
        * console.log(poolTvl);
        * ```
        */
-      async getTVL() {
-        return new Farms(this.config, this.api).getTVL({
-          farmIds: [this.stakingPool.objectId]
-        });
+      async getTVL(abortSignal) {
+        return new Farms(this.config, this.api).getTVL(
+          {
+            farmIds: [this.stakingPool.objectId]
+          },
+          abortSignal
+        );
       }
       /**
        * Fetches the total value locked (TVL) of the reward coins in this specific staking pool.
@@ -5308,10 +5487,13 @@ var init_farmsStakingPool = __esm({
        * console.log(rewardTvl);
        * ```
        */
-      async getRewardsTVL() {
-        return new Farms(this.config, this.api).getRewardsTVL({
-          farmIds: [this.stakingPool.objectId]
-        });
+      async getRewardsTVL(abortSignal) {
+        return new Farms(this.config, this.api).getRewardsTVL(
+          {
+            farmIds: [this.stakingPool.objectId]
+          },
+          abortSignal
+        );
       }
       // =========================================================================
       //  Transactions
@@ -6031,9 +6213,11 @@ var init_farms = __esm({
        * console.log(pool.stakingPool);
        * ```
        */
-      async getStakingPool(inputs) {
+      async getStakingPool(inputs, abortSignal) {
         const stakingPool = await this.fetchApi(
-          inputs.objectId
+          inputs.objectId,
+          void 0,
+          abortSignal
         );
         return new FarmsStakingPool(stakingPool, this.config, this.api);
       }
@@ -6051,10 +6235,14 @@ var init_farms = __esm({
        * console.log(pools[0].stakingPool, pools[1].stakingPool);
        * ```
        */
-      async getStakingPools(inputs) {
-        const stakingPools = await this.fetchApi("", {
-          farmIds: inputs.objectIds
-        });
+      async getStakingPools(inputs, abortSignal) {
+        const stakingPools = await this.fetchApi(
+          "",
+          {
+            farmIds: inputs.objectIds
+          },
+          abortSignal
+        );
         return stakingPools.map(
           (stakingPool) => new FarmsStakingPool(stakingPool, this.config, this.api)
         );
@@ -6070,8 +6258,12 @@ var init_farms = __esm({
        * console.log(allPools.map(pool => pool.stakingPool));
        * ```
        */
-      async getAllStakingPools() {
-        const stakingPools = await this.fetchApi("", {});
+      async getAllStakingPools(abortSignal) {
+        const stakingPools = await this.fetchApi(
+          "",
+          {},
+          abortSignal
+        );
         return stakingPools.map(
           (pool) => new FarmsStakingPool(pool, this.config, this.api)
         );
@@ -6150,8 +6342,8 @@ var init_farms = __esm({
        * console.log("Specific farm's TVL:", tvlForSpecificFarm);
        * ```
        */
-      async getTVL(inputs) {
-        return this.fetchApi("tvl", inputs ?? {});
+      async getTVL(inputs, abortSignal) {
+        return this.fetchApi("tvl", inputs ?? {}, abortSignal);
       }
       /**
        * Retrieves the total value locked (TVL) of reward coins across specified farm IDs or all farms if none are specified.
@@ -6168,8 +6360,19 @@ var init_farms = __esm({
        * console.log("Single farm's rewards TVL:", singleFarmRewardsTvl);
        * ```
        */
-      async getRewardsTVL(inputs) {
-        return this.fetchApi("rewards-tvl", inputs ?? {});
+      async getRewardsTVL(inputs, abortSignal) {
+        return this.fetchApi("rewards-tvl", inputs ?? {}, abortSignal);
+      }
+      /**
+       * Fetches TVL and reward TVL for multiple farms in a single batch response.
+       * When `farmIds` is omitted, the API returns summaries for all farms.
+       *
+       * @param inputs - Optionally provide the farm IDs to include.
+       * @param abortSignal - An optional signal for cancelling the request.
+       * @returns TVL and reward TVL metrics for each requested farm.
+       */
+      async getFarmSummaries(inputs, abortSignal) {
+        return this.fetchApi("summary", inputs ?? {}, abortSignal);
       }
       // =========================================================================
       //  Transactions
@@ -8569,10 +8772,13 @@ var init_pools = __esm({
          * console.log(poolId);
          * ```
          */
-        this.getPoolObjectIdForLpCoinType = (inputs) => {
-          return this.getPoolObjectIdsForLpCoinTypes({
-            lpCoinTypes: [inputs.lpCoinType]
-          });
+        this.getPoolObjectIdForLpCoinType = (inputs, abortSignal) => {
+          return this.getPoolObjectIdsForLpCoinTypes(
+            {
+              lpCoinTypes: [inputs.lpCoinType]
+            },
+            abortSignal
+          );
         };
         /**
          * Checks if a given coin type is recognized as an LP coin.
@@ -8581,8 +8787,8 @@ var init_pools = __esm({
          * @param inputs - Contains the `lpCoinType` to check.
          * @returns `true` if the coin is an LP token, `false` otherwise.
          */
-        this.isLpCoinType = async (inputs) => {
-          const result = await this.getPoolObjectIdForLpCoinType(inputs);
+        this.isLpCoinType = async (inputs, abortSignal) => {
+          const result = await this.getPoolObjectIdForLpCoinType(inputs, abortSignal);
           return result.some((id) => id !== void 0);
         };
         /**
@@ -8632,8 +8838,12 @@ var init_pools = __esm({
        * console.log(pool.pool.lpCoinType, pool.pool.name);
        * ```
        */
-      async getPool(inputs) {
-        const pool = await this.fetchApi(inputs.objectId);
+      async getPool(inputs, abortSignal) {
+        const pool = await this.fetchApi(
+          inputs.objectId,
+          void 0,
+          abortSignal
+        );
         return new Pool(pool, this.config, this.api);
       }
       /**
@@ -8648,10 +8858,14 @@ var init_pools = __esm({
        * console.log(poolArray.length);
        * ```
        */
-      async getPools(inputs) {
-        const pools = await this.fetchApi("", {
-          poolIds: inputs.objectIds
-        });
+      async getPools(inputs, abortSignal) {
+        const pools = await this.fetchApi(
+          "",
+          {
+            poolIds: inputs.objectIds
+          },
+          abortSignal
+        );
         return pools.map((pool) => new Pool(pool, this.config, this.api));
       }
       /**
@@ -8665,8 +8879,8 @@ var init_pools = __esm({
        * console.log(allPools.map(p => p.pool.name));
        * ```
        */
-      async getAllPools() {
-        const pools = await this.fetchApi("", {});
+      async getAllPools(abortSignal) {
+        const pools = await this.fetchApi("", {}, abortSignal);
         return pools.map((pool) => new Pool(pool, this.config, this.api));
       }
       /**
@@ -8756,8 +8970,8 @@ var init_pools = __esm({
        * console.log(poolIds);
        * ```
        */
-      async getPoolObjectIdsForLpCoinTypes(inputs) {
-        return this.fetchApi("pool-object-ids", inputs);
+      async getPoolObjectIdsForLpCoinTypes(inputs, abortSignal) {
+        return this.fetchApi("pool-object-ids", inputs, abortSignal);
       }
       /**
        * Retrieves the total value locked (TVL) across all or specific pool IDs.
@@ -8787,8 +9001,19 @@ var init_pools = __esm({
        * console.log(stats[0].volume, stats[1].tvl);
        * ```
        */
-      async getPoolsStats(inputs) {
-        return this.fetchApi("stats", inputs);
+      async getPoolsStats(inputs, abortSignal) {
+        return this.fetchApi("stats", inputs, abortSignal);
+      }
+      /**
+       * Fetches pool objects and their statistics in a single batch response.
+       * When `poolIds` is omitted, the API returns summaries for all pools.
+       *
+       * @param inputs - Optionally provide the pool IDs to include.
+       * @param abortSignal - An optional signal for cancelling the request.
+       * @returns Pool objects paired with their current statistics.
+       */
+      async getPoolSummaries(inputs, abortSignal) {
+        return this.fetchApi("summary", inputs ?? {}, abortSignal);
       }
       /**
        * Returns all DAO fee pool owner capabilities owned by a particular user.
@@ -15396,11 +15621,11 @@ var init_rewards = __esm({
       /**
        * Preview a single account's expected rewards for an epoch, broken down by
        * domain (trading, referral, AFLP, integrator) plus totals. Backed by the
-       * newer `rewards/expectedRewards` endpoint. Provide exactly one of `address`
+       * newer `rewards/expected-rewards` endpoint. Provide exactly one of `address`
        * or `accountId`; omit `epoch` for the current epoch.
        */
       async getExpectedRewards(inputs) {
-        return this.fetchApi("expectedRewards", inputs);
+        return this.fetchApi("expected-rewards", inputs);
       }
       // =========================================================================
       //  Transactions
@@ -23552,22 +23777,22 @@ var init_aftermath = __esm({
        * returns a ready-to-use instance. Pass `addresses` or `api` to skip
        * the corresponding bootstrap steps.
        */
-      static async create(options = {}) {
+      static async create(options = {}, abortSignal) {
         const af = new _Aftermath(options);
-        await af.bootstrap();
+        await af.bootstrap(abortSignal);
         return af;
       }
       /**
        * Resolves addresses and wires up the internal `AftermathApi`. Called
        * exactly once by the {@link Aftermath.create} factory.
        */
-      async bootstrap() {
+      async bootstrap(abortSignal) {
         if (this.options.api) {
           this.api = this.options.api;
           return;
         }
         const network = this.network;
-        const addresses = this.options.addresses ?? await this.getAddresses();
+        const addresses = this.options.addresses ?? await this.getAddresses(abortSignal);
         const fullnodeUrl = this.options.fullnodeUrl ?? Caller.defaultFullnodeUrl(network);
         const client = new SuiGrpcClient({
           network: network.toLowerCase(),
@@ -23599,8 +23824,8 @@ var init_aftermath = __esm({
        * directly from the API. Typically you don't need to call this — the
        * `create` factory handles it. Useful for cache warmers or tooling.
        */
-      getAddresses() {
-        return this.fetchApi("addresses");
+      getAddresses(abortSignal) {
+        return this.fetchApi("addresses", void 0, abortSignal);
       }
       /**
        * Attempts to decode a raw Move abort/error string into a structured
@@ -23647,6 +23872,7 @@ init_index();
 export {
   Aftermath,
   AftermathApi,
+  AftermathTransportError,
   Auth,
   Casting,
   Coin,
@@ -23676,6 +23902,7 @@ export {
   SuiFren,
   SuiFrens,
   SuiFrensSortOption,
+  isAftermathTransportError,
   isAllocatedCollateralEvent,
   isCanceledOrderEvent,
   isDeallocatedCollateralEvent,