@ethersphere/bee-js 6.8.0 → 6.9.0

package/dist/mjs/modules/bytes.js

@@ -1,5 +1,5 @@
 import { wrapBytesWithHelpers } from "../utils/bytes.js";
-import { extractUploadHeaders } from "../utils/headers.js";
+import { extractDownloadHeaders, extractRedundantUploadHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { makeTagUid } from "../utils/type.js";
 const endpoint = 'bytes';
@@ -19,7 +19,7 @@ export async function upload(requestOptions, data, postageBatchId, options) {
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options)
+      ...extractRedundantUploadHeaders(postageBatchId, options)
     }
   });
   return {
@@ -33,10 +33,11 @@ export async function upload(requestOptions, data, postageBatchId, options) {
  * @param ky
  * @param hash Bee content reference
  */
-export async function download(requestOptions, hash) {
+export async function download(requestOptions, hash, options) {
   const response = await http(requestOptions, {
     responseType: 'arraybuffer',
-    url: `${endpoint}/${hash}`
+    url: `${endpoint}/${hash}`,
+    headers: extractDownloadHeaders(options)
   });
   return wrapBytesWithHelpers(new Uint8Array(response.data));
 }
@@ -46,10 +47,11 @@ export async function download(requestOptions, hash) {
  * @param ky
  * @param hash Bee content reference
  */
-export async function downloadReadable(requestOptions, hash) {
+export async function downloadReadable(requestOptions, hash, options) {
   const response = await http(requestOptions, {
     responseType: 'stream',
-    url: `${endpoint}/${hash}`
+    url: `${endpoint}/${hash}`,
+    headers: extractDownloadHeaders(options)
   });
   return response.data;
 }

package/dist/mjs/modules/bzz.js

@@ -1,13 +1,13 @@
 import { wrapBytesWithHelpers } from "../utils/bytes.js";
 import { assertCollection } from "../utils/collection.js";
-import { extractUploadHeaders, readFileHeaders } from "../utils/headers.js";
+import { extractDownloadHeaders, extractRedundantUploadHeaders, readFileHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { isReadable } from "../utils/stream.js";
 import { makeTar } from "../utils/tar.js";
 import { makeTagUid } from "../utils/type.js";
 const bzzEndpoint = 'bzz';
 function extractFileUploadHeaders(postageBatchId, options) {
-  const headers = extractUploadHeaders(postageBatchId, options);
+  const headers = extractRedundantUploadHeaders(postageBatchId, options);
   if (options?.size) headers['content-length'] = String(options.size);
   if (options?.contentType) headers['content-type'] = options.contentType;
   return headers;
@@ -23,7 +23,9 @@ function extractFileUploadHeaders(postageBatchId, options) {
  */
 export async function uploadFile(requestOptions, data, postageBatchId, name, options) {
   if (isReadable(data) && !options?.contentType) {
-    if (!options) options = {};
+    if (!options) {
+      options = {};
+    }
     options.contentType = 'application/octet-stream';
   }
   const response = await http(requestOptions, {
@@ -50,11 +52,12 @@ export async function uploadFile(requestOptions, data, postageBatchId, name, opt
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export async function downloadFile(requestOptions, hash, path = '') {
+export async function downloadFile(requestOptions, hash, path = '', options) {
   const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'arraybuffer',
-    url: `${bzzEndpoint}/${hash}/${path}`
+    url: `${bzzEndpoint}/${hash}/${path}`,
+    headers: extractDownloadHeaders(options)
   });
   const file = {
     ...readFileHeaders(response.headers),
@@ -69,11 +72,12 @@ export async function downloadFile(requestOptions, hash, path = '') {
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export async function downloadFileReadable(requestOptions, hash, path = '') {
+export async function downloadFileReadable(requestOptions, hash, path = '', options) {
   const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'stream',
-    url: `${bzzEndpoint}/${hash}/${path}`
+    url: `${bzzEndpoint}/${hash}/${path}`,
+    headers: extractDownloadHeaders(options)
   });
   const file = {
     ...readFileHeaders(response.headers),
@@ -82,9 +86,13 @@ export async function downloadFileReadable(requestOptions, hash, path = '') {
   return file;
 }
 function extractCollectionUploadHeaders(postageBatchId, options) {
-  const headers = extractUploadHeaders(postageBatchId, options);
-  if (options?.indexDocument) headers['swarm-index-document'] = options.indexDocument;
-  if (options?.errorDocument) headers['swarm-error-document'] = options.errorDocument;
+  const headers = extractRedundantUploadHeaders(postageBatchId, options);
+  if (options?.indexDocument) {
+    headers['swarm-index-document'] = options.indexDocument;
+  }
+  if (options?.errorDocument) {
+    headers['swarm-error-document'] = options.errorDocument;
+  }
   return headers;
 }
 /**

package/dist/mjs/types/index.js

@@ -22,6 +22,35 @@ export const STAMPS_DEPTH_MAX = 255;
 export const TAGS_LIMIT_MIN = 1;
 export const TAGS_LIMIT_MAX = 1000;
 export const FEED_INDEX_HEX_LENGTH = 16;
+/**
+ * Add redundancy to the data being uploaded so that downloaders can download it with better UX.
+ * 0 value is default and does not add any redundancy to the file.
+ */
+export var RedundancyLevel;
+(function (RedundancyLevel) {
+  RedundancyLevel[RedundancyLevel["OFF"] = 0] = "OFF";
+  RedundancyLevel[RedundancyLevel["MEDIUM"] = 1] = "MEDIUM";
+  RedundancyLevel[RedundancyLevel["STRONG"] = 2] = "STRONG";
+  RedundancyLevel[RedundancyLevel["INSANE"] = 3] = "INSANE";
+  RedundancyLevel[RedundancyLevel["PARANOID"] = 4] = "PARANOID";
+})(RedundancyLevel || (RedundancyLevel = {}));
+/**
+ * Specify the retrieve strategy on redundant data.
+ * The possible values are NONE, DATA, PROX and RACE.
+ * Strategy NONE means no prefetching takes place.
+ * Strategy DATA means only data chunks are prefetched.
+ * Strategy PROX means only chunks that are close to the node are prefetched.
+ * Strategy RACE means all chunks are prefetched: n data chunks and k parity chunks. The first n chunks to arrive are used to reconstruct the file.
+ * Multiple strategies can be used in a fallback cascade if the swarm redundancy fallback mode is set to true.
+ * The default strategy is NONE, DATA, falling back to PROX, falling back to RACE
+ */
+export var RedundancyStrategy;
+(function (RedundancyStrategy) {
+  RedundancyStrategy[RedundancyStrategy["NONE"] = 0] = "NONE";
+  RedundancyStrategy[RedundancyStrategy["DATA"] = 1] = "DATA";
+  RedundancyStrategy[RedundancyStrategy["PROX"] = 2] = "PROX";
+  RedundancyStrategy[RedundancyStrategy["RACE"] = 3] = "RACE";
+})(RedundancyStrategy || (RedundancyStrategy = {}));
 /*********************************************************
  * Writers and Readers interfaces
  */

package/dist/mjs/utils/expose.js

@@ -6,4 +6,5 @@ export { ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, m
 export { isNodeReadable, isReadable, isReadableStream, normalizeToReadableStream, readableNodeToWeb, readableWebToNode } from "./stream.js";
 export { keccak256Hash } from "./hash.js";
 export { makeMaxTarget } from "./pss.js";
-export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampMaximumCapacityBytes, getStampEffectiveBytes, getStampTtlSeconds, getStampUsage } from "./stamps.js";
+export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage } from "./stamps.js";
+export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from "./redundancy.js";

package/dist/mjs/utils/headers.js

@@ -42,9 +42,37 @@ export function extractUploadHeaders(postageBatchId, options) {
   const headers = {
     'swarm-postage-batch-id': postageBatchId
   };
-  if (options?.pin) headers['swarm-pin'] = String(options.pin);
-  if (options?.encrypt) headers['swarm-encrypt'] = String(options.encrypt);
-  if (options?.tag) headers['swarm-tag'] = String(options.tag);
-  if (typeof options?.deferred === 'boolean') headers['swarm-deferred-upload'] = options.deferred.toString();
+  if (options?.pin) {
+    headers['swarm-pin'] = String(options.pin);
+  }
+  if (options?.encrypt) {
+    headers['swarm-encrypt'] = String(options.encrypt);
+  }
+  if (options?.tag) {
+    headers['swarm-tag'] = String(options.tag);
+  }
+  if (typeof options?.deferred === 'boolean') {
+    headers['swarm-deferred-upload'] = options.deferred.toString();
+  }
+  return headers;
+}
+export function extractRedundantUploadHeaders(postageBatchId, options) {
+  const headers = extractUploadHeaders(postageBatchId, options);
+  if (options?.redundancyLevel) {
+    headers['swarm-redundancy-level'] = String(options.redundancyLevel);
+  }
+  return headers;
+}
+export function extractDownloadHeaders(options) {
+  const headers = {};
+  if (options?.redundancyStrategy) {
+    headers['swarm-redundancy-strategy'] = String(options.redundancyStrategy);
+  }
+  if (options?.fallback === false) {
+    headers['swarm-redundancy-fallback-mode'] = 'false';
+  }
+  if (options?.timeoutMs !== undefined) {
+    headers['swarm-chunk-retrieval-timeout'] = String(options.timeoutMs);
+  }
   return headers;
 }

package/dist/mjs/utils/redundancy.js

@@ -0,0 +1,88 @@
+import { RedundancyLevel } from "../index.js";
+const mediumTable = [[94, 68, 46, 28, 14, 5, 1], [9, 8, 7, 6, 5, 4, 3]];
+const encMediumTable = [[47, 34, 23, 14, 7, 2], [9, 8, 7, 6, 5, 4]];
+const strongTable = [[104, 95, 86, 77, 69, 61, 53, 46, 39, 32, 26, 20, 15, 10, 6, 3, 1], [21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5]];
+const encStrongTable = [[52, 47, 43, 38, 34, 30, 26, 23, 19, 16, 13, 10, 7, 5, 3, 1], [21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6]];
+const insaneTable = [[92, 87, 82, 77, 73, 68, 63, 59, 54, 50, 45, 41, 37, 33, 29, 26, 22, 19, 16, 13, 10, 8, 5, 3, 2, 1], [31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6]];
+const encInsaneTable = [[46, 43, 41, 38, 36, 34, 31, 29, 27, 25, 22, 20, 18, 16, 14, 13, 11, 9, 8, 6, 5, 4, 2, 1], [31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 7]];
+const paranoidTable = [[37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [90, 88, 87, 85, 84, 82, 81, 79, 77, 76, 74, 72, 71, 69, 67, 66, 64, 62, 60, 59, 57, 55, 53, 51, 49, 48, 46, 44, 41, 39, 37, 35, 32, 30, 27, 24, 20]];
+const encParanoidTable = [[18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], [88, 85, 82, 79, 76, 72, 69, 66, 62, 59, 55, 51, 48, 44, 39, 35, 30, 24]];
+const tables = {
+  [RedundancyLevel.MEDIUM]: [mediumTable, encMediumTable],
+  [RedundancyLevel.STRONG]: [strongTable, encStrongTable],
+  [RedundancyLevel.INSANE]: [insaneTable, encInsaneTable],
+  [RedundancyLevel.PARANOID]: [paranoidTable, encParanoidTable]
+};
+/**
+ * Returns an approximate multiplier for the overhead of a given redundancy level.
+ * Redundancy level is a tradeoff between storage overhead and fault tolerance.
+ * Use this number to estimate the amount of chunks that will be stored for a given
+ * redundancy level.
+ */
+export function approximateOverheadForRedundancyLevel(chunks, level, encrypted) {
+  const tableType = level === RedundancyLevel.MEDIUM ? tables[RedundancyLevel.MEDIUM] : level === RedundancyLevel.STRONG ? tables[RedundancyLevel.STRONG] : level === RedundancyLevel.INSANE ? tables[RedundancyLevel.INSANE] : tables[RedundancyLevel.PARANOID];
+  const table = encrypted ? tableType[1] : tableType[0];
+  const [supportedChunks, parities] = table;
+  for (let i = 0; i < supportedChunks.length; i++) {
+    if (chunks >= supportedChunks[i]) {
+      return parities[i] / supportedChunks[i];
+    }
+  }
+  return parities[parities.length - 1] / supportedChunks[supportedChunks.length - 1];
+}
+const medium = {
+  label: 'medium',
+  value: RedundancyLevel.MEDIUM,
+  errorTolerance: 0.01
+};
+const strong = {
+  label: 'strong',
+  value: RedundancyLevel.STRONG,
+  errorTolerance: 0.05
+};
+const insane = {
+  label: 'insane',
+  value: RedundancyLevel.INSANE,
+  errorTolerance: 0.1
+};
+const paranoid = {
+  label: 'paranoid',
+  value: RedundancyLevel.PARANOID,
+  errorTolerance: 0.5
+};
+export function getRedundancyStats() {
+  return {
+    medium,
+    strong,
+    insane,
+    paranoid
+  };
+}
+export function getRedundancyStat(level) {
+  if (typeof level === 'string') {
+    switch (level.toLowerCase()) {
+      case 'medium':
+        return medium;
+      case 'strong':
+        return strong;
+      case 'insane':
+        return insane;
+      case 'paranoid':
+        return paranoid;
+      default:
+        throw new Error(`Unknown redundancy level '${level}'`);
+    }
+  }
+  switch (level) {
+    case RedundancyLevel.MEDIUM:
+      return medium;
+    case RedundancyLevel.STRONG:
+      return strong;
+    case RedundancyLevel.INSANE:
+      return insane;
+    case RedundancyLevel.PARANOID:
+      return paranoid;
+    default:
+      throw new Error(`Unknown redundancy level '${level}'`);
+  }
+}

package/dist/types/bee.d.ts

@@ -1,6 +1,6 @@
 import { Index, IndexBytes } from './feed';
 import { FeedType } from './feed/type';
-import type { AddressPrefix, AnyJson, BatchId, BeeOptions, BeeRequestOptions, CollectionUploadOptions, Data, FeedReader, FeedWriter, FileData, FileUploadOptions, JsonFeedOptions, Pin, PssMessageHandler, PssSubscription, PublicKey, Reference, SOCReader, SOCWriter, Signer, Tag, Topic, UploadOptions, UploadResultWithCid } from './types';
+import type { AddressPrefix, AnyJson, BatchId, BeeOptions, BeeRequestOptions, CollectionUploadOptions, Data, FeedReader, FeedWriter, FileData, FileUploadOptions, JsonFeedOptions, Pin, PssMessageHandler, PssSubscription, PublicKey, Reference, SOCReader, SOCWriter, Signer, Tag, Topic, UploadOptions, UploadRedundancyOptions, UploadResultWithCid } from './types';
 import { AllTagsOptions, Collection, FeedManifestResult, Readable, ReferenceCidOrEns, ReferenceOrEns, UploadResult } from './types';
 import { EthAddress } from './utils/eth';
 /**
@@ -39,7 +39,7 @@ export declare class Bee {
      * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
      * @see [Bee API reference - `POST /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes/post)
      */
-    uploadData(postageBatchId: string | BatchId, data: string | Uint8Array, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+    uploadData(postageBatchId: string | BatchId, data: string | Uint8Array, options?: UploadOptions & UploadRedundancyOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
     /**
      * Download data as a byte array
      *
@@ -101,7 +101,7 @@ export declare class Bee {
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/File/paths/~1bzz/post)
      * @returns reference is a content hash of the file
      */
-    uploadFile(postageBatchId: string | BatchId, data: string | Uint8Array | Readable | File, name?: string, options?: FileUploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
+    uploadFile(postageBatchId: string | BatchId, data: string | Uint8Array | Readable | File, name?: string, options?: FileUploadOptions & UploadRedundancyOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
     /**
      * Download single file.
      *
@@ -144,7 +144,7 @@ export declare class Bee {
      * @see [Bee docs - Upload directory](https://docs.ethswarm.org/docs/access-the-swarm/upload-a-directory/)
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz/post)
      */
-    uploadFiles(postageBatchId: string | BatchId, fileList: FileList | File[], options?: CollectionUploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
+    uploadFiles(postageBatchId: string | BatchId, fileList: FileList | File[], options?: CollectionUploadOptions & UploadRedundancyOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
     /**
      * Upload Collection that you can assembly yourself.
      *
@@ -155,7 +155,7 @@ export declare class Bee {
      * @param collection
      * @param options Collections and request options
      */
-    uploadCollection(postageBatchId: string | BatchId, collection: Collection<Uint8Array | Readable>, options?: CollectionUploadOptions): Promise<UploadResultWithCid>;
+    uploadCollection(postageBatchId: string | BatchId, collection: Collection<Uint8Array | Readable>, options?: CollectionUploadOptions & UploadRedundancyOptions): Promise<UploadResultWithCid>;
     /**
      * Upload collection of files.
      *
@@ -172,7 +172,7 @@ export declare class Bee {
      * @see [Bee docs - Upload directory](https://docs.ethswarm.org/docs/access-the-swarm/upload-a-directory/)
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz/post)
      */
-    uploadFilesFromDirectory(postageBatchId: string | BatchId, dir: string, options?: CollectionUploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
+    uploadFilesFromDirectory(postageBatchId: string | BatchId, dir: string, options?: CollectionUploadOptions & UploadRedundancyOptions, requestOptions?: BeeRequestOptions): Promise<UploadResultWithCid>;
     /**
      * Create a new Tag which is meant for tracking progres of syncing data across network.
      *

package/dist/types/modules/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { BatchId, BeeRequestOptions, Data, ReferenceOrEns, UploadOptions } from '../types';
+import type { BatchId, BeeRequestOptions, Data, DownloadRedundancyOptions, ReferenceOrEns, UploadOptions, UploadRedundancyOptions } from '../types';
 import { UploadResult } from '../types';
 /**
  * Upload data to a Bee node
@@ -8,18 +8,18 @@ import { UploadResult } from '../types';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
-export declare function upload(requestOptions: BeeRequestOptions, data: string | Uint8Array, postageBatchId: BatchId, options?: UploadOptions): Promise<UploadResult>;
+export declare function upload(requestOptions: BeeRequestOptions, data: string | Uint8Array, postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
 /**
  * Download data as a byte array
  *
  * @param ky
  * @param hash Bee content reference
  */
-export declare function download(requestOptions: BeeRequestOptions, hash: ReferenceOrEns): Promise<Data>;
+export declare function download(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, options?: DownloadRedundancyOptions): Promise<Data>;
 /**
  * Download data as a readable stream
  *
  * @param ky
  * @param hash Bee content reference
  */
-export declare function downloadReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns): Promise<ReadableStream<Uint8Array>>;
+export declare function downloadReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, options?: DownloadRedundancyOptions): Promise<ReadableStream<Uint8Array>>;

package/dist/types/modules/bzz.d.ts

@@ -1,4 +1,4 @@
-import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Readable, ReferenceOrEns, UploadResult } from '../types';
+import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Data, DownloadRedundancyOptions, FileData, FileUploadOptions, Readable, ReferenceOrEns, UploadRedundancyOptions, UploadResult } from '../types';
 /**
  * Upload single file
  *
@@ -8,7 +8,7 @@ import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Data,
  * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
  * @param options
  */
-export declare function uploadFile(requestOptions: BeeRequestOptions, data: string | Uint8Array | Readable | ArrayBuffer, postageBatchId: BatchId, name?: string, options?: FileUploadOptions): Promise<UploadResult>;
+export declare function uploadFile(requestOptions: BeeRequestOptions, data: string | Uint8Array | Readable | ArrayBuffer, postageBatchId: BatchId, name?: string, options?: FileUploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
 /**
  * Download single file as a buffer
  *
@@ -16,7 +16,7 @@ export declare function uploadFile(requestOptions: BeeRequestOptions, data: stri
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFile(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string): Promise<FileData<Data>>;
+export declare function downloadFile(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string, options?: DownloadRedundancyOptions): Promise<FileData<Data>>;
 /**
  * Download single file as a readable stream
  *
@@ -24,7 +24,7 @@ export declare function downloadFile(requestOptions: BeeRequestOptions, hash: Re
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export declare function downloadFileReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string): Promise<FileData<ReadableStream<Uint8Array>>>;
+export declare function downloadFileReadable(requestOptions: BeeRequestOptions, hash: ReferenceOrEns, path?: string, options?: DownloadRedundancyOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
 /**
  * Upload collection
  * @param kyOptions Ky Options for making requests
@@ -32,4 +32,4 @@ export declare function downloadFileReadable(requestOptions: BeeRequestOptions,
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options
  */
-export declare function uploadCollection(requestOptions: BeeRequestOptions, collection: Collection<Uint8Array>, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<UploadResult>;
+export declare function uploadCollection(requestOptions: BeeRequestOptions, collection: Collection<Uint8Array>, postageBatchId: BatchId, options?: CollectionUploadOptions & UploadRedundancyOptions): Promise<UploadResult>;

package/dist/types/types/index.d.ts

@@ -148,6 +148,50 @@ export interface UploadOptions {
      */
     deferred?: boolean;
 }
+/**
+ * Add redundancy to the data being uploaded so that downloaders can download it with better UX.
+ * 0 value is default and does not add any redundancy to the file.
+ */
+export declare enum RedundancyLevel {
+    OFF = 0,
+    MEDIUM = 1,
+    STRONG = 2,
+    INSANE = 3,
+    PARANOID = 4
+}
+export interface UploadRedundancyOptions {
+    redundancyLevel?: RedundancyLevel;
+}
+/**
+ * Specify the retrieve strategy on redundant data.
+ * The possible values are NONE, DATA, PROX and RACE.
+ * Strategy NONE means no prefetching takes place.
+ * Strategy DATA means only data chunks are prefetched.
+ * Strategy PROX means only chunks that are close to the node are prefetched.
+ * Strategy RACE means all chunks are prefetched: n data chunks and k parity chunks. The first n chunks to arrive are used to reconstruct the file.
+ * Multiple strategies can be used in a fallback cascade if the swarm redundancy fallback mode is set to true.
+ * The default strategy is NONE, DATA, falling back to PROX, falling back to RACE
+ */
+export declare enum RedundancyStrategy {
+    NONE = 0,
+    DATA = 1,
+    PROX = 2,
+    RACE = 3
+}
+export interface DownloadRedundancyOptions {
+    /**
+     * Specify the retrieve strategy on redundant data.
+     */
+    redundancyStrategy?: RedundancyStrategy;
+    /**
+     * Specify if the retrieve strategies (chunk prefetching on redundant data) are used in a fallback cascade. The default is true.
+     */
+    fallback?: boolean;
+    /**
+     * Specify the timeout for chunk retrieval. The default is 30 seconds.
+     */
+    timeoutMs?: number;
+}
 export interface FileUploadOptions extends UploadOptions {
     /**
      * Specifies Content-Length for the given data. It is required when uploading with Readable.

package/dist/types/utils/expose.d.ts

@@ -6,4 +6,5 @@ export { EthAddress, ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeE
 export { isNodeReadable, isReadable, isReadableStream, normalizeToReadableStream, readableNodeToWeb, readableWebToNode, } from './stream';
 export { keccak256Hash } from './hash';
 export { makeMaxTarget } from './pss';
-export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampMaximumCapacityBytes, getStampEffectiveBytes, getStampTtlSeconds, getStampUsage, } from './stamps';
+export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage, } from './stamps';
+export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from './redundancy';

package/dist/types/utils/headers.d.ts

@@ -1,3 +1,5 @@
-import { BatchId, FileHeaders, UploadOptions } from '../types';
+import { BatchId, DownloadRedundancyOptions, FileHeaders, UploadOptions, UploadRedundancyOptions } from '../types';
 export declare function readFileHeaders(headers: Record<string, string>): FileHeaders;
 export declare function extractUploadHeaders(postageBatchId: BatchId, options?: UploadOptions): Record<string, string>;
+export declare function extractRedundantUploadHeaders(postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Record<string, string>;
+export declare function extractDownloadHeaders(options?: DownloadRedundancyOptions): Record<string, string>;

package/dist/types/utils/redundancy.d.ts

@@ -0,0 +1,21 @@
+import { RedundancyLevel } from '..';
+/**
+ * Returns an approximate multiplier for the overhead of a given redundancy level.
+ * Redundancy level is a tradeoff between storage overhead and fault tolerance.
+ * Use this number to estimate the amount of chunks that will be stored for a given
+ * redundancy level.
+ */
+export declare function approximateOverheadForRedundancyLevel(chunks: number, level: RedundancyLevel, encrypted: boolean): number;
+interface RedundancyStats {
+    label: string;
+    value: RedundancyLevel;
+    errorTolerance: number;
+}
+export declare function getRedundancyStats(): {
+    medium: RedundancyStats;
+    strong: RedundancyStats;
+    insane: RedundancyStats;
+    paranoid: RedundancyStats;
+};
+export declare function getRedundancyStat(level?: string | RedundancyLevel): RedundancyStats;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethersphere/bee-js",
-  "version": "6.8.0",
+  "version": "6.9.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",
@@ -27,7 +27,8 @@
   "exports": {
     ".": {
       "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
     }
   },
   "types": "dist/types/index.d.ts",