@upcoming/bee-js 9.9.1 → 11.1.0

package/dist/mjs/utils/http.js

@@ -10,6 +10,7 @@ const MAX_FAILED_ATTEMPTS = 100000;
 const DELAY_FAST = 200;
 const DELAY_SLOW = 1000;
 const DELAY_THRESHOLD = Dates.minutes(1) / DELAY_FAST;
+const ABORT_ERROR_MESSAGE = 'Request aborted';
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
@@ -17,6 +18,11 @@ export const DEFAULT_HTTP_CONFIG = {
   maxBodyLength: Infinity,
   maxContentLength: Infinity
 };
+function throwIfAborted(signal, config, responseData, responseStatus) {
+  if (signal?.aborted) {
+    throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', ABORT_ERROR_MESSAGE, responseData, responseStatus, 'ERR_CANCELED');
+  }
+}
 /**
  * Main function to make HTTP requests.
  * @param options User defined settings
@@ -24,9 +30,11 @@ export const DEFAULT_HTTP_CONFIG = {
  */
 export async function http(options, config) {
   const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
-  if (requestConfig.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(requestConfig.data)) {
-    requestConfig.data = requestConfig.data.buffer.slice(requestConfig.data.byteOffset, requestConfig.data.byteOffset + requestConfig.data.byteLength);
+  if (options.signal) {
+    requestConfig.signal = options.signal;
+    throwIfAborted(options.signal, config);
   }
+  maybeReplaceBodyBuffers(requestConfig);
   if (requestConfig.params) {
     const keys = Object.keys(requestConfig.params);
     for (const key of keys) {
@@ -38,6 +46,7 @@ export async function http(options, config) {
   }
   let failedAttempts = 0;
   while (failedAttempts < MAX_FAILED_ATTEMPTS) {
+    throwIfAborted(options.signal, config);
     try {
       debug(`${requestConfig.method || 'get'} ${Strings.joinUrl([requestConfig.baseURL, requestConfig.url])}`, {
         headers: {
@@ -50,11 +59,16 @@ export async function http(options, config) {
       return response;
     } catch (e) {
       if (e instanceof AxiosError) {
+        if (e.code === 'ERR_CANCELED') {
+          throwIfAborted({
+            aborted: true
+          }, config, e.response?.data, e.response?.status);
+        }
         if (e.code === 'ECONNABORTED' && options.endlesslyRetry) {
           failedAttempts++;
           await System.sleepMillis(failedAttempts < DELAY_THRESHOLD ? DELAY_FAST : DELAY_SLOW);
         } else {
-          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.code);
+          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.response?.statusText);
         }
       } else {
         throw e;
@@ -74,4 +88,12 @@ function maybeRunOnRequestHook(options, requestConfig) {
       params: requestConfig.params
     });
   }
+}
+function maybeReplaceBodyBuffers(config) {
+  if (config.data && config.data instanceof Uint8Array) {
+    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  }
+  if (config.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(config.data)) {
+    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  }
 }

package/dist/mjs/utils/size.js

@@ -25,6 +25,31 @@ export class Size {
   static fromGigabytes(gigabytes) {
     return new Size(gigabytes * 1000 * 1000 * 1000);
   }
+  /**
+   * Parses a size string and returns a `Size` instance.
+   *
+   * Case insensitive. E.g. both `"28MB"` and `"1gb"` are valid.
+   *
+   * Whitespaces are ignored. E.g. both `"512 kb"` and `"2megabytes"` are valid.
+   *
+   * Decimal numbers are supported. E.g. `"1.5gb"` is valid.
+   *
+   * Uses 1000 as the base for conversions. E.g. 1kb = 1000 bytes.
+   * This is consistent with the effective stamp utilization table.
+   *
+   * Supported units:
+   * - b, byte, bytes
+   * - kb, kilobyte, kilobytes
+   * - mb, megabyte, megabytes
+   * - gb, gigabyte, gigabytes
+   * - tb, terabyte, terabytes
+   *
+   * @param size - A string representing a size
+   * @returns a `Size` instance
+   */
+  static parseFromString(size) {
+    return Size.fromBytes(Numbers.makeStorage(size, 1000));
+  }
   toBytes() {
     return this.bytes;
   }

package/dist/mjs/utils/stamps.js

@@ -2,8 +2,11 @@ import { Binary } from 'cafe-utility';
 import { capacityBreakpoints } from "../types/index.js";
 import { Bytes, parseSizeToBytes } from "./bytes.js";
 import { Duration } from "./duration.js";
+import { Size } from "./size.js";
 import { BZZ } from "./tokens.js";
 import { asNumberString } from "./type.js";
+import { BatchId } from "./typed-bytes.js";
+import { normalizeBatchTTL } from "./workaround.js";
 const MAX_UTILIZATION = 0.9;
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
@@ -137,4 +140,49 @@ export function marshalStamp(signature, batchId, timestamp, index) {
     throw Error('invalid index length');
   }
   return new Bytes(Binary.concatBytes(batchId, index, timestamp, signature));
+}
+export function mapPostageBatch(raw, encryption, erasureCodeLevel) {
+  const usage = getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
+  const batchTTL = normalizeBatchTTL(raw.batchTTL);
+  const duration = Duration.fromSeconds(batchTTL);
+  const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, erasureCodeLevel);
+  return {
+    batchID: new BatchId(raw.batchID),
+    utilization: raw.utilization,
+    usable: raw.usable,
+    label: raw.label,
+    depth: raw.depth,
+    amount: asNumberString(raw.amount),
+    bucketDepth: raw.bucketDepth,
+    blockNumber: raw.blockNumber,
+    immutableFlag: raw.immutableFlag,
+    usage,
+    usageText: `${Math.round(usage * 100)}%`,
+    size: Size.fromBytes(effectiveBytes),
+    remainingSize: Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage))),
+    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(raw.depth)),
+    duration,
+    calculateSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(effectiveBytes);
+    },
+    calculateRemainingSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(Math.ceil(effectiveBytes * (1 - this.usage)));
+    }
+  };
+}
+export function unmapPostageBatch(batch) {
+  return {
+    batchID: batch.batchID.toHex(),
+    utilization: batch.utilization,
+    usable: batch.usable,
+    label: batch.label,
+    depth: batch.depth,
+    amount: batch.amount,
+    bucketDepth: batch.bucketDepth,
+    blockNumber: batch.blockNumber,
+    immutableFlag: batch.immutableFlag,
+    batchTTL: batch.duration.toSeconds()
+  };
 }

package/dist/mjs/utils/type.js

@@ -34,7 +34,8 @@ export function prepareBeeRequestOptions(value) {
     httpsAgent: object.httpsAgent,
     endlesslyRetry: Types.asOptional(x => Types.asBoolean(x, {
       name: 'endlesslyRetry'
-    }), object.endlesslyRetry)
+    }), object.endlesslyRetry),
+    signal: object.signal
   };
 }
 export function prepareDownloadOptions(value) {
@@ -158,6 +159,9 @@ export function preparePssMessageHandler(value) {
     }),
     onError: Types.asFunction(object.onError, {
       name: 'onError'
+    }),
+    onClose: Types.asFunction(object.onClose, {
+      name: 'onClose'
     })
   };
 }
@@ -171,6 +175,9 @@ export function prepareGsocMessageHandler(value) {
     }),
     onError: Types.asFunction(object.onError, {
       name: 'onError'
+    }),
+    onClose: Types.asFunction(object.onClose, {
+      name: 'onClose'
     })
   };
 }

package/dist/mjs/utils/workaround.js

@@ -6,8 +6,11 @@ export function normalizeBatchTTL(batchTTL) {
   if (batchTTL < 1) {
     return 1;
   }
-  if (batchTTL > 315569260) {
-    return 315569260;
+  // Cap `batchTTL` (represents seconds) to 100 years.
+  // We can assume `storagePrice` is invalid (e.g. 1).
+  // This is needed to prevent Date objects breaking.
+  if (batchTTL > 3155695200) {
+    return 3155695200;
   }
   return batchTTL;
 }