@ethersphere/bee-js 6.9.1 → 7.0.0

package/dist/mjs/modules/pss.js

@@ -5,7 +5,7 @@ const endpoint = 'pss';
 /**
  * Send to recipient or target with Postal Service for Swarm
  *
- * @param kyOptions Ky Options for making requests
+ * @param requestOptions Options for making requests
  * @param topic Topic name
  * @param target Target message address prefix
  * @param data

package/dist/mjs/modules/soc.js

@@ -4,7 +4,7 @@ const socEndpoint = 'soc';
 /**
  * Upload single owner chunk (SOC) to a Bee node
  *
- * @param ky Ky instance
+ * @param requestOptions  Options for making requests
  * @param owner           Owner's ethereum address in hex
  * @param identifier      Arbitrary identifier in hex
  * @param signature       Signature in hex

package/dist/mjs/modules/status.js

@@ -2,7 +2,7 @@ import { http } from "../utils/http.js";
 /**
  * Ping the base bee URL. If connection was not successful throw error
  *
- * @param kyOptions Ky instance for given Bee class instance
+ * @param requestOptions Options for making requests
  */
 export async function checkConnection(requestOptions) {
   await http(requestOptions, {

package/dist/mjs/modules/stewardship.js

@@ -2,7 +2,7 @@ import { http } from "../utils/http.js";
 const stewardshipEndpoint = 'stewardship';
 /**
  * Reupload locally pinned data
- * @param ky Ky instance
+ * @param requestOptions Options for making requests
  * @param reference
  * @param options
  * @throws BeeResponseError if not locally pinned or invalid data

package/dist/mjs/package.json

@@ -2,7 +2,11 @@
     "type": "module",
     "browser": {
      "stream": false,
-      "./utils/data.js": "./utils/data.browser.js",
-      "./utils/collection.node.js": "./utils/collection.browser.js"
+     "fs": false,
+     "./utils/tar.js": "./utils/tar.browser.js",
+     "./utils/tar-writer.js": "./utils/tar-writer.browser.js",
+      "./utils/tar-uploader.js": "./utils/tar-uploader.browser.js",
+     "./utils/data.js": "./utils/data.browser.js",
+     "./utils/collection.node.js": "./utils/collection.browser.js"
     }
 }

package/dist/mjs/types/index.js

@@ -15,6 +15,10 @@ export const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
  * Minimal depth that can be used for creation of postage batch
  */
 export const STAMPS_DEPTH_MIN = 17;
+/**
+ * Minimal amount that can be used for creation of postage batch
+ */
+export const STAMPS_AMOUNT_MIN = 24000 * 24 * 60 * 12;
 /**
  * Maximal depth that can be used for creation of postage batch
  */

package/dist/mjs/utils/collection.js

@@ -1,11 +1,9 @@
 import { BeeArgumentError } from "./error.js";
-import { fileArrayBuffer } from "./file.js";
-import { isUint8Array } from "./type.js";
 export function isCollection(data) {
   if (!Array.isArray(data)) {
     return false;
   }
-  return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data));
+  return data.every(entry => typeof entry === 'object' && entry.path && entry.size);
 }
 export function assertCollection(data) {
   if (!isCollection(data)) {
@@ -22,17 +20,11 @@ function makeFilePath(file) {
   throw new TypeError('file is not valid File object');
 }
 export async function makeCollectionFromFileList(fileList) {
-  const collection = [];
-  for (let i = 0; i < fileList.length; i++) {
-    const file = fileList[i];
-    if (file) {
-      collection.push({
-        path: makeFilePath(file),
-        data: new Uint8Array(await fileArrayBuffer(file))
-      });
-    }
-  }
-  return collection;
+  return Array.from(fileList).map(file => ({
+    path: makeFilePath(file),
+    size: file.size,
+    file
+  }));
 }
 /**
  * Calculate cumulative size of files
@@ -41,12 +33,5 @@ export async function makeCollectionFromFileList(fileList) {
  * @returns size in bytes
  */
 export function getCollectionSize(fileList) {
-  let sum = 0;
-  for (let i = 0; i < fileList.length; i++) {
-    const file = fileList[i];
-    if (file) {
-      sum += file.size;
-    }
-  }
-  return sum;
+  return Array.from(fileList).reduce((sum, file) => sum + file.size, 0);
 }

package/dist/mjs/utils/collection.node.js

@@ -26,7 +26,8 @@ async function buildCollectionRelative(dir, relativePath) {
     if (entry.isFile()) {
       collection.push({
         path: entryPath,
-        data: new Uint8Array(await fs.promises.readFile(fullPath))
+        size: (await fs.promises.stat(fullPath)).size,
+        fsPath: fullPath
       });
     } else if (entry.isDirectory()) {
       collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];

package/dist/mjs/utils/data.browser.js

@@ -1,60 +1,3 @@
-import { isNodeReadable, isReadableStream } from "./stream.js";
-/**
- * Validates input and converts to Uint8Array
- *
- * @param data any string, ArrayBuffer or Uint8Array
- */
-export async function prepareData(data) {
-  if (typeof data === 'string') return new Blob([data], {
-    type: 'text/plain'
-  });
-  if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-    return new Blob([data], {
-      type: 'application/octet-stream'
-    });
-  }
-  if (data instanceof Blob) {
-    return data;
-  }
-  // Currently it is not possible to stream requests from browsers
-  // there are already first experiments on this field (Chromium)
-  // but till it is fully implemented across browsers-land we have to
-  // buffer the data before sending the requests.
-  if (isNodeReadable(data)) {
-    return new Promise(resolve => {
-      const buffers = [];
-      data.on('data', d => {
-        buffers.push(d);
-      });
-      data.on('end', () => {
-        resolve(new Blob(buffers, {
-          type: 'application/octet-stream'
-        }));
-      });
-    });
-  }
-  if (isReadableStream(data)) {
-    return new Promise(async resolve => {
-      const reader = data.getReader();
-      const buffers = [];
-      let done, value;
-      do {
-        ;
-        ({
-          done,
-          value
-        } = await reader.read());
-        if (!done) {
-          buffers.push(value);
-        }
-      } while (!done);
-      resolve(new Blob(buffers, {
-        type: 'application/octet-stream'
-      }));
-    });
-  }
-  throw new TypeError('unknown data type');
-}
 export async function prepareWebsocketData(data) {
   if (typeof data === 'string') return new TextEncoder().encode(data);
   if (data instanceof ArrayBuffer) return new Uint8Array(data);

package/dist/mjs/utils/error.js

@@ -10,13 +10,9 @@ export class BeeArgumentError extends BeeError {
   }
 }
 export class BeeResponseError extends BeeError {
-  constructor(message, code, axiosStatus, status, config, request, response) {
+  constructor(message, status, statusText) {
     super(message);
-    this.code = code;
-    this.axiosStatus = axiosStatus;
     this.status = status;
-    this.config = config;
-    this.request = request;
-    this.response = response;
+    this.statusText = statusText;
   }
 }

package/dist/mjs/utils/eth.js

@@ -4,8 +4,8 @@ const {
   keccak256,
   sha3_256
 } = pkg;
-import { hexToBytes, intToHex, makeHexString, assertHexString } from "./hex.js";
 import { assertBytes } from "./bytes.js";
+import { assertHexString, hexToBytes, intToHex, makeHexString } from "./hex.js";
 const ETH_ADDR_BYTES_LENGTH = 20;
 const ETH_ADDR_HEX_LENGTH = 40;
 export function makeEthAddress(address) {

package/dist/mjs/utils/expose.js

@@ -3,7 +3,6 @@ export { getFolderSize } from "./collection.node.js";
 export { assertBytes, assertFlexBytes, bytesAtOffset, bytesEqual, flexBytesAtOffset, isBytes, isFlexBytes } from "./bytes.js";
 export { assertHexString, assertPrefixedHexString, bytesToHex, hexToBytes, intToHex, isHexString, makeHexString } from "./hex.js";
 export { ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, makeEthereumWalletSigner, makeHexEthAddress, toLittleEndian } from "./eth.js";
-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, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage } from "./stamps.js";

package/dist/mjs/utils/http.js

@@ -1,6 +1,9 @@
-import axios, { AxiosError } from 'axios';
+import axios from 'axios';
 import { Objects, Strings } from 'cafe-utility';
 import { BeeResponseError } from "../index.js";
+const {
+  AxiosError
+} = axios;
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
@@ -22,7 +25,7 @@ export async function http(options, config) {
     return response;
   } catch (e) {
     if (e instanceof AxiosError) {
-      throw new BeeResponseError(e.message, e.code, e.status, e.response?.status, e.config, e.request, e.response);
+      throw new BeeResponseError(e.message, e.status, e.code);
     }
     throw e;
   }

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

@@ -0,0 +1,22 @@
+import { extractCollectionUploadHeaders } from "../modules/bzz.js";
+import { http } from "./http.js";
+import { TarStream } from "./tar.js";
+import { writeTar } from "./tar-writer.js";
+const bzzEndpoint = 'bzz';
+export async function uploadTar(requestOptions, collection, postageBatchId, options) {
+  const tarStream = new TarStream();
+  await writeTar(collection, tarStream);
+  await tarStream.end();
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: bzzEndpoint,
+    data: tarStream.output,
+    responseType: 'json',
+    headers: {
+      'content-type': 'application/x-tar',
+      'swarm-collection': 'true',
+      ...extractCollectionUploadHeaders(postageBatchId, options)
+    }
+  });
+  return response;
+}

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

@@ -0,0 +1,23 @@
+import { extractCollectionUploadHeaders } from "../modules/bzz.js";
+import { http } from "./http.js";
+import { TarStream } from "./tar.js";
+import { writeTar } from "./tar-writer.js";
+const bzzEndpoint = 'bzz';
+export async function uploadTar(requestOptions, collection, postageBatchId, options) {
+  const tarStream = new TarStream();
+  const responsePromise = http(requestOptions, {
+    method: 'post',
+    url: bzzEndpoint,
+    data: tarStream.output,
+    responseType: 'json',
+    headers: {
+      'content-type': 'application/x-tar',
+      'swarm-collection': 'true',
+      ...extractCollectionUploadHeaders(postageBatchId, options)
+    }
+  });
+  await writeTar(collection, tarStream);
+  await tarStream.end();
+  const response = await responsePromise;
+  return response;
+}

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

@@ -0,0 +1,12 @@
+import { fileArrayBuffer } from "./file.js";
+export async function writeTar(collection, tarStream) {
+  for (const item of collection) {
+    if (item.file) {
+      await tarStream.beginFile(item.path, item.file.size);
+      await tarStream.appendFile(new Uint8Array(await fileArrayBuffer(item.file)));
+      await tarStream.endFile();
+    } else {
+      throw new Error('Invalid collection item');
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { createReadStream } from 'fs';
+export async function writeTar(collection, tarStream) {
+  for (const item of collection) {
+    await tarStream.beginFile(item.path, item.size);
+    if (item.fsPath) {
+      const stream = createReadStream(item.fsPath);
+      for await (const chunk of stream) {
+        await tarStream.appendFile(chunk);
+      }
+      await tarStream.endFile();
+      stream.close();
+    } else {
+      throw new Error('Invalid collection item');
+    }
+  }
+}

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

@@ -0,0 +1,61 @@
+export class TarStream {
+  constructor() {
+    this.pieces = [];
+    this.currentFileSize = 0;
+  }
+  get output() {
+    return this.pieces.reduce((acc, piece) => {
+      const newAcc = new Uint8Array(acc.length + piece.length);
+      newAcc.set(acc);
+      newAcc.set(piece, acc.length);
+      return newAcc;
+    });
+  }
+  async beginFile(path, size) {
+    const header = createHeader(path, size);
+    this.pieces.push(header);
+    this.currentFileSize = 0;
+  }
+  async appendFile(data) {
+    this.pieces.push(data);
+    this.currentFileSize += data.length;
+  }
+  async endFile() {
+    const padding = 512 - this.currentFileSize % 512;
+    this.pieces.push(new Uint8Array(padding));
+  }
+  async end() {
+    this.pieces.push(createEndOfArchive());
+  }
+}
+function createHeader(path, size) {
+  const header = new Uint8Array(512); // Initialize header with zeros
+  const encoder = new TextEncoder();
+  function writeToBuffer(str, offset, length) {
+    const bytes = encoder.encode(str);
+    header.set(bytes.slice(0, length), offset);
+  }
+  writeToBuffer(path, 0, 100); // File name
+  writeToBuffer('0000777', 100, 8); // File mode
+  writeToBuffer('0001750', 108, 8); // UID
+  writeToBuffer('0001750', 116, 8); // GID
+  writeToBuffer(size.toString(8).padStart(11, '0') + ' ', 124, 12); // File size
+  writeToBuffer(Math.floor(Date.now() / 1000).toString(8) + ' ', 136, 12); // Mod time
+  writeToBuffer('        ', 148, 8); // Checksum placeholder
+  writeToBuffer('0', 156, 1); // Typeflag
+  writeToBuffer('ustar  ', 257, 8); // Magic and version
+  for (let i = 345; i < 512; i++) {
+    header[i] = 0; // Fill remaining with zeros
+  }
+  // Calculate checksum
+  let checksum = 0;
+  for (let i = 0; i < 512; i++) {
+    checksum += header[i];
+  }
+  // Write checksum
+  writeToBuffer(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8);
+  return header;
+}
+function createEndOfArchive() {
+  return new Uint8Array(1024);
+}

package/dist/mjs/utils/tar.js

@@ -1,18 +1,47 @@
-import Tar from 'tar-js';
-// converts a string to utf8 Uint8Array and returns it as a string-like
-// object that `tar.append` accepts as path
-function fixUnicodePath(path) {
-  const codes = new TextEncoder().encode(path);
-  return {
-    length: codes.length,
-    charCodeAt: index => codes[index]
-  };
-}
-export function makeTar(data) {
-  const tar = new Tar(1);
-  for (const entry of data) {
-    const path = fixUnicodePath(entry.path);
-    tar.append(path, entry.data);
+import { PassThrough } from 'stream';
+export class TarStream {
+  constructor() {
+    this.output = new PassThrough();
+    this.currentFileSize = 0;
+  }
+  async beginFile(path, size) {
+    const header = createHeader(path, size);
+    this.output.write(header);
+    this.currentFileSize = 0;
+  }
+  async appendFile(data) {
+    return new Promise(resolve => {
+      this.output.write(data, () => {
+        resolve();
+      });
+      this.currentFileSize += data.length;
+    });
+  }
+  async endFile() {
+    const padding = 512 - this.currentFileSize % 512;
+    this.output.write(Buffer.alloc(padding, 0));
   }
-  return tar.out;
+  async end() {
+    this.output.write(createEndOfArchive());
+    this.output.end();
+  }
+}
+function createHeader(path, size) {
+  const header = Buffer.alloc(512, 0); // Initialize header with zeros
+  header.write(path, 0, 100); // File name
+  header.write('0000777', 100, 8); // File mode
+  header.write('0001750', 108, 8); // UID
+  header.write('0001750', 116, 8); // GID
+  header.write(size.toString(8).padStart(11, '0') + ' ', 124, 12); // File size
+  header.write(Math.floor(new Date().getTime() / 1000).toString(8) + ' ', 136, 12); // Mod time
+  header.write('        ', 148, 8); // Checksum placeholder
+  header.write('0', 156, 1); // Typeflag
+  header.write('ustar  ', 257, 8); // Magic and version
+  header.write('0'.repeat(8 * 12), 345, 8 * 12); // Fill remaining with zeros
+  const checksum = header.reduce((sum, elem) => sum + elem, 0);
+  header.write(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8); // Write checksum
+  return header;
+}
+function createEndOfArchive() {
+  return Buffer.alloc(1024, 0);
 }

package/dist/mjs/utils/type.js

@@ -1,9 +1,12 @@
 import { decodeCid, encodeReference } from '@ethersphere/swarm-cid';
+import { Readable } from 'stream';
 import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PSS_TARGET_HEX_LENGTH_MAX, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
 import { BeeArgumentError, BeeError } from "./error.js";
 import { isFile } from "./file.js";
 import { assertHexString, assertPrefixedHexString, isHexString } from "./hex.js";
-import { isReadable } from "./stream.js";
+export function isReadable(obj) {
+  return typeof Readable !== 'undefined' && obj instanceof Readable;
+}
 export function isUint8Array(obj) {
   return obj instanceof Uint8Array;
 }

package/dist/mjs/utils/url.js

@@ -18,12 +18,7 @@ export function isValidBeeUrl(url) {
     // There can be wide range of protocols passed.
     return urlObject.protocol === 'http:' || urlObject.protocol === 'https:';
   } catch (e) {
-    // URL constructor throws TypeError if not valid URL
-    // TODO: Drop the `.code` hack for NodeJS environment: https://github.com/ethersphere/bee-js/issues/204
-    if (e instanceof TypeError || isNodeJsError(e) && e.code === 'ERR_INVALID_URL') {
-      return false;
-    }
-    throw e;
+    return false;
   }
 }
 /**