@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/mjs/utils/bytes.js

@@ -1,108 +1,67 @@
-import { bytesToHex } from "./hex.js";
-/**
- * Type guard for `Bytes<T>` type
- *
- * @param b       The byte array
- * @param length  The length of the byte array
- */
-export function isBytes(b, length) {
-  return b instanceof Uint8Array && b.length === length;
-}
-/**
- * Function that verifies if passed data are Bytes and if the array has "length" number of bytes under given offset.
- * @param data
- * @param offset
- * @param length
- */
-export function hasBytesAtOffset(data, offset, length) {
-  if (!(data instanceof Uint8Array)) {
-    throw new TypeError('Data has to an Uint8Array!');
+import { Binary, Types } from 'cafe-utility';
+const DECODER = new TextDecoder();
+const ENCODER = new TextEncoder();
+export class Bytes {
+  constructor(bytes, byteLength) {
+    if (bytes instanceof Bytes) {
+      this.bytes = bytes.bytes;
+    } else if (typeof bytes === 'string') {
+      this.bytes = Binary.hexToUint8Array(Types.asHexString(bytes, {
+        name: 'Bytes#constructor(bytes)'
+      }));
+    } else if (bytes instanceof ArrayBuffer) {
+      this.bytes = new Uint8Array(bytes);
+    } else {
+      this.bytes = bytes;
+    }
+    this.length = this.bytes.length;
+    if (byteLength) {
+      if (Array.isArray(byteLength)) {
+        if (!byteLength.includes(this.length)) {
+          throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength.join(' or ')}`);
+        }
+      } else if (this.length !== byteLength) {
+        throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength}`);
+      }
+    }
   }
-  const offsetBytes = data.slice(offset, offset + length);
-  return isBytes(offsetBytes, length);
-}
-/**
- * Verifies if a byte array has a certain length
- *
- * @param b       The byte array
- * @param length  The specified length
- */
-export function assertBytes(b, length) {
-  if (!isBytes(b, length)) {
-    throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
+  static keccak256(bytes) {
+    return new Bytes(Binary.keccak256(new Bytes(bytes).toUint8Array()));
   }
-}
-/**
- * Type guard for FlexBytes<Min,Max> type
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-export function isFlexBytes(b, min, max) {
-  return b instanceof Uint8Array && b.length >= min && b.length <= max;
-}
-/**
- * Verifies if a byte array has a certain length between min and max
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-export function assertFlexBytes(b, min, max) {
-  if (!isFlexBytes(b, min, max)) {
-    throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
+  static fromUtf8(utf8) {
+    return new Bytes(ENCODER.encode(utf8));
+  }
+  static fromSlice(bytes, start, length) {
+    if (length === undefined) {
+      return new Bytes(bytes.slice(start));
+    }
+    return new Bytes(bytes.slice(start, start + length));
+  }
+  offset(index) {
+    return new Uint8Array(this.bytes.slice(index));
+  }
+  toUint8Array() {
+    return new Uint8Array(this.bytes);
+  }
+  toHex() {
+    return Binary.uint8ArrayToHex(this.bytes);
+  }
+  toBase64() {
+    return Binary.uint8ArrayToBase64(this.bytes);
+  }
+  toBase32() {
+    return Binary.uint8ArrayToBase32(this.bytes);
+  }
+  toString() {
+    return this.toHex();
+  }
+  toUtf8() {
+    return DECODER.decode(this.bytes);
+  }
+  toJSON() {
+    return JSON.parse(this.toUtf8());
+  }
+  equals(other) {
+    return this.toHex() === new Bytes(other).toHex();
   }
-}
-/**
- * Return `length` bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param length The length of data to be returned
- */
-export function bytesAtOffset(data, offset, length) {
-  const offsetBytes = data.slice(offset, offset + length);
-  // We are returning strongly typed Bytes so we have to verify that length is really what we claim
-  assertBytes(offsetBytes, length);
-  return offsetBytes;
-}
-/**
- * Return flex bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param _min   The minimum size of the data
- * @param _max   The maximum size of the data
- */
-export function flexBytesAtOffset(data, offset,
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_min,
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_max) {
-  return data.slice(offset);
-}
-/**
- * Returns true if two byte arrays are equal
- *
- * @param a Byte array to compare
- * @param b Byte array to compare
- */
-export function bytesEqual(a, b) {
-  return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-/**
- * Returns a new byte array filled with zeroes with the specified length
- *
- * @param length The length of data to be returned
- */
-export function makeBytes(length) {
-  return new Uint8Array(length);
-}
-export function wrapBytesWithHelpers(data) {
-  return Object.assign(data, {
-    text: () => new TextDecoder('utf-8').decode(data),
-    json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
-    hex: () => bytesToHex(data)
-  });
 }

package/dist/mjs/utils/chunk-size.js

@@ -0,0 +1,13 @@
+export function totalChunks(fileSize) {
+  const chunkSize = 4096;
+  const hashesPerChunk = 128;
+  function chunksAtLevel(chunkCount) {
+    if (chunkCount <= 1) {
+      return chunkCount;
+    }
+    const upperLevelChunks = Math.ceil(chunkCount / hashesPerChunk);
+    return chunkCount + chunksAtLevel(upperLevelChunks);
+  }
+  const baseLevelChunks = Math.ceil(fileSize / chunkSize);
+  return chunksAtLevel(baseLevelChunks);
+}

package/dist/mjs/utils/chunk-stream.browser.js

@@ -0,0 +1,85 @@
+import { AsyncQueue, MerkleTree, Strings } from 'cafe-utility';
+import { NULL_ADDRESS } from "../index.js";
+import { MantarayNode } from "../manifest/manifest.js";
+import { totalChunks } from "./chunk-size.js";
+import { makeFilePath } from "./collection.js";
+import { mimes } from "./mime.js";
+import { BatchId } from "./typed-bytes.js";
+export async function hashDirectory(_dir) {
+  throw new Error('Hashing directories is not supported in browsers!');
+}
+export async function streamDirectory(_bee, _dir, _postageBatchId, _onUploadProgress, _options, _requestOptions) {
+  throw new Error('Streaming directories is not supported in browsers!');
+}
+export async function streamFiles(bee, files, postageBatchId, onUploadProgress, options, requestOptions) {
+  const queue = new AsyncQueue(64, 64);
+  let total = 0;
+  let processed = 0;
+  for (const file of files) {
+    total += totalChunks(file.size);
+  }
+  postageBatchId = new BatchId(postageBatchId);
+  async function onChunk(chunk) {
+    await queue.enqueue(async () => {
+      await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
+      onUploadProgress?.({
+        total,
+        processed: ++processed
+      });
+    });
+  }
+  const mantaray = new MantarayNode();
+  for (const file of files) {
+    const rootChunk = await new Promise((resolve, reject) => {
+      const tree = new MerkleTree(onChunk);
+      let offset = 0;
+      const reader = new FileReader();
+      reader.onerror = () => {
+        reject(reader.error);
+      };
+      const readNextChunk = async () => {
+        if (offset >= file.size) {
+          const rootChunk = await tree.finalize();
+          resolve(rootChunk);
+          return;
+        }
+        const slice = file.slice(offset, offset + 4096);
+        reader.readAsArrayBuffer(slice);
+      };
+      reader.onload = async event => {
+        if (!event.target) {
+          reject('No event target');
+          return;
+        }
+        const data = event.target.result;
+        if (data) {
+          await tree.append(new Uint8Array(data));
+          offset += 4096;
+        }
+        readNextChunk();
+      };
+      readNextChunk();
+    });
+    await queue.drain();
+    const {
+      filename,
+      extension
+    } = Strings.parseFilename(file.name);
+    mantaray.addFork(makeFilePath(file), rootChunk.hash(), {
+      'Content-Type': maybeEnrichMime(mimes[extension.toLowerCase()] || 'application/octet-stream'),
+      Filename: filename
+    });
+    if (file.name === 'index.html') {
+      mantaray.addFork('/', NULL_ADDRESS, {
+        'website-index-document': 'index.html'
+      });
+    }
+  }
+  return mantaray.saveRecursively(bee, postageBatchId, options, requestOptions);
+}
+function maybeEnrichMime(mime) {
+  if (['text/html', 'text/css'].includes(mime)) {
+    return `${mime}; charset=utf-8`;
+  }
+  return mime;
+}

package/dist/mjs/utils/chunk-stream.js

@@ -0,0 +1,87 @@
+import { AsyncQueue, MerkleTree, Strings } from 'cafe-utility';
+import { createReadStream } from 'fs';
+import { NULL_ADDRESS } from "../index.js";
+import { MantarayNode } from "../manifest/manifest.js";
+import { totalChunks } from "./chunk-size.js";
+import { makeCollectionFromFS } from "./collection.node.js";
+import { mimes } from "./mime.js";
+import { BatchId } from "./typed-bytes.js";
+export async function hashDirectory(dir) {
+  const files = await makeCollectionFromFS(dir);
+  const mantaray = new MantarayNode();
+  for (const file of files) {
+    const tree = new MerkleTree(MerkleTree.NOOP);
+    if (!file.fsPath) {
+      throw Error('File does not have fsPath, which should never happen in node. Please report this issue.');
+    }
+    const readStream = createReadStream(file.fsPath);
+    for await (const data of readStream) {
+      await tree.append(data);
+    }
+    const rootChunk = await tree.finalize();
+    const {
+      filename,
+      extension
+    } = Strings.parseFilename(file.path);
+    mantaray.addFork(file.path, rootChunk.hash(), {
+      'Content-Type': maybeEnrichMime(mimes[extension.toLowerCase()] || 'application/octet-stream'),
+      Filename: filename
+    });
+  }
+  return mantaray.calculateSelfAddress();
+}
+export async function streamDirectory(bee, dir, postageBatchId, onUploadProgress, options, requestOptions) {
+  const queue = new AsyncQueue(64, 64);
+  let total = 0;
+  let processed = 0;
+  postageBatchId = new BatchId(postageBatchId);
+  const files = await makeCollectionFromFS(dir);
+  for (const file of files) {
+    total += totalChunks(file.size);
+  }
+  async function onChunk(chunk) {
+    await queue.enqueue(async () => {
+      await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
+      onUploadProgress?.({
+        total,
+        processed: ++processed
+      });
+    });
+  }
+  const mantaray = new MantarayNode();
+  for (const file of files) {
+    if (!file.fsPath) {
+      throw Error('File does not have fsPath, which should never happen in node. Please report this issue.');
+    }
+    const readStream = createReadStream(file.fsPath);
+    const tree = new MerkleTree(onChunk);
+    for await (const data of readStream) {
+      await tree.append(data);
+    }
+    const rootChunk = await tree.finalize();
+    await queue.drain();
+    const {
+      filename,
+      extension
+    } = Strings.parseFilename(file.path);
+    mantaray.addFork(file.path, rootChunk.hash(), {
+      'Content-Type': maybeEnrichMime(mimes[extension.toLowerCase()] || 'application/octet-stream'),
+      Filename: filename
+    });
+    if (file.path === 'index.html') {
+      mantaray.addFork('/', NULL_ADDRESS, {
+        'website-index-document': 'index.html'
+      });
+    }
+  }
+  return mantaray.saveRecursively(bee, postageBatchId, options, requestOptions);
+}
+function maybeEnrichMime(mime) {
+  if (['text/html', 'text/css'].includes(mime)) {
+    return `${mime}; charset=utf-8`;
+  }
+  return mime;
+}
+export async function streamFiles(_bee, _files, _postageBatchId, _onUploadProgress, _options, _requestOptions) {
+  throw new Error('Streaming files is not supported in Node.js');
+}

package/dist/mjs/utils/cid.js

@@ -1,4 +1,5 @@
 import { Binary } from 'cafe-utility';
+import { Reference } from "./typed-bytes.js";
 export const SWARM_MANIFEST_CODEC = 0xfa;
 export const SWARM_FEED_CODEC = 0xfb;
 const CODEC_TABLE = {
@@ -6,9 +7,7 @@ const CODEC_TABLE = {
   [SWARM_FEED_CODEC]: 'feed'
 };
 export function convertReferenceToCid(reference, type) {
-  if (reference.length !== 64) {
-    throw TypeError('Only 32-byte, non-encrypted references are supported');
-  }
+  reference = new Reference(reference);
   const base32 = 'b';
   const version = new Uint8Array([1]);
   const codec = new Uint8Array([type === 'feed' ? SWARM_FEED_CODEC : SWARM_MANIFEST_CODEC]);
@@ -16,7 +15,7 @@ export function convertReferenceToCid(reference, type) {
   const sha256 = new Uint8Array([27]);
   const size = new Uint8Array([32]);
   const header = Binary.uint8ArrayToBase32(Binary.concatBytes(version, codec, unknown, sha256, size)).replace(/\=+$/, '');
-  const hash = Binary.uint8ArrayToBase32(Binary.hexToUint8Array(reference)).replace(/\=+$/, '');
+  const hash = reference.toBase32().replace(/\=+$/, '');
   return `${base32}${header}${hash}`.toLowerCase();
 }
 export function convertCidToReference(cid) {
@@ -25,9 +24,9 @@ export function convertCidToReference(cid) {
   if (!CODEC_TABLE[codec]) {
     throw new Error('Unknown codec');
   }
-  const reference = bytes.slice(-32);
+  const reference = new Reference(bytes.slice(-32));
   return {
     type: CODEC_TABLE[codec],
-    reference: Binary.uint8ArrayToHex(reference)
+    reference
   };
 }

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

@@ -4,7 +4,7 @@
  *
  * @param dir path to the directory
  */
-export async function makeCollectionFromFS(dir) {
+export async function makeCollectionFromFS(_dir) {
   throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 /**
@@ -13,6 +13,6 @@ export async function makeCollectionFromFS(dir) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-export async function getFolderSize(dir) {
+export async function getFolderSize(_dir) {
   throw new Error('Creating Collection from File System is not supported in browsers!');
 }

package/dist/mjs/utils/collection.js

@@ -10,7 +10,7 @@ export function assertCollection(data) {
     throw new BeeArgumentError('invalid collection', data);
   }
 }
-function makeFilePath(file) {
+export function makeFilePath(file) {
   if (file.webkitRelativePath && file.webkitRelativePath !== '') {
     return file.webkitRelativePath.replace(/.*?\//i, '');
   }
@@ -19,7 +19,7 @@ function makeFilePath(file) {
   }
   throw new TypeError('file is not valid File object');
 }
-export async function makeCollectionFromFileList(fileList) {
+export function makeCollectionFromFileList(fileList) {
   return Array.from(fileList).map(file => ({
     path: makeFilePath(file),
     size: file.size,

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

@@ -2,7 +2,6 @@ import fs from 'fs';
 import path from 'path';
 /**
  * Creates array in the format of Collection with data loaded from directory on filesystem.
- * The function loads all the data into memory!
  *
  * @param dir path to the directory
  */
@@ -16,7 +15,6 @@ export async function makeCollectionFromFS(dir) {
   return buildCollectionRelative(dir, '');
 }
 async function buildCollectionRelative(dir, relativePath) {
-  // Handles case when the dir is not existing or it is a file ==> throws an error
   const dirname = path.join(dir, relativePath);
   const entries = await fs.promises.opendir(dirname);
   let collection = [];

package/dist/mjs/utils/constants.js

@@ -1,3 +1,7 @@
+import { BatchId, Topic } from "./typed-bytes.js";
 export const SWARM_GATEWAY_URL = 'https://api.gateway.ethswarm.org';
-export const NULL_STAMP = '0000000000000000000000000000000000000000000000000000000000000000';
-export const NULL_TOPIC = '0000000000000000000000000000000000000000000000000000000000000000';
+export const NULL_STAMP = new BatchId('0000000000000000000000000000000000000000000000000000000000000000');
+export const NULL_TOPIC = new Topic('0000000000000000000000000000000000000000000000000000000000000000');
+export const NULL_ADDRESS = new Uint8Array(32);
+export const NULL_IDENTIFIER = new Uint8Array(32);
+export const NULL_OWNER = new Uint8Array(20);

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

@@ -1,6 +1,12 @@
 export async function prepareWebsocketData(data) {
-  if (typeof data === 'string') return new TextEncoder().encode(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (data instanceof Blob) return new Uint8Array(await new Response(data).arrayBuffer());
+  if (typeof data === 'string') {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (data instanceof Blob) {
+    return new Uint8Array(await new Response(data).arrayBuffer());
+  }
   throw new TypeError('unknown websocket data type');
 }

package/dist/mjs/utils/data.js

@@ -2,9 +2,17 @@ function isBufferArray(buffer) {
   return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
 }
 export async function prepareWebsocketData(data) {
-  if (typeof data === 'string') return new TextEncoder().encode(data);
-  if (data instanceof Buffer) return new Uint8Array(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
+  if (typeof data === 'string') {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (isBufferArray(data)) {
+    return new Uint8Array(Buffer.concat(data));
+  }
   throw new TypeError('unknown websocket data type');
 }

package/dist/mjs/utils/duration.js

@@ -0,0 +1,47 @@
+export class Duration {
+  constructor(seconds) {
+    this.seconds = Math.ceil(seconds);
+    if (seconds <= 0) {
+      throw Error('Duration must be greater than 0');
+    }
+  }
+  static fromMilliseconds(milliseconds) {
+    return new Duration(milliseconds / 1000);
+  }
+  static fromSeconds(seconds) {
+    return new Duration(seconds);
+  }
+  static fromHours(hours) {
+    return new Duration(hours * 60 * 60);
+  }
+  static fromDays(days) {
+    return new Duration(days * 24 * 60 * 60);
+  }
+  static fromWeeks(weeks) {
+    return new Duration(weeks * 7 * 24 * 60 * 60);
+  }
+  static fromYears(years) {
+    return new Duration(years * 365 * 24 * 60 * 60);
+  }
+  static fromEndDate(endDate, startDate) {
+    return new Duration((endDate.getTime() - (startDate ?? new Date()).getTime()) / 1000);
+  }
+  toSeconds() {
+    return this.seconds;
+  }
+  toHours() {
+    return this.seconds / 60 / 60;
+  }
+  toDays() {
+    return this.seconds / 24 / 60 / 60;
+  }
+  toWeeks() {
+    return this.seconds / 7 / 24 / 60 / 60;
+  }
+  toYears() {
+    return this.seconds / 365 / 24 / 60 / 60;
+  }
+  toEndDate(startDate) {
+    return new Date((startDate ?? new Date()).getTime() + this.seconds * 1000);
+  }
+}

package/dist/mjs/utils/expose.js

@@ -1,10 +1,5 @@
-export { getCollectionSize } from "./collection.js";
+export { getCollectionSize, makeCollectionFromFileList } from "./collection.js";
 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 { capitalizeAddressERC55, ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, makeEthereumWalletSigner, makeHexEthAddress, toLittleEndian } from "./eth.js";
-export { keccak256Hash } from "./hash.js";
 export { makeMaxTarget } from "./pss.js";
-export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage } from "./stamps.js";
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from "./redundancy.js";
-export { convertCidToReference, convertReferenceToCid } from "./cid.js";
+export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage } from "./stamps.js";