@ethersphere/bee-js 3.2.0 → 3.3.2-pre.0

package/dist/mjs/utils/bytes.js

@@ -0,0 +1,101 @@
+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;
+}
+/**
+ * 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}`);
+  }
+}
+/**
+ * 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}`);
+  }
+}
+/**
+ * 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/collection.browser.js

@@ -0,0 +1,19 @@
+/**
+ * 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
+ */
+export async function makeCollectionFromFS(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+
+export async function getFolderSize(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
+}

package/dist/mjs/utils/collection.js

@@ -0,0 +1,64 @@
+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));
+}
+export function assertCollection(data) {
+  if (!isCollection(data)) {
+    throw new BeeArgumentError('invalid collection', data);
+  }
+}
+
+function makeFilePath(file) {
+  if (file.webkitRelativePath && file.webkitRelativePath !== '') {
+    return file.webkitRelativePath.replace(/.*?\//i, '');
+  }
+
+  if (file.name) {
+    return file.name;
+  }
+
+  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;
+}
+/**
+ * Calculate cumulative size of files
+ *
+ * @param fileList list of files to check
+ * @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;
+}

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

@@ -0,0 +1,74 @@
+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
+ */
+
+export async function makeCollectionFromFS(dir) {
+  if (typeof dir !== 'string') {
+    throw new TypeError('dir has to be string!');
+  }
+
+  if (dir === '') {
+    throw new TypeError('dir must not be empty string!');
+  }
+
+  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 = [];
+
+  for await (const entry of entries) {
+    const fullPath = path.join(dir, relativePath, entry.name);
+    const entryPath = path.join(relativePath, entry.name);
+
+    if (entry.isFile()) {
+      collection.push({
+        path: entryPath,
+        data: new Uint8Array(await fs.promises.readFile(fullPath))
+      });
+    } else if (entry.isDirectory()) {
+      collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
+    }
+  }
+
+  return collection;
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+
+
+export async function getFolderSize(dir) {
+  if (typeof dir !== 'string') {
+    throw new TypeError('dir has to be string!');
+  }
+
+  if (dir === '') {
+    throw new TypeError('dir must not be empty string!');
+  }
+
+  const entries = await fs.promises.opendir(dir);
+  let size = 0;
+
+  for await (const entry of entries) {
+    if (entry.isFile()) {
+      const stats = await fs.promises.stat(path.join(dir, entry.name));
+      size += stats.size;
+    } else if (entry.isDirectory()) {
+      size += await getFolderSize(path.join(dir, entry.name));
+    }
+  }
+
+  return size;
+}

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

@@ -0,0 +1,73 @@
+import { isNodeReadable, isReadableStream } from "./stream.js";
+import Blob from 'cross-blob';
+/**
+ * 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);
+  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

@@ -0,0 +1,43 @@
+import Blob from 'cross-blob';
+import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js";
+/**
+ * Prepare data for valid input for node-fetch.
+ *
+ * node-fetch is not using WHATWG ReadableStream but NodeJS Readable so we need to convert in case of ReadableStream,
+ * but the typings are set to use ReadableStream so hence why type conversion here.
+ *
+ * @param data any string, ArrayBuffer, Uint8Array or Readable
+ */
+
+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 || isNodeReadable(data)) return data;
+
+  if (isReadableStream(data)) {
+    return readableWebToNode(data);
+  }
+
+  throw new TypeError('unknown data type');
+}
+
+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 (data instanceof Blob) return new Uint8Array(await new Response(data).arrayBuffer());
+  if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
+  throw new TypeError('unknown websocket data type');
+}

package/dist/mjs/utils/error.js

@@ -0,0 +1,56 @@
+export class BeeError extends Error {
+  constructor(message) {
+    super(message);
+  }
+
+}
+export class BeeArgumentError extends BeeError {
+  value;
+
+  constructor(message, value) {
+    super(message);
+    this.value = value;
+  }
+
+}
+export class BeeRequestError extends BeeError {
+  requestOptions;
+  /**
+   * @param message
+   * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+   */
+
+  constructor(message, requestOptions) {
+    super(message);
+    this.requestOptions = requestOptions;
+  }
+
+}
+export class BeeResponseError extends BeeError {
+  status;
+  response;
+  responseBody;
+  requestOptions;
+  /**
+   * @param status HTTP status code number
+   * @param response Response returned from the server
+   * @param responseBody Response body as string which is returned from response.text() call
+   * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+   * @param message
+   */
+
+  constructor(status, response, responseBody, requestOptions, message) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.responseBody = responseBody;
+    this.requestOptions = requestOptions;
+  }
+
+}
+export class BeeNotAJsonError extends BeeError {
+  constructor() {
+    super(`Received response is not valid JSON.`);
+  }
+
+}

package/dist/mjs/utils/eth.js

@@ -0,0 +1,199 @@
+// For ESM compatibility
+import pkg from 'js-sha3';
+const {
+  keccak256,
+  sha3_256
+} = pkg;
+import { hexToBytes, intToHex, makeHexString, assertHexString } from "./hex.js";
+import { assertBytes } from "./bytes.js";
+const ETH_ADDR_BYTES_LENGTH = 20;
+const ETH_ADDR_HEX_LENGTH = 40;
+export function makeEthAddress(address) {
+  if (typeof address === 'string') {
+    const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
+    const ownerBytes = hexToBytes(hexAddr);
+    assertBytes(ownerBytes, ETH_ADDR_BYTES_LENGTH);
+    return ownerBytes;
+  } else if (address instanceof Uint8Array) {
+    assertBytes(address, ETH_ADDR_BYTES_LENGTH);
+    return address;
+  }
+
+  throw new TypeError('Invalid EthAddress');
+}
+export function makeHexEthAddress(address) {
+  try {
+    return makeHexString(address, ETH_ADDR_HEX_LENGTH);
+  } catch (e) {
+    if (e instanceof TypeError) {
+      e.message = `Invalid HexEthAddress: ${e.message}`;
+    }
+
+    throw e;
+  }
+}
+/**
+ * Check if this is all caps or small caps eth address (=address without checksum)
+ *
+ * @param address Ethereum address as hex string
+ */
+
+function isEthAddrCaseIns(address) {
+  // Check it's string, all small caps or all all caps hex and 40 chars long without the `0x` prefix
+  return typeof address === 'string' && (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address));
+}
+/**
+ * Check if this is checksummed ethereum address
+ *
+ * @param address Ethereum address as hex string
+ */
+
+
+function isValidChecksummedEthAddress(address) {
+  try {
+    // Check for valid case insensitive hex type string, 40 chars
+    const addr = makeHexString(address, ETH_ADDR_HEX_LENGTH); // Check the checksum
+
+    const addressHash = keccak256(addr.toLowerCase());
+
+    for (let i = 0; i < 40; i += 1) {
+      // the nth letter should be uppercase if the nth digit of casemap is 1
+      if (parseInt(addressHash[i], 16) > 7 && addr[i].toUpperCase() !== addr[i] || parseInt(addressHash[i], 16) <= 7 && addr[i].toLowerCase() !== addr[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  } catch (e) {
+    if (e instanceof TypeError) {
+      return false;
+    }
+
+    throw e;
+  }
+}
+/**
+ * Check if is valid ethereum address
+ *
+ * Pretty much typed version from web3js
+ * https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3-utils/src/utils.js
+ *
+ * @param address  Ethereum address as hex string
+ *
+ * @return True if is valid eth address
+ */
+
+
+export function isHexEthAddress(address) {
+  return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
+}
+/**
+ * Convert big-endian hex or number to little-endian.
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param bigEndian Big-endian hex string or number to convert
+ * @param pad       Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return little-endian encoded hexstring
+ */
+
+export function toLittleEndian(bigEndian, pad = 2) {
+  if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
+    throw new TypeError('minimal padding for conversion needs to be positive even integer');
+  }
+
+  let hexRep;
+  if (typeof bigEndian === 'string') hexRep = makeHexString(bigEndian);else if (typeof bigEndian === 'number') hexRep = intToHex(bigEndian);else throw new TypeError('incorrect input type');
+  hexRep = hexRep.padStart(pad, '0'); // Extend to an even length hexstring
+
+  if (hexRep.length % 2 !== 0) hexRep = hexRep.padStart(hexRep.length + 1, '0'); // Match all two pairs in the hexstring, reverse the pairs and join it again
+
+  const littleEndian = hexRep.match(/../g)?.reverse().join('');
+  if (littleEndian) return littleEndian;
+  throw new Error('failed to convert');
+}
+/**
+ * Convert little-endian hex or number to big-endian
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param littleEndian Little-endian hex string or number to convert
+ * @param pad          Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return big-endian encoded hexstring
+ */
+
+export function fromLittleEndian(littleEndian, pad = 2) {
+  // It's a reversible function
+  return toLittleEndian(littleEndian, pad);
+}
+
+function assertEthAddress(ethAddress) {
+  if (!isHexEthAddress(ethAddress)) throw new TypeError('invalid ETH address');
+}
+
+function assertSwarmNetworkId(networkId) {
+  if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError('swarm network id must be positive integer');
+  }
+}
+/**
+ * Get swarm overlay address from public ethereum address and swarm network id
+ *
+ * @param ethAddress  Public ethereum address
+ * @param networkId   Swarm network id
+ *
+ * @return Swarm overlay address
+ */
+
+
+export function ethToSwarmAddress(ethAddress, networkId = 1) {
+  assertEthAddress(ethAddress);
+  assertSwarmNetworkId(networkId);
+  const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`;
+  assertHexString(hex);
+  const overlayAddress = sha3_256(hexToBytes(hex));
+  return overlayAddress;
+}
+/**
+ * Function that takes Ethereum EIP-1193 compatible provider and create an Signer instance that
+ * uses `personal_sign` method to sign requested data.
+ *
+ * @param provider Injected web3 provider like window.ethereum or other compatible with EIP-1193
+ * @param ethAddress Optional address of the account which the data should be signed with. If not specified `eth_requestAccounts` request is used to get the account address.
+ */
+
+export async function makeEthereumWalletSigner(provider, ethAddress) {
+  let executorFnc;
+
+  if (typeof provider !== 'object' || provider === null) {
+    throw new TypeError('We need JsonRPC provider object!');
+  }
+
+  if (provider.request) {
+    executorFnc = provider.request;
+  } else if (provider.sendAsync) {
+    executorFnc = provider.sendAsync;
+  } else {
+    throw new Error('Incompatible interface of given provider!');
+  }
+
+  if (!ethAddress) {
+    ethAddress = (await executorFnc({
+      method: 'eth_requestAccounts'
+    }))[0];
+  }
+
+  const bytesEthAddress = makeEthAddress(ethAddress);
+  const hexEthAddress = makeHexEthAddress(ethAddress);
+  return {
+    address: bytesEthAddress,
+    sign: async data => {
+      const result = await executorFnc({
+        jsonrpc: '2.0',
+        method: 'personal_sign',
+        params: ['0x' + data.hex(), '0x' + hexEthAddress]
+      });
+      return result;
+    }
+  };
+}

package/dist/mjs/utils/expose.js

@@ -0,0 +1,9 @@
+export { getCollectionSize } from "./collection.js";
+export { getFolderSize } from "./collection.node.js";
+export { isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual } from "./bytes.js";
+export { makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString } from "./hex.js";
+export { makeEthAddress, makeHexEthAddress, isHexEthAddress, ethToSwarmAddress, toLittleEndian, fromLittleEndian, makeEthereumWalletSigner } from "./eth.js";
+export { readableWebToNode, readableNodeToWeb, isReadableStream, isNodeReadable, normalizeToReadableStream, isReadable } from "./stream.js";
+export { keccak256Hash } from "./hash.js";
+export { makeMaxTarget } from "./pss.js";
+export { getStampUsage } from "./stamps.js";

package/dist/mjs/utils/file.js

@@ -0,0 +1,36 @@
+/**
+ * Compatibility functions for working with File API objects
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/File
+ */
+export function isFile(file) {
+  // browser
+  if (typeof File === 'function') {
+    return file instanceof File;
+  } // node.js
+
+
+  const f = file;
+  return typeof f === 'object' && typeof f.name === 'string' && (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function');
+}
+/**
+ * Compatibility helper for browsers where the `arrayBuffer function is
+ * missing from `File` objects.
+ *
+ * @param file A File object
+ */
+
+export async function fileArrayBuffer(file) {
+  if (file.arrayBuffer) {
+    return file.arrayBuffer();
+  } // workaround for Safari where arrayBuffer is not supported on Files
+
+
+  return new Promise(resolve => {
+    const fr = new FileReader();
+
+    fr.onload = () => resolve(fr.result);
+
+    fr.readAsArrayBuffer(file);
+  });
+}

package/dist/mjs/utils/hash.js

@@ -0,0 +1,17 @@
+// For ESM compatibility
+import pkg from 'js-sha3';
+const {
+  keccak256
+} = pkg;
+/**
+ * Helper function for calculating the keccak256 hash with
+ * correct types.
+ *
+ * @param messages Any number of messages (strings, byte arrays etc.)
+ */
+
+export function keccak256Hash(...messages) {
+  const hasher = keccak256.create();
+  messages.forEach(bytes => hasher.update(bytes));
+  return Uint8Array.from(hasher.digest());
+}