@ethersphere/bee-js 2.0.0 → 3.1.0

package/src/utils/collection.ts

@@ -1,151 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { Collection } from '../types'
-import { BeeArgumentError } from './error'
-import { fileArrayBuffer } from './file'
-import { isUint8Array } from './type'
-
-export function isCollection(data: unknown): data is Collection<Uint8Array> {
-  if (!Array.isArray(data)) {
-    return false
-  }
-
-  return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data))
-}
-
-export function assertCollection(data: unknown): asserts data is Collection<Uint8Array> {
-  if (!isCollection(data)) {
-    throw new BeeArgumentError('invalid collection', data)
-  }
-}
-
-/**
- * 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: string): Promise<Collection<Uint8Array>> {
-  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: string, relativePath: string): Promise<Collection<Uint8Array>> {
-  // 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: Collection<Uint8Array> = []
-
-  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
-}
-
-/*
- * This is a workaround for fixing the type definitions
- * regarding the missing `webkitRelativePath` property which is
- * provided on files if you specify the `webkitdirectory`
- * property on the HTML input element. This is a non-standard
- * functionality supported in all major browsers.
- */
-interface WebkitFile extends File {
-  readonly webkitRelativePath?: string
-}
-
-function makeFilePath(file: WebkitFile) {
-  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: FileList | File[]): Promise<Collection<Uint8Array>> {
-  const collection: Collection<Uint8Array> = []
-
-  for (let i = 0; i < fileList.length; i++) {
-    const file = fileList[i] as WebkitFile
-
-    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: FileList | File[]): number {
-  let sum = 0
-
-  for (let i = 0; i < fileList.length; i++) {
-    const file = fileList[i] as WebkitFile
-
-    if (file) {
-      sum += file.size
-    }
-  }
-
-  return sum
-}
-
-/**
- * Calculate folder size recursively
- *
- * @param dir the path to the folder to check
- * @returns size in bytes
- */
-export async function getFolderSize(dir: string): Promise<number> {
-  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/src/utils/data.browser.ts

@@ -1,68 +0,0 @@
-import { isNodeReadable, isReadableStream } from './stream'
-import { Readable } from '../types'
-import Blob from 'cross-blob'
-
-/**
- * Validates input and converts to Uint8Array
- *
- * @param data any string, ArrayBuffer or Uint8Array
- */
-export async function prepareData(
-  data: string | Blob | ArrayBuffer | Uint8Array | Readable,
-): Promise<Blob | ReadableStream<Uint8Array> | never> {
-  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: Array<Uint8Array> = []
-      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: Array<Uint8Array> = []
-
-      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: string | ArrayBuffer | Blob): Promise<Uint8Array> | never {
-  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 as Blob).arrayBuffer())
-
-  throw new TypeError('unknown websocket data type')
-}

package/src/utils/data.ts

@@ -1,48 +0,0 @@
-import type { Data } from 'ws'
-import Blob from 'cross-blob'
-import { isNodeReadable, isReadableStream, readableWebToNode } from './stream'
-import { Readable } from '../types'
-
-/**
- * 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: string | ArrayBuffer | Uint8Array | Readable,
-): Promise<Blob | ReadableStream<Uint8Array> | never> {
-  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 as ReadableStream<Uint8Array>
-
-  if (isReadableStream(data)) {
-    return readableWebToNode(data) as unknown as ReadableStream<Uint8Array>
-  }
-
-  throw new TypeError('unknown data type')
-}
-
-function isBufferArray(buffer: unknown): buffer is Buffer[] {
-  return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer)
-}
-
-export async function prepareWebsocketData(data: Data | Blob): Promise<Uint8Array> | never {
-  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 as Blob).arrayBuffer())
-
-  if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data))
-
-  throw new TypeError('unknown websocket data type')
-}

package/src/utils/error.ts

@@ -1,23 +0,0 @@
-export class BeeError extends Error {
-  public constructor(message: string) {
-    super(message)
-  }
-}
-
-export class BeeArgumentError extends BeeError {
-  public constructor(message: string, readonly value: unknown) {
-    super(message)
-  }
-}
-
-export class BeeRequestError extends BeeError {
-  public constructor(message: string) {
-    super(message)
-  }
-}
-
-export class BeeResponseError extends BeeError {
-  public constructor(readonly status: number, message: string) {
-    super(message)
-  }
-}

package/src/utils/eth.ts

@@ -1,229 +0,0 @@
-import { keccak256, sha3_256 } from 'js-sha3'
-import { BrandedString, Data, Signer } from '../types'
-import { HexString, hexToBytes, intToHex, makeHexString, assertHexString } from './hex'
-import { Bytes, assertBytes } from './bytes'
-
-export type OverlayAddress = BrandedString<'OverlayAddress'>
-export type EthAddress = Bytes<20>
-export type HexEthAddress = HexString<40>
-const ETH_ADDR_BYTES_LENGTH = 20
-const ETH_ADDR_HEX_LENGTH = 40
-
-export function makeEthAddress(address: EthAddress | Uint8Array | string | unknown): EthAddress {
-  if (typeof address === 'string') {
-    const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH)
-    const ownerBytes = hexToBytes<typeof ETH_ADDR_BYTES_LENGTH>(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: EthAddress | Uint8Array | string | unknown): HexEthAddress {
-  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: string | HexString | HexEthAddress): address is HexEthAddress {
-  // 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: string | HexString | HexEthAddress): address is HexEthAddress {
-  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: string | HexString | HexEthAddress): address is HexEthAddress {
-  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: number | string | HexString, pad = 2): HexString | never {
-  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 as HexString)
-  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 as HexString
-
-  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: number | string | HexString, pad = 2): HexString | never {
-  // It's a reversible function
-  return toLittleEndian(littleEndian, pad)
-}
-
-function assertEthAddress(ethAddress: string | HexString | HexEthAddress): asserts ethAddress is HexEthAddress {
-  if (!isHexEthAddress(ethAddress)) throw new TypeError('invalid ETH address')
-}
-
-function assertSwarmNetworkId(networkId: number): asserts networkId is number {
-  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: string | HexString | HexEthAddress, networkId = 1): OverlayAddress {
-  assertEthAddress(ethAddress)
-  assertSwarmNetworkId(networkId)
-
-  const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`
-  assertHexString(hex)
-
-  const overlayAddress = sha3_256(hexToBytes(hex))
-
-  return overlayAddress as OverlayAddress
-}
-
-interface RequestArguments {
-  method: string
-  jsonrpc?: string
-  params?: unknown[] | Record<string, unknown>
-}
-
-export interface JsonRPC {
-  request?(args: RequestArguments): Promise<unknown>
-  sendAsync?(args: RequestArguments): Promise<unknown>
-}
-
-/**
- * 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: JsonRPC,
-  ethAddress?: string | HexString | HexEthAddress,
-): Promise<Signer> {
-  let executorFnc: (args: RequestArguments) => Promise<unknown>
-
-  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' })) as string[])[0]
-  }
-
-  const bytesEthAddress = makeEthAddress(ethAddress)
-  const hexEthAddress = makeHexEthAddress(ethAddress)
-
-  return {
-    address: bytesEthAddress,
-    sign: async (data: Data): Promise<string> => {
-      const result = await executorFnc({
-        jsonrpc: '2.0',
-        method: 'personal_sign',
-        params: ['0x' + data.hex(), '0x' + hexEthAddress],
-      })
-
-      return result as string
-    },
-  } as Signer
-}

package/src/utils/expose.ts

@@ -1,48 +0,0 @@
-export { getCollectionSize, getFolderSize } from './collection'
-
-export {
-  Bytes,
-  FlexBytes,
-  isBytes,
-  assertBytes,
-  isFlexBytes,
-  assertFlexBytes,
-  bytesAtOffset,
-  flexBytesAtOffset,
-  bytesEqual,
-} from './bytes'
-
-export {
-  HexString,
-  PrefixedHexString,
-  makeHexString,
-  hexToBytes,
-  bytesToHex,
-  intToHex,
-  isHexString,
-  assertHexString,
-  assertPrefixedHexString,
-} from './hex'
-
-export {
-  EthAddress,
-  makeEthAddress,
-  makeHexEthAddress,
-  isHexEthAddress,
-  ethToSwarmAddress,
-  toLittleEndian,
-  fromLittleEndian,
-  makeEthereumWalletSigner,
-} from './eth'
-
-export {
-  readableWebToNode,
-  readableNodeToWeb,
-  isReadableStream,
-  isNodeReadable,
-  normalizeToReadableStream,
-  isReadable,
-} from './stream'
-
-export { keccak256Hash } from './hash'
-export { makeMaxTarget } from './pss'

package/src/utils/file.ts

@@ -1,40 +0,0 @@
-/**
- * Compatibility functions for working with File API objects
- *
- * https://developer.mozilla.org/en-US/docs/Web/API/File
- */
-
-export function isFile(file: unknown): file is File {
-  // browser
-  if (typeof File === 'function') {
-    return file instanceof File
-  }
-
-  // node.js
-  const f = file as 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: File): Promise<ArrayBuffer> {
-  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 as ArrayBuffer)
-    fr.readAsArrayBuffer(file)
-  })
-}

package/src/utils/hash.ts

@@ -1,16 +0,0 @@
-import { keccak256, Message } from 'js-sha3'
-import { Bytes } from './bytes'
-
-/**
- * Helper function for calculating the keccak256 hash with
- * correct types.
- *
- * @param messages Any number of messages (strings, byte arrays etc.)
- */
-export function keccak256Hash(...messages: Message[]): Bytes<32> {
-  const hasher = keccak256.create()
-
-  messages.forEach(bytes => hasher.update(bytes))
-
-  return Uint8Array.from(hasher.digest()) as Bytes<32>
-}

package/src/utils/headers.ts

@@ -1,63 +0,0 @@
-import { BatchId, FileHeaders, UploadOptions } from '../types'
-import { BeeError } from './error'
-
-/**
- * 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
- */
-function readContentDispositionFilename(header: string | null): string {
-  if (!header) {
-    throw new BeeError('missing content-disposition header')
-  }
-
-  // Regex was found here
-  // https://stackoverflow.com/questions/23054475/javascript-regex-for-extracting-filename-from-content-disposition-header
-  const dispositionMatch = header.match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i)
-
-  if (dispositionMatch && dispositionMatch.length > 0) {
-    return dispositionMatch[1]
-  }
-  throw new BeeError('invalid content-disposition header')
-}
-
-function readTagUid(header: string | null): number | undefined {
-  if (!header) {
-    return undefined
-  }
-
-  return parseInt(header, 10)
-}
-
-export function readFileHeaders(headers: Headers): FileHeaders {
-  const name = readContentDispositionFilename(headers.get('content-disposition'))
-  const tagUid = readTagUid(headers.get('swarm-tag-uid'))
-  const contentType = headers.get('content-type') || undefined
-
-  return {
-    name,
-    tagUid,
-    contentType,
-  }
-}
-
-export function extractUploadHeaders(postageBatchId: BatchId, options?: UploadOptions): Record<string, string> {
-  if (!postageBatchId) {
-    throw new BeeError('Postage BatchID has to be specified!')
-  }
-
-  const headers: Record<string, string> = {
-    '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)
-
-  return headers
-}