@ethersphere/bee-js 2.1.0 → 3.2.0

package/src/feed/index.ts

@@ -1,217 +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,
-  Ky,
-} 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(
-  ky: Ky,
-  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(ky, signer, postageBatchId, identifier, payloadBytes, options)
-}
-
-export async function findNextIndex(
-  ky: Ky,
-  owner: HexEthAddress,
-  topic: Topic,
-  options?: FeedUpdateOptions,
-): Promise<HexString<typeof INDEX_HEX_LENGTH>> {
-  try {
-    const feedUpdate = await fetchFeedUpdate(ky, 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(
-  ky: Ky,
-  signer: Signer,
-  topic: Topic,
-  reference: ChunkReference,
-  postageBatchId: BatchId,
-  options?: FeedUploadOptions,
-): Promise<Reference> {
-  const ownerHex = makeHexEthAddress(signer.address)
-  const nextIndex = await findNextIndex(ky, ownerHex, topic, options)
-
-  return uploadFeedUpdate(ky, 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(ky: Ky, 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(ky, 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(ky: Ky, type: FeedType, topic: Topic, owner: HexEthAddress): FeedReader {
-  const download = async (options?: FeedUpdateOptions) => fetchFeedUpdate(ky, 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(ky: Ky, 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(ky, signer, topic, canonicalReference, postageBatchId, { ...options, type })
-  }
-
-  return {
-    ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
-    upload,
-  }
-}

package/src/feed/json.ts

@@ -1,33 +0,0 @@
-import { FeedWriter, FeedReader, AnyJson, BatchId, Reference, RequestOptions } 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,
-  options?: RequestOptions,
-): Promise<Reference> {
-  const serializedData = serializeJson(data)
-  const { reference } = await bee.uploadData(postageBatchId, serializedData, options)
-
-  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,70 +0,0 @@
-import type { BatchId, Data, Ky, Reference, UploadOptions } from '../types'
-import { prepareData } from '../utils/data'
-import { extractUploadHeaders } from '../utils/headers'
-import { http } from '../utils/http'
-import { wrapBytesWithHelpers } from '../utils/bytes'
-import { UploadResult } from '../types'
-import { makeTagUid } from '../utils/type'
-
-const endpoint = 'bytes'
-
-/**
- * Upload data to a Bee node
- *
- * @param ky              Ky instance
- * @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(
-  ky: Ky,
-  data: string | Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<UploadResult> {
-  const response = await http<{ reference: Reference }>(ky, {
-    path: endpoint,
-    method: 'post',
-    responseType: 'json',
-    body: await prepareData(data),
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-  })
-
-  return {
-    reference: response.data.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag')),
-  }
-}
-
-/**
- * Download data as a byte array
- *
- * @param ky
- * @param hash Bee content reference
- */
-export async function download(ky: Ky, hash: Reference): Promise<Data> {
-  const response = await http<ArrayBuffer>(ky, {
-    responseType: 'arraybuffer',
-    path: `${endpoint}/${hash}`,
-  })
-
-  return wrapBytesWithHelpers(new Uint8Array(response.data))
-}
-
-/**
- * Download data as a readable stream
- *
- * @param ky
- * @param hash Bee content reference
- */
-export async function downloadReadable(ky: Ky, hash: Reference): Promise<ReadableStream<Uint8Array>> {
-  const response = await http<ReadableStream<Uint8Array>>(ky, {
-    responseType: 'stream',
-    path: `${endpoint}/${hash}`,
-  })
-
-  return response.data
-}

package/src/modules/bzz.ts

@@ -1,179 +0,0 @@
-import {
-  BatchId,
-  Collection,
-  CollectionUploadOptions,
-  Data,
-  FileData,
-  FileUploadOptions,
-  Ky,
-  Readable,
-  Reference,
-  UploadHeaders,
-  UploadResult,
-} from '../types'
-import { extractUploadHeaders, readFileHeaders } from '../utils/headers'
-import { http } from '../utils/http'
-import { prepareData } from '../utils/data'
-import { makeTar } from '../utils/tar'
-import { assertCollection } from '../utils/collection'
-import { wrapBytesWithHelpers } from '../utils/bytes'
-import { isReadable } from '../utils/stream'
-import { makeTagUid } from '../utils/type'
-
-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 ky
- * @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(
-  ky: Ky,
-  data: string | Uint8Array | Readable | ArrayBuffer,
-  postageBatchId: BatchId,
-  name?: string,
-  options?: FileUploadOptions,
-): Promise<UploadResult> {
-  if (isReadable(data) && !options?.contentType) {
-    if (!options) options = {}
-
-    options.contentType = 'application/octet-stream'
-  }
-
-  const response = await http<{ reference: Reference }>(ky, {
-    method: 'post',
-    path: bzzEndpoint,
-    body: await prepareData(data),
-    headers: {
-      ...extractFileUploadHeaders(postageBatchId, options),
-    },
-    searchParams: { name },
-    responseType: 'json',
-  })
-
-  return {
-    reference: response.data.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag')),
-  }
-}
-
-/**
- * Download single file as a buffer
- *
- * @param ky Ky instance for given Bee class instance
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- */
-export async function downloadFile(ky: Ky, hash: string, path = ''): Promise<FileData<Data>> {
-  const response = await http<ArrayBuffer>(ky, {
-    method: 'GET',
-    responseType: 'arraybuffer',
-    path: `${bzzEndpoint}/${hash}/${path}`,
-  })
-  const file = {
-    ...readFileHeaders(response.headers),
-    data: wrapBytesWithHelpers(new Uint8Array(response.data)),
-  }
-
-  return file
-}
-
-/**
- * Download single file as a readable stream
- *
- * @param ky Ky instance for given Bee class instance
- * @param hash Bee file or collection hash
- * @param path If hash is collection then this defines path to a single file in the collection
- */
-export async function downloadFileReadable(
-  ky: Ky,
-  hash: string,
-  path = '',
-): Promise<FileData<ReadableStream<Uint8Array>>> {
-  const response = await http<ReadableStream<Uint8Array>>(ky, {
-    method: 'GET',
-    responseType: 'stream',
-    path: `${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 ky Ky instance for given Bee class instance
- * @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(
-  ky: Ky,
-  collection: Collection<Uint8Array>,
-  postageBatchId: BatchId,
-  options?: CollectionUploadOptions,
-): Promise<UploadResult> {
-  assertCollection(collection)
-  const tarData = makeTar(collection)
-
-  const response = await http<{ reference: Reference }>(ky, {
-    method: 'post',
-    path: bzzEndpoint,
-    body: tarData,
-    responseType: 'json',
-    headers: {
-      'content-type': 'application/x-tar',
-      'swarm-collection': 'true',
-      ...extractCollectionUploadHeaders(postageBatchId, options),
-    },
-  })
-
-  return {
-    reference: response.data.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag')),
-  }
-}

package/src/modules/chunk.ts

@@ -1,69 +0,0 @@
-import type { BatchId, Ky, ReferenceResponse, UploadOptions } from '../types'
-import { extractUploadHeaders } from '../utils/headers'
-import { http } from '../utils/http'
-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 ky Ky instance
- * @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(
-  ky: Ky,
-  data: Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  const response = await http<ReferenceResponse>(ky, {
-    method: 'post',
-    path: `${endpoint}`,
-    body: data,
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-    responseType: 'json',
-  })
-
-  return response.data.reference
-}
-
-/**
- * Download chunk data as a byte array
- *
- * @param ky Ky instance for given Bee class instance
- * @param hash Bee content reference
- *
- */
-export async function download(ky: Ky, hash: string): Promise<Uint8Array> {
-  const response = await http<ArrayBuffer>(ky, {
-    responseType: 'arraybuffer',
-    path: `${endpoint}/${hash}`,
-  })
-
-  return new Uint8Array(response.data)
-}
-
-/**
- * Download chunk data as a readable stream
- *
- * @param ky Ky instance for given Bee class instance
- * @param hash Bee content reference
- */
-export async function downloadReadable(ky: Ky, hash: string): Promise<ReadableStream<Uint8Array>> {
-  const response = await http<ReadableStream<Uint8Array>>(ky, {
-    responseType: 'stream',
-    path: `${endpoint}/${hash}`,
-  })
-
-  return response.data
-}

package/src/modules/debug/balance.ts

@@ -1,63 +0,0 @@
-import { http } from '../../utils/http'
-import type { PeerBalance, BalanceResponse, Ky } from '../../types'
-
-const balancesEndpoint = 'balances'
-const consumedEndpoint = 'consumed'
-
-/**
- * Get the balances with all known peers including prepaid services
- *
- * @param ky Ky debug instance
- */
-export async function getAllBalances(ky: Ky): Promise<BalanceResponse> {
-  const response = await http<BalanceResponse>(ky, {
-    path: balancesEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the balances with a specific peer including prepaid services
- *
- * @param ky Ky debug instance
- * @param address Swarm address of peer
- */
-export async function getPeerBalance(ky: Ky, address: string): Promise<PeerBalance> {
-  const response = await http<PeerBalance>(ky, {
-    path: `${balancesEndpoint}/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the past due consumption balances with all known peers
- *
- * @param ky Ky debug instance
- */
-export async function getPastDueConsumptionBalances(ky: Ky): Promise<BalanceResponse> {
-  const response = await http<BalanceResponse>(ky, {
-    path: consumedEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the past due consumption balance with a specific peer
- *
- * @param ky Ky debug instance
- * @param address Swarm address of peer
- */
-export async function getPastDueConsumptionPeerBalance(ky: Ky, address: string): Promise<PeerBalance> {
-  const response = await http<PeerBalance>(ky, {
-    path: `${consumedEndpoint}/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}