@ethersphere/bee-js 1.2.1 → 3.0.0

package/src/feed/index.ts

@@ -1,221 +0,0 @@
-import { keccak256Hash } from '../utils/hash'
-import { serializeBytes } from '../chunk/serialize'
-import { Identifier, uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from '../chunk/soc'
-import { FeedUpdateOptions, fetchFeedUpdate } from '../modules/feed'
-import {
-  REFERENCE_HEX_LENGTH,
-  Reference,
-  UploadOptions,
-  ENCRYPTED_REFERENCE_HEX_LENGTH,
-  ENCRYPTED_REFERENCE_BYTES_LENGTH,
-  REFERENCE_BYTES_LENGTH,
-  Signer,
-  FeedReader,
-  FeedWriter,
-  Topic,
-  Address,
-  BatchId,
-} from '../types'
-import { Bytes, makeBytes, bytesAtOffset } from '../utils/bytes'
-import { BeeResponseError } from '../utils/error'
-import { bytesToHex, HexString, hexToBytes, makeHexString } from '../utils/hex'
-import { readUint64BigEndian, writeUint64BigEndian } from '../utils/uint64'
-import * as chunkAPI from '../modules/chunk'
-import { EthAddress, HexEthAddress, makeHexEthAddress } from '../utils/eth'
-
-import type { FeedType } from './type'
-import { assertAddress } from '../utils/type'
-
-const TIMESTAMP_PAYLOAD_OFFSET = 0
-const TIMESTAMP_PAYLOAD_SIZE = 8
-const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE
-const REFERENCE_PAYLOAD_MIN_SIZE = 32
-const REFERENCE_PAYLOAD_MAX_SIZE = 64
-const INDEX_HEX_LENGTH = 16
-
-export interface Epoch {
-  time: number
-  level: number
-}
-export type IndexBytes = Bytes<8>
-export type Index = number | Epoch | IndexBytes | string
-
-export interface FeedUploadOptions extends UploadOptions, FeedUpdateOptions {}
-
-type PlainChunkReference = Bytes<32>
-type EncryptedChunkReference = Bytes<64>
-export type ChunkReference = PlainChunkReference | EncryptedChunkReference
-
-export interface FeedUpdate {
-  timestamp: number
-  reference: ChunkReference
-}
-
-export function isEpoch(epoch: unknown): epoch is Epoch {
-  return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch
-}
-
-function hashFeedIdentifier(topic: Topic, index: IndexBytes): Identifier {
-  return keccak256Hash(hexToBytes(topic), index)
-}
-
-export function makeSequentialFeedIdentifier(topic: Topic, index: number): Identifier {
-  const indexBytes = writeUint64BigEndian(index)
-
-  return hashFeedIdentifier(topic, indexBytes)
-}
-
-export function makeFeedIndexBytes(s: string): IndexBytes {
-  const hex = makeHexString(s, INDEX_HEX_LENGTH)
-
-  return hexToBytes(hex)
-}
-
-export function makeFeedIdentifier(topic: Topic, index: Index): Identifier {
-  if (typeof index === 'number') {
-    return makeSequentialFeedIdentifier(topic, index)
-  } else if (typeof index === 'string') {
-    const indexBytes = makeFeedIndexBytes(index)
-
-    return hashFeedIdentifier(topic, indexBytes)
-  } else if (isEpoch(index)) {
-    throw new TypeError('epoch is not yet implemented')
-  }
-
-  return hashFeedIdentifier(topic, index)
-}
-
-export async function uploadFeedUpdate(
-  url: string,
-  signer: Signer,
-  topic: Topic,
-  index: Index,
-  reference: ChunkReference,
-  postageBatchId: BatchId,
-  options?: FeedUploadOptions,
-): Promise<Reference> {
-  const identifier = makeFeedIdentifier(topic, index)
-  const at = options?.at ?? Date.now() / 1000.0
-  const timestamp = writeUint64BigEndian(at)
-  const payloadBytes = serializeBytes(timestamp, reference)
-
-  return uploadSingleOwnerChunkData(url, signer, postageBatchId, identifier, payloadBytes, options)
-}
-
-export async function findNextIndex(
-  url: string,
-  owner: HexEthAddress,
-  topic: Topic,
-  options?: FeedUpdateOptions,
-): Promise<HexString<typeof INDEX_HEX_LENGTH>> {
-  try {
-    const feedUpdate = await fetchFeedUpdate(url, owner, topic, options)
-
-    return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH)
-  } catch (e) {
-    if (e instanceof BeeResponseError && e.status === 404) {
-      return bytesToHex(makeBytes(8))
-    }
-    throw e
-  }
-}
-
-export async function updateFeed(
-  url: string,
-  signer: Signer,
-  topic: Topic,
-  reference: ChunkReference,
-  postageBatchId: BatchId,
-  options?: FeedUploadOptions,
-): Promise<Reference> {
-  const ownerHex = makeHexEthAddress(signer.address)
-  const nextIndex = await findNextIndex(url, ownerHex, topic, options)
-
-  return uploadFeedUpdate(url, signer, topic, nextIndex, reference, postageBatchId, options)
-}
-
-function verifyChunkReferenceAtOffset(offset: number, data: Uint8Array): ChunkReference {
-  try {
-    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MAX_SIZE)
-  } catch (e) {
-    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MIN_SIZE)
-  }
-}
-
-export function verifyChunkReference(data: Uint8Array): ChunkReference {
-  return verifyChunkReferenceAtOffset(0, data)
-}
-
-export async function downloadFeedUpdate(
-  url: string,
-  owner: EthAddress,
-  topic: Topic,
-  index: Index,
-): Promise<FeedUpdate> {
-  const identifier = makeFeedIdentifier(topic, index)
-  const address = keccak256Hash(identifier, owner)
-  const addressHex = bytesToHex(address)
-  const data = await chunkAPI.download(url, addressHex)
-  const soc = makeSingleOwnerChunkFromData(data, address)
-  const payload = soc.payload()
-  const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE)
-  const timestamp = readUint64BigEndian(timestampBytes)
-  const reference = verifyChunkReferenceAtOffset(REFERENCE_PAYLOAD_OFFSET, payload)
-
-  return {
-    timestamp,
-    reference,
-  }
-}
-
-export function makeFeedReader(url: string, type: FeedType, topic: Topic, owner: HexEthAddress): FeedReader {
-  const download = async (options?: FeedUpdateOptions) => fetchFeedUpdate(url, owner, topic, { ...options, type })
-
-  return {
-    type,
-    owner,
-    topic,
-    download,
-  }
-}
-
-function makeChunkReference(reference: ChunkReference | Reference): ChunkReference {
-  if (typeof reference === 'string') {
-    try {
-      // Non-encrypted chunk hex string reference
-      const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH)
-
-      return hexToBytes<typeof REFERENCE_BYTES_LENGTH>(hexReference)
-    } catch (e) {
-      if (!(e instanceof TypeError)) {
-        throw e
-      }
-
-      // Encrypted chunk hex string reference
-      const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH)
-
-      return hexToBytes<typeof ENCRYPTED_REFERENCE_BYTES_LENGTH>(hexReference)
-    }
-  } else if (reference instanceof Uint8Array) {
-    return verifyChunkReference(reference)
-  }
-  throw new TypeError('invalid chunk reference')
-}
-
-export function makeFeedWriter(url: string, type: FeedType, topic: Topic, signer: Signer): FeedWriter {
-  const upload = async (
-    postageBatchId: string | Address,
-    reference: ChunkReference | Reference,
-    options?: FeedUploadOptions,
-  ) => {
-    assertAddress(postageBatchId)
-    const canonicalReference = makeChunkReference(reference)
-
-    return updateFeed(url, signer, topic, canonicalReference, postageBatchId, { ...options, type })
-  }
-
-  return {
-    ...makeFeedReader(url, type, topic, makeHexEthAddress(signer.address)),
-    upload,
-  }
-}

package/src/feed/json.ts

@@ -1,32 +0,0 @@
-import { FeedWriter, FeedReader, AnyJson, BatchId, Reference } from '../types'
-import { Bee } from '../bee'
-
-function serializeJson(data: AnyJson): Uint8Array {
-  try {
-    const jsonString = JSON.stringify(data)
-
-    return new TextEncoder().encode(jsonString)
-  } catch (e) {
-    e.message = `JsonFeed: ${e.message}`
-    throw e
-  }
-}
-
-export async function getJsonData<T extends AnyJson>(bee: Bee, reader: FeedReader): Promise<T> {
-  const feedUpdate = await reader.download()
-  const retrievedData = await bee.downloadData(feedUpdate.reference)
-
-  return retrievedData.json() as T
-}
-
-export async function setJsonData(
-  bee: Bee,
-  writer: FeedWriter,
-  postageBatchId: BatchId,
-  data: AnyJson,
-): Promise<Reference> {
-  const serializedData = serializeJson(data)
-  const reference = await bee.uploadData(postageBatchId, serializedData)
-
-  return writer.upload(postageBatchId, reference)
-}

package/src/feed/topic.ts

@@ -1,23 +0,0 @@
-import { keccak256Hash } from '../utils/hash'
-import { assertBytes } from '../utils/bytes'
-import { makeHexString, bytesToHex } from '../utils/hex'
-import { Topic, TOPIC_BYTES_LENGTH, TOPIC_HEX_LENGTH } from '../types'
-
-export function makeTopic(topic: Uint8Array | string): Topic {
-  if (typeof topic === 'string') {
-    return makeHexString(topic, TOPIC_HEX_LENGTH)
-  } else if (topic instanceof Uint8Array) {
-    assertBytes(topic, TOPIC_BYTES_LENGTH)
-
-    return bytesToHex(topic, TOPIC_HEX_LENGTH)
-  }
-  throw new TypeError('invalid topic')
-}
-
-export function makeTopicFromString(s: string): Topic {
-  if (typeof s !== 'string') {
-    throw new TypeError('topic has to be string!')
-  }
-
-  return bytesToHex(keccak256Hash(s), TOPIC_HEX_LENGTH)
-}

package/src/feed/type.ts

@@ -1,12 +0,0 @@
-const feedTypes = ['sequence', 'epoch'] as const
-export type FeedType = typeof feedTypes[number]
-export const DEFAULT_FEED_TYPE: FeedType = 'sequence'
-
-export function isFeedType(type: unknown): type is FeedType {
-  return typeof type === 'string' && feedTypes.includes(type as FeedType)
-}
-export function assertFeedType(type: unknown): asserts type is FeedType {
-  if (!isFeedType(type)) {
-    throw new TypeError('invalid feed type')
-  }
-}

package/src/index.ts

@@ -1,24 +0,0 @@
-import { Bee } from './bee'
-import { BeeDebug } from './bee-debug'
-
-export * as Utils from './utils/expose'
-export * from './types'
-export * from './utils/error'
-export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status'
-export { Bee, BeeDebug }
-
-// for requrie-like imports
-declare global {
-  interface Window {
-    // binded as 'BeeJs' via Webpack
-    BeeJs: {
-      Bee: typeof import('./bee').Bee
-      BeeDebug: typeof import('./bee-debug').BeeDebug
-      Utils: typeof import('./utils/expose')
-      BeeError: typeof import('./utils/error').BeeError
-      BeeRequestError: typeof import('./utils/error').BeeRequestError
-      BeeResponseError: typeof import('./utils/error').BeeResponseError
-      BeeArgumentError: typeof import('./utils/error').BeeArgumentError
-    }
-  }
-}

package/src/modules/bytes.ts

@@ -1,75 +0,0 @@
-import type { AxiosRequestConfig } from 'axios'
-import type { Readable } from 'stream'
-import { BatchId, Data, Reference, UploadOptions } from '../types'
-import { prepareData } from '../utils/data'
-import { extractUploadHeaders } from '../utils/headers'
-import { safeAxios } from '../utils/safe-axios'
-import { wrapBytesWithHelpers } from '../utils/bytes'
-
-const endpoint = '/bytes'
-
-/**
- * Upload data to a Bee node
- *
- * @param url             Bee URL
- * @param data            Data to be uploaded
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options         Additional options like tag, encryption, pinning
- */
-export async function upload(
-  url: string,
-  data: string | Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  const response = await safeAxios<{ reference: Reference }>({
-    ...options?.axiosOptions,
-    method: 'post',
-    url: url + endpoint,
-    data: await prepareData(data),
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-    responseType: 'json',
-  })
-
-  return response.data.reference
-}
-
-/**
- * Download data as a byte array
- *
- * @param url  Bee URL
- * @param hash Bee content reference
- */
-export async function download(url: string, hash: Reference): Promise<Data> {
-  const response = await safeAxios<ArrayBuffer>({
-    responseType: 'arraybuffer',
-    url: `${url}${endpoint}/${hash}`,
-  })
-
-  return wrapBytesWithHelpers(new Uint8Array(response.data))
-}
-
-/**
- * Download data as a readable stream
- *
- * @param url  Bee URL
- * @param hash Bee content reference
- * @param axiosOptions optional - alter default options of axios HTTP client
- */
-export async function downloadReadable(
-  url: string,
-  hash: Reference,
-  axiosOptions?: AxiosRequestConfig,
-): Promise<Readable> {
-  const response = await safeAxios<Readable>({
-    ...axiosOptions,
-    method: 'GET',
-    responseType: 'stream',
-    url: `${url}${endpoint}/${hash}`,
-  })
-
-  return response.data
-}

package/src/modules/bzz.ts

@@ -1,184 +0,0 @@
-import {
-  BatchId,
-  Collection,
-  CollectionUploadOptions,
-  Data,
-  FileData,
-  FileUploadOptions,
-  Reference,
-  UploadHeaders,
-} from '../types'
-import { extractUploadHeaders, readFileHeaders } from '../utils/headers'
-import { safeAxios } from '../utils/safe-axios'
-import { prepareData } from '../utils/data'
-import { BeeArgumentError } from '../utils/error'
-import { makeTar } from '../utils/tar'
-import { assertCollection } from '../utils/collection'
-import { AxiosRequestConfig } from 'axios'
-import { wrapBytesWithHelpers } from '../utils/bytes'
-import { Readable } from 'stream'
-
-const bzzEndpoint = '/bzz'
-
-interface FileUploadHeaders extends UploadHeaders {
-  'content-length'?: string
-  'content-type'?: string
-}
-
-function extractFileUploadHeaders(postageBatchId: BatchId, options?: FileUploadOptions): FileUploadHeaders {
-  const headers: FileUploadHeaders = extractUploadHeaders(postageBatchId, options)
-
-  if (options?.size) headers['content-length'] = String(options.size)
-
-  if (options?.contentType) headers['content-type'] = options.contentType
-
-  return headers
-}
-
-/**
- * Upload single file
- *
- * @param url Bee URL
- * @param data Files data
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
- * @param options
- */
-export async function uploadFile(
-  url: string,
-  data: string | Uint8Array | Readable | ArrayBuffer,
-  postageBatchId: BatchId,
-  name?: string,
-  options?: FileUploadOptions,
-): Promise<Reference> {
-  if (!url) {
-    throw new BeeArgumentError('url parameter is required and cannot be empty', url)
-  }
-
-  const response = await safeAxios<{ reference: Reference }>({
-    ...options?.axiosOptions,
-    method: 'post',
-    url: url + bzzEndpoint,
-    data: prepareData(data),
-    headers: {
-      ...extractFileUploadHeaders(postageBatchId, options),
-    },
-    params: { name },
-    responseType: 'json',
-  })
-
-  return response.data.reference
-}
-
-/**
- * Download single file as a buffer
- *
- * @param url  Bee URL
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- * @param axiosOptions optional - alter default options of axios HTTP client
- */
-export async function downloadFile(
-  url: string,
-  hash: string,
-  path = '',
-  axiosOptions?: AxiosRequestConfig,
-): Promise<FileData<Data>> {
-  const response = await safeAxios<ArrayBuffer>({
-    ...axiosOptions,
-    method: 'GET',
-    responseType: 'arraybuffer',
-    url: `${url}${bzzEndpoint}/${hash}/${path}`,
-  })
-  const file = {
-    ...readFileHeaders(response.headers),
-    data: wrapBytesWithHelpers(new Uint8Array(response.data)),
-  }
-
-  return file
-}
-
-/**
- * Download single file as a readable stream
- *
- * @param url  Bee URL
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- * @param axiosOptions optional - alter default options of axios HTTP client
- */
-export async function downloadFileReadable(
-  url: string,
-  hash: string,
-  path = '',
-  axiosOptions?: AxiosRequestConfig,
-): Promise<FileData<Readable>> {
-  const response = await safeAxios<Readable>({
-    ...axiosOptions,
-    method: 'GET',
-    responseType: 'stream',
-    url: `${url}${bzzEndpoint}/${hash}/${path}`,
-  })
-  const file = {
-    ...readFileHeaders(response.headers),
-    data: response.data,
-  }
-
-  return file
-}
-
-/*******************************************************************************************************************/
-// Collections
-
-interface CollectionUploadHeaders extends UploadHeaders {
-  'swarm-index-document'?: string
-  'swarm-error-document'?: string
-}
-
-function extractCollectionUploadHeaders(
-  postageBatchId: BatchId,
-  options?: CollectionUploadOptions,
-): CollectionUploadHeaders {
-  const headers: CollectionUploadHeaders = extractUploadHeaders(postageBatchId, options)
-
-  if (options?.indexDocument) headers['swarm-index-document'] = options.indexDocument
-
-  if (options?.errorDocument) headers['swarm-error-document'] = options.errorDocument
-
-  return headers
-}
-
-/**
- * Upload collection
- * @param url Bee URL
- * @param collection Collection of Uint8Array buffers to upload
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options
- */
-export async function uploadCollection(
-  url: string,
-  collection: Collection<Uint8Array>,
-  postageBatchId: BatchId,
-  options?: CollectionUploadOptions,
-): Promise<Reference> {
-  if (!url) {
-    throw new BeeArgumentError('url parameter is required and cannot be empty', url)
-  }
-
-  assertCollection(collection)
-  const tarData = makeTar(collection)
-
-  const response = await safeAxios<{ reference: Reference }>({
-    ...options?.axiosOptions,
-    method: 'post',
-    url: url + bzzEndpoint,
-    data: tarData,
-    responseType: 'json',
-    headers: {
-      'content-type': 'application/x-tar',
-      'swarm-collection': 'true',
-      ...extractCollectionUploadHeaders(postageBatchId, options),
-    },
-  })
-
-  return response.data.reference
-}

package/src/modules/chunk.ts

@@ -1,75 +0,0 @@
-import type { AxiosRequestConfig } from 'axios'
-import type { Readable } from 'stream'
-import type { BatchId, ReferenceResponse, UploadOptions } from '../types'
-import { extractUploadHeaders } from '../utils/headers'
-import { safeAxios } from '../utils/safe-axios'
-import { Reference } from '../types'
-
-const endpoint = '/chunks'
-
-/**
- * Upload chunk to a Bee node
- *
- * The chunk data consists of 8 byte span and up to 4096 bytes of payload data.
- * The span stores the length of the payload in uint64 little endian encoding.
- * Upload expects the chuck data to be set accordingly.
- *
- * @param url     Bee URL
- * @param data    Chunk data to be uploaded
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
- * @param options Additional options like tag, encryption, pinning
- */
-export async function upload(
-  url: string,
-  data: Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  const response = await safeAxios<ReferenceResponse>({
-    ...options?.axiosOptions,
-    method: 'post',
-    url: `${url}${endpoint}`,
-    data,
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-    responseType: 'json',
-  })
-
-  return response.data.reference
-}
-
-/**
- * Download chunk data as a byte array
- *
- * @param url  Bee URL
- * @param hash Bee content reference
- *
- */
-export async function download(url: string, hash: string): Promise<Uint8Array> {
-  const response = await safeAxios<ArrayBuffer>({
-    responseType: 'arraybuffer',
-    url: `${url}${endpoint}/${hash}`,
-  })
-
-  return new Uint8Array(response.data)
-}
-
-/**
- * Download chunk data as a readable stream
- *
- * @param url  Bee URL
- * @param hash Bee content reference
- * @param axiosOptions optional - alter default options of axios HTTP client
- */
-export async function downloadReadable(url: string, hash: string, axiosOptions: AxiosRequestConfig): Promise<Readable> {
-  const response = await safeAxios<Readable>({
-    ...axiosOptions,
-    method: 'GET',
-    responseType: 'stream',
-    url: `${url}${endpoint}/${hash}`,
-  })
-
-  return response.data
-}