@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/mjs/utils/headers.js

@@ -1,13 +1,17 @@
-import { Binary } from 'cafe-utility';
+import { Types } from 'cafe-utility';
 import { BeeError } from "./error.js";
-/**
- * Read the filename from the content-disposition header
- * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
- *
- * @param header the content-disposition header value
- *
- * @returns the filename
- */
+import { convertEnvelopeToMarshaledStamp } from "./stamps.js";
+import { BatchId, PublicKey, Reference } from "./typed-bytes.js";
+export function readFileHeaders(headers) {
+  const name = readContentDispositionFilename(headers['content-disposition']);
+  const tagUid = readTagUid(headers['swarm-tag-uid']);
+  const contentType = headers['content-type'] || undefined;
+  return {
+    name,
+    tagUid,
+    contentType
+  };
+}
 function readContentDispositionFilename(header) {
   if (!header) {
     throw new BeeError('missing content-disposition header');
@@ -26,60 +30,81 @@ function readTagUid(header) {
   }
   return parseInt(header, 10);
 }
-export function readFileHeaders(headers) {
-  const name = readContentDispositionFilename(headers['content-disposition']);
-  const tagUid = readTagUid(headers['swarm-tag-uid']);
-  const contentType = headers['content-type'] || undefined;
-  return {
-    name,
-    tagUid,
-    contentType
-  };
-}
-export function extractUploadHeaders(stamp, options) {
-  if (!stamp) {
-    throw new BeeError('Stamp has to be specified!');
-  }
+export function prepareRequestHeaders(stamp, nullableOptions) {
   const headers = {};
-  if (stamp instanceof Uint8Array) {
-    headers['swarm-postage-stamp'] = Binary.uint8ArrayToHex(stamp);
-  } else {
-    headers['swarm-postage-batch-id'] = stamp;
+  if (isEnvelopeWithBatchId(stamp)) {
+    headers['swarm-postage-stamp'] = convertEnvelopeToMarshaledStamp(stamp).toHex();
+  } else if (stamp) {
+    stamp = new BatchId(stamp);
+    headers['swarm-postage-batch-id'] = stamp.toHex();
+  }
+  if (!nullableOptions) {
+    return headers;
   }
-  if (options?.act) {
+  const options = Types.asObject(nullableOptions);
+  if (options.size) {
+    headers['content-length'] = String(options.size);
+  }
+  if (options.contentType) {
+    headers['content-type'] = String(options.contentType);
+  }
+  if (options.redundancyLevel) {
+    headers['swarm-redundancy-level'] = String(options.redundancyLevel);
+  }
+  if (Types.isBoolean(options.act)) {
     headers['swarm-act'] = String(options.act);
   }
-  if (options?.pin) {
+  if (Types.isBoolean(options.pin)) {
     headers['swarm-pin'] = String(options.pin);
   }
-  if (options?.encrypt) {
-    headers['swarm-encrypt'] = String(options.encrypt);
+  if (Types.isBoolean(options.encrypt)) {
+    headers['swarm-encrypt'] = options.encrypt.toString();
   }
-  if (options?.tag) {
+  if (options.tag) {
     headers['swarm-tag'] = String(options.tag);
   }
-  if (typeof options?.deferred === 'boolean') {
+  if (Types.isBoolean(options.deferred)) {
     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) {
+  if (options.redundancyStrategy) {
     headers['swarm-redundancy-strategy'] = String(options.redundancyStrategy);
   }
-  if (options?.fallback === false) {
-    headers['swarm-redundancy-fallback-mode'] = 'false';
+  if (Types.isBoolean(options.fallback)) {
+    headers['swarm-redundancy-fallback-mode'] = options.fallback.toString();
   }
-  if (options?.timeoutMs !== undefined) {
+  if (options.timeoutMs) {
     headers['swarm-chunk-retrieval-timeout'] = String(options.timeoutMs);
   }
+  if (options.indexDocument) {
+    headers['swarm-index-document'] = String(options.indexDocument);
+  }
+  if (options.errorDocument) {
+    headers['swarm-error-document'] = String(options.errorDocument);
+  }
+  if (options.actPublisher) {
+    headers['swarm-act-publisher'] = new PublicKey(options.actPublisher).toCompressedHex();
+  }
+  if (options.actHistoryAddress) {
+    headers['swarm-act-history-address'] = new Reference(options.actHistoryAddress).toHex();
+  }
+  if (options.actTimestamp) {
+    headers['swarm-act-timestamp'] = String(options.actTimestamp);
+  }
+  if (options.actPublisher || options.actHistoryAddress || options.actTimestamp) {
+    headers['swarm-act'] = 'true';
+  }
+  if (options.gasPrice) {
+    headers['gas-price'] = String(options.gasPrice);
+  }
+  if (options.gasLimit) {
+    headers['gas-limit'] = String(options.gasLimit);
+  }
   return headers;
+}
+function isEnvelopeWithBatchId(value) {
+  if (!Types.isObject(value)) {
+    return false;
+  }
+  const envelope = value;
+  return envelope.issuer !== undefined && envelope.index !== undefined && envelope.signature !== undefined && envelope.timestamp !== undefined && envelope.batchId !== undefined;
 }

package/dist/mjs/utils/http.js

@@ -1,9 +1,13 @@
 import axios from 'axios';
-import { Objects, Strings } from 'cafe-utility';
+import { Dates, Objects, Strings, System } from 'cafe-utility';
 import { BeeResponseError } from "../index.js";
 const {
   AxiosError
 } = axios;
+const MAX_FAILED_ATTEMPTS = 100000;
+const DELAY_FAST = 200;
+const DELAY_SLOW = 1000;
+const DELAY_THRESHOLD = Dates.minutes(1) / DELAY_FAST;
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
@@ -17,18 +21,36 @@ export const DEFAULT_HTTP_CONFIG = {
  * @param config Internal settings and/or Bee settings
  */
 export async function http(options, config) {
-  try {
-    const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
-    maybeRunOnRequestHook(options, requestConfig);
-    const response = await axios(requestConfig);
-    // TODO: https://github.com/axios/axios/pull/6253
-    return response;
-  } catch (e) {
-    if (e instanceof AxiosError) {
-      throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.code);
+  const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
+  if (requestConfig.params) {
+    const keys = Object.keys(requestConfig.params);
+    for (const key of keys) {
+      const value = requestConfig.params[key];
+      if (value === undefined) {
+        delete requestConfig.params[key];
+      }
     }
-    throw e;
   }
+  let failedAttempts = 0;
+  while (failedAttempts < MAX_FAILED_ATTEMPTS) {
+    try {
+      maybeRunOnRequestHook(options, requestConfig);
+      const response = await axios(requestConfig);
+      return response;
+    } catch (e) {
+      if (e instanceof AxiosError) {
+        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);
+        }
+      } else {
+        throw e;
+      }
+    }
+  }
+  throw Error('Max number of failed attempts reached');
 }
 function maybeRunOnRequestHook(options, requestConfig) {
   if (options.onRequest) {

package/dist/mjs/utils/mime.js

@@ -0,0 +1,75 @@
+export const mimes = {
+  aac: 'audio/aac',
+  abw: 'application/x-abiword',
+  ai: 'application/postscript',
+  arc: 'application/octet-stream',
+  avi: 'video/x-msvideo',
+  azw: 'application/vnd.amazon.ebook',
+  bin: 'application/octet-stream',
+  bz: 'application/x-bzip',
+  bz2: 'application/x-bzip2',
+  csh: 'application/x-csh',
+  css: 'text/css',
+  csv: 'text/csv',
+  doc: 'application/msword',
+  dll: 'application/octet-stream',
+  dmg: 'application/x-apple-diskimage',
+  eot: 'application/vnd.ms-fontobject',
+  epub: 'application/epub+zip',
+  gif: 'image/gif',
+  htm: 'text/html',
+  html: 'text/html',
+  ico: 'image/x-icon',
+  ics: 'text/calendar',
+  jar: 'application/java-archive',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  js: 'application/javascript',
+  json: 'application/json',
+  mid: 'audio/midi',
+  midi: 'audio/midi',
+  mp2: 'audio/mpeg',
+  mp3: 'audio/mpeg',
+  mp4: 'video/mp4',
+  mpa: 'video/mpeg',
+  mpe: 'video/mpeg',
+  mpeg: 'video/mpeg',
+  mpkg: 'application/vnd.apple.installer+xml',
+  odp: 'application/vnd.oasis.opendocument.presentation',
+  ods: 'application/vnd.oasis.opendocument.spreadsheet',
+  odt: 'application/vnd.oasis.opendocument.text',
+  oga: 'audio/ogg',
+  ogv: 'video/ogg',
+  ogx: 'application/ogg',
+  otf: 'font/otf',
+  png: 'image/png',
+  pdf: 'application/pdf',
+  ppt: 'application/vnd.ms-powerpoint',
+  rar: 'application/x-rar-compressed',
+  rtf: 'application/rtf',
+  sh: 'application/x-sh',
+  svg: 'image/svg+xml',
+  swf: 'application/x-shockwave-flash',
+  tar: 'application/x-tar',
+  tif: 'image/tiff',
+  tiff: 'image/tiff',
+  ts: 'application/typescript',
+  ttf: 'font/ttf',
+  txt: 'text/plain',
+  vsd: 'application/vnd.visio',
+  wav: 'audio/x-wav',
+  weba: 'audio/webm',
+  webm: 'video/webm',
+  webp: 'image/webp',
+  woff: 'font/woff',
+  woff2: 'font/woff2',
+  xhtml: 'application/xhtml+xml',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.ms-excel',
+  xml: 'application/xml',
+  xul: 'application/vnd.mozilla.xul+xml',
+  zip: 'application/zip',
+  '3gp': 'video/3gpp',
+  '3gp2': 'video/3gpp2',
+  '7z': 'application/x-7z-compressed'
+};

package/dist/mjs/utils/pss.js

@@ -1,4 +1,5 @@
 import { PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
+import { PeerAddress } from "./typed-bytes.js";
 /**
  * Utility function that for given strings/reference takes the most specific
  * target that Bee node will except.
@@ -7,8 +8,6 @@ import { PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
  * @see [Bee docs - PSS](https://docs.ethswarm.org/docs/develop/tools-and-features/pss)
  */
 export function makeMaxTarget(target) {
-  if (typeof target !== 'string') {
-    throw new TypeError('target has to be an string!');
-  }
-  return target.slice(0, PSS_TARGET_HEX_LENGTH_MAX);
+  target = new PeerAddress(target);
+  return target.toHex().slice(0, PSS_TARGET_HEX_LENGTH_MAX);
 }

package/dist/mjs/utils/redundancy.js

@@ -7,12 +7,6 @@ const insaneTable = [[92, 87, 82, 77, 73, 68, 63, 59, 54, 50, 45, 41, 37, 33, 29
 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.
@@ -20,8 +14,10 @@ const tables = {
  * 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];
+  if (level === RedundancyLevel.OFF) {
+    return 0;
+  }
+  const table = selectTable(level, encrypted);
   const [supportedChunks, parities] = table;
   for (let i = 0; i < supportedChunks.length; i++) {
     if (chunks >= supportedChunks[i]) {
@@ -30,6 +26,20 @@ export function approximateOverheadForRedundancyLevel(chunks, level, encrypted)
   }
   return parities[parities.length - 1] / supportedChunks[supportedChunks.length - 1];
 }
+function selectTable(level, encrypted) {
+  switch (level) {
+    case RedundancyLevel.MEDIUM:
+      return encrypted ? encMediumTable : mediumTable;
+    case RedundancyLevel.STRONG:
+      return encrypted ? encStrongTable : strongTable;
+    case RedundancyLevel.INSANE:
+      return encrypted ? encInsaneTable : insaneTable;
+    case RedundancyLevel.PARANOID:
+      return encrypted ? encParanoidTable : paranoidTable;
+    default:
+      throw new Error(`Unknown redundancy level ${level}`);
+  }
+}
 const medium = {
   label: 'medium',
   value: RedundancyLevel.MEDIUM,

package/dist/mjs/utils/resource-locator.js

@@ -0,0 +1,13 @@
+import { Types } from 'cafe-utility';
+import { Reference } from "./typed-bytes.js";
+export class ResourceLocator {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  toString() {
+    if (Types.isString(this.raw) && this.raw.includes('.eth')) {
+      return this.raw;
+    }
+    return new Reference(this.raw).toHex();
+  }
+}

package/dist/mjs/utils/size.js

@@ -0,0 +1,31 @@
+import { Numbers } from 'cafe-utility';
+/**
+ * Represents a size in bytes.
+ *
+ * Uses 1000 instead of 1024 for converting between units.
+ * This is to stay consistent with the Swarm papers
+ * on theoretical and effective storage capacity.
+ */
+export class Size {
+  constructor(bytes) {
+    this.bytes = Math.ceil(bytes);
+    if (bytes < 0) {
+      throw Error('Size must be at least 0');
+    }
+  }
+  static fromBytes(bytes) {
+    return new Size(bytes);
+  }
+  static fromGigabytes(gigabytes) {
+    return new Size(gigabytes * 1000 * 1000 * 1000);
+  }
+  toBytes() {
+    return this.bytes;
+  }
+  toGigabytes() {
+    return this.bytes / 1000 / 1000 / 1000;
+  }
+  toFormattedString() {
+    return Numbers.convertBytes(this.bytes, 1000);
+  }
+}

package/dist/mjs/utils/stamps.js

@@ -1,4 +1,8 @@
 import { Binary } from 'cafe-utility';
+import { Bytes } from "./bytes.js";
+import { Duration } from "./duration.js";
+import { BZZ } from "./tokens.js";
+import { asNumberString } from "./type.js";
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
  *
@@ -10,14 +14,14 @@ export function getStampUsage(utilization, depth, bucketDepth) {
   return utilization / Math.pow(2, depth - bucketDepth);
 }
 /**
- * Utility function that calculates the theoritical maximum capacity of a postage batch based on its depth.
+ * Utility function that calculates the theoritical maximum size of a postage batch based on its depth.
  *
- * For smaller depths (up to 20), this may provide less accurate results.
+ * For smaller depths (up to 22), this may provide less accurate results.
  *
- * @returns {number} The maximum capacity of the postage batch in bytes.
+ * @returns {number} The maximum theoretical size of the postage batch in bytes.
  */
-export function getStampMaximumCapacityBytes(depth) {
-  return 2 ** depth * 4096;
+export function getStampTheoreticalBytes(depth) {
+  return 4096 * 2 ** depth;
 }
 /**
  * Based on https://docs.ethswarm.org/docs/learn/technology/contracts/postage-stamp/#effective-utilisation-table
@@ -37,79 +41,78 @@ const utilisationRateMap = {
   33: 0.9842,
   34: 0.9889
 };
+const effectiveSizeBreakpoints = [[22, 4.93], [23, 17.03], [24, 44.21], [25, 102.78], [26, 225.87], [27, 480.44], [28, 1001.44], [29, 2060.27], [30, 4201.9], [31, 8519.02], [32, 17199.89], [33, 34628.46]];
 /**
- * Utility function that calculates the effective volume of a postage batch based on its depth.
+ * Utility function that calculates the effective size of a postage batch based on its depth.
  *
- * Below 22 depth the effective volume is 0
+ * Below 22 depth the effective size is 0
  * Above 34 it's always > 99%
  *
- * @returns {number} The effective volume of the postage batch in bytes.
+ * @returns {number} The effective size of the postage batch in bytes.
  */
 export function getStampEffectiveBytes(depth) {
   if (depth < 22) {
     return 0;
   }
   const utilRate = utilisationRateMap[depth] ?? 0.99;
-  return getStampMaximumCapacityBytes(depth) * utilRate;
+  return Math.ceil(getStampTheoreticalBytes(depth) * utilRate);
 }
-/**
- * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in PLUR (10000000000000000 [1e16] PLUR = 1 BZZ)
- */
-export function getStampCostInPlur(depth, amount) {
-  return 2 ** depth * amount;
+export function getStampEffectiveBytesBreakpoints() {
+  const map = new Map();
+  for (let i = 22; i < 35; i++) {
+    map.set(i, getStampEffectiveBytes(i));
+  }
+  return map;
 }
 /**
  * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in BZZ (1 BZZ = 10000000000000000 [1e16] PLUR)
  */
-export function getStampCostInBzz(depth, amount) {
-  const BZZ_UNIT = 10 ** 16;
-  return getStampCostInPlur(depth, amount) / BZZ_UNIT;
+export function getStampCost(depth, amount) {
+  return BZZ.fromPLUR(2n ** BigInt(depth) * BigInt(amount));
 }
 /**
  * Utility function that calculates the TTL of a postage batch based on its amount, price per block and block time.
  *
  * For more accurate results, get the price per block and block time from the Bee node or the blockchain.
  *
- * @returns {number} The TTL of the postage batch in seconds.
+ * @returns {number} The TTL of the postage batch.
  */
-export function getStampTtlSeconds(amount, pricePerBlock = 24000, blockTime = 5) {
-  return amount * blockTime / pricePerBlock;
+export function getStampDuration(amount, pricePerBlock, blockTime = 5) {
+  const amountBigInt = BigInt(asNumberString(amount));
+  return Duration.fromSeconds(Number(amountBigInt * BigInt(blockTime) / BigInt(pricePerBlock)));
 }
 /**
- * Utility function that calculates the amount of tokens required to maintain a given Time To Live (TTL) for a postage batch.
- *
- * This function estimates the required amount based on the provided TTL in days.
+ * Get the postage batch `amount` required for a given `duration`.
  *
- * @param {number} days - The Time To Live (TTL) in days.
- * @returns {NumberString} The estimated amount of tokens needed for the specified TTL.
+ * @param duration A duration object representing the duration of the storage.
+ * @param pricePerBlock The price per block in PLUR.
+ * @param blockTime The block time in seconds.
  */
-export function getAmountForTtl(days) {
-  // 414720000 = (24 * 60 * 60 * 24_000) / 5
-  return ((days <= 0 ? 1 : days) * 414720000).toString();
+export function getAmountForDuration(duration, pricePerBlock, blockTime = 5) {
+  return BigInt(duration.toSeconds()) / BigInt(blockTime) * BigInt(pricePerBlock);
 }
 /**
- * Utility function that calculates the depth required for a postage batch to achieve the specified capacity in gigabytes.
+ * Utility function that calculates the depth required for a postage batch to achieve the specified effective size
  *
- * The depth is determined based on the given gigabytes, and the result is adjusted to a minimum depth of 18.
- *
- * @param {number} gigabytes - The desired capacity of the postage batch in gigabytes.
- * @returns {number} The calculated depth necessary to achieve the specified capacity.
+ * @param size The effective size of the postage batch
+ * @returns
  */
-export function getDepthForCapacity(gigabytes) {
-  return gigabytes <= 1 ? 18 : Math.ceil(Math.log2(Math.ceil(gigabytes)) + 18);
+export function getDepthForSize(size) {
+  for (const [depth, sizeBreakpoint] of effectiveSizeBreakpoints) {
+    if (size.toGigabytes() <= sizeBreakpoint) {
+      return depth;
+    }
+  }
+  return 34;
 }
-export function convertEnvelopeToMarshaledStamp(batchID, envelope) {
-  return marshalStamp(envelope.signature, Binary.hexToUint8Array(batchID), envelope.timestamp, envelope.index);
+export function convertEnvelopeToMarshaledStamp(envelope) {
+  return marshalStamp(envelope.signature, envelope.batchId.toUint8Array(), envelope.timestamp, envelope.index);
 }
-export function marshalStamp(signature, batchID, timestamp, index) {
+export function marshalStamp(signature, batchId, timestamp, index) {
   if (signature.length !== 65) {
     throw Error('invalid signature length');
   }
-  if (batchID.length !== 32) {
+  if (batchId.length !== 32) {
     throw Error('invalid batch ID length');
   }
   if (timestamp.length !== 8) {
@@ -118,5 +121,5 @@ export function marshalStamp(signature, batchID, timestamp, index) {
   if (index.length !== 8) {
     throw Error('invalid index length');
   }
-  return Binary.concatBytes(batchID, index, timestamp, signature);
+  return new Bytes(Binary.concatBytes(batchId, index, timestamp, signature));
 }

package/dist/mjs/utils/tar-uploader.browser.js

@@ -1,4 +1,4 @@
-import { extractCollectionUploadHeaders } from "../modules/bzz.js";
+import { prepareRequestHeaders } from "./headers.js";
 import { http } from "./http.js";
 import { TarStream } from "./tar.js";
 import { writeTar } from "./tar-writer.js";
@@ -15,7 +15,7 @@ export async function uploadTar(requestOptions, collection, postageBatchId, opti
     headers: {
       'content-type': 'application/x-tar',
       'swarm-collection': 'true',
-      ...extractCollectionUploadHeaders(postageBatchId, options)
+      ...prepareRequestHeaders(postageBatchId, options)
     }
   });
   return response;

package/dist/mjs/utils/tar-uploader.js

@@ -1,4 +1,4 @@
-import { extractCollectionUploadHeaders } from "../modules/bzz.js";
+import { prepareRequestHeaders } from "./headers.js";
 import { http } from "./http.js";
 import { TarStream } from "./tar.js";
 import { writeTar } from "./tar-writer.js";
@@ -13,7 +13,7 @@ export async function uploadTar(requestOptions, collection, postageBatchId, opti
     headers: {
       'content-type': 'application/x-tar',
       'swarm-collection': 'true',
-      ...extractCollectionUploadHeaders(postageBatchId, options)
+      ...prepareRequestHeaders(postageBatchId, options)
     }
   });
   await writeTar(collection, tarStream);