@ethersphere/bee-js 2.1.0 → 3.2.0

package/src/modules/pinning.ts

@@ -1,74 +0,0 @@
-import type { BeeGenericResponse, Ky, Pin, Reference } from '../types'
-import { http } from '../utils/http'
-
-const PINNING_ENDPOINT = 'pins'
-
-export interface GetAllPinResponse {
-  references: Reference[] | null
-}
-
-/**
- * Pin data with given reference
- *
- * @param ky Ky instance for given Bee class instance
- * @param reference Bee data reference
- */
-export async function pin(ky: Ky, reference: Reference): Promise<void> {
-  await http<BeeGenericResponse>(ky, {
-    method: 'post',
-    responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`,
-  })
-}
-
-/**
- * Unpin data with given reference
- *
- * @param ky Ky instance for given Bee class instance
- * @param reference Bee data reference
- */
-export async function unpin(ky: Ky, reference: Reference): Promise<void> {
-  await http<BeeGenericResponse>(ky, {
-    method: 'delete',
-    responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`,
-  })
-}
-
-/**
- * Get pin status for specific address.
- *
- * @param ky Ky instance
- * @param reference
- * @throws Error if given address is not pinned
- */
-export async function getPin(ky: Ky, reference: Reference): Promise<Pin> {
-  const response = await http<Pin>(ky, {
-    method: 'get',
-    responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`,
-  })
-
-  return response.data
-}
-
-/**
- * Get list of all pins
- *
- * @param ky Ky instance
- */
-export async function getAllPins(ky: Ky): Promise<Reference[]> {
-  const response = await http<GetAllPinResponse>(ky, {
-    method: 'get',
-    responseType: 'json',
-    path: `${PINNING_ENDPOINT}`,
-  })
-
-  const result = response.data.references
-
-  if (result === null) {
-    return []
-  }
-
-  return result
-}

package/src/modules/pss.ts

@@ -1,49 +0,0 @@
-import WebSocket from 'isomorphic-ws'
-
-import type { BatchId, BeeGenericResponse, Ky, PublicKey } from '../types'
-import { prepareData } from '../utils/data'
-import { http } from '../utils/http'
-import { extractUploadHeaders } from '../utils/headers'
-
-const endpoint = 'pss'
-
-/**
- * Send to recipient or target with Postal Service for Swarm
- *
- * @param ky Ky instance for given Bee class instance
- * @param topic Topic name
- * @param target Target message address prefix
- * @param data
- * @param postageBatchId Postage BatchId that will be assigned to sent message
- * @param recipient Recipient public key
- *
- */
-export async function send(
-  ky: Ky,
-  topic: string,
-  target: string,
-  data: string | Uint8Array,
-  postageBatchId: BatchId,
-  recipient?: PublicKey,
-): Promise<void> {
-  await http<BeeGenericResponse>(ky, {
-    method: 'post',
-    path: `${endpoint}/send/${topic}/${target}`,
-    body: await prepareData(data),
-    responseType: 'json',
-    searchParams: { recipient },
-    headers: extractUploadHeaders(postageBatchId),
-  })
-}
-
-/**
- * Subscribe for messages on the given topic
- *
- * @param url Bee node URL
- * @param topic Topic name
- */
-export function subscribe(url: string, topic: string): WebSocket {
-  const wsUrl = url.replace(/^http/i, 'ws')
-
-  return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic}`)
-}

package/src/modules/soc.ts

@@ -1,40 +0,0 @@
-import { BatchId, Ky, Reference, ReferenceResponse, UploadOptions } from '../types'
-import { extractUploadHeaders } from '../utils/headers'
-import { http } from '../utils/http'
-
-const socEndpoint = 'soc'
-
-/**
- * Upload single owner chunk (SOC) to a Bee node
- *
- * @param ky Ky instance
- * @param owner           Owner's ethereum address in hex
- * @param identifier      Arbitrary identifier in hex
- * @param signature       Signature in hex
- * @param data            Content addressed 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,
-  owner: string,
-  identifier: string,
-  signature: string,
-  data: Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  const response = await http<ReferenceResponse>(ky, {
-    method: 'post',
-    path: `${socEndpoint}/${owner}/${identifier}`,
-    body: data,
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-    responseType: 'json',
-    searchParams: { sig: signature },
-  })
-
-  return response.data.reference
-}

package/src/modules/stamps.ts

@@ -1,59 +0,0 @@
-import type { BatchId, Ky, NumberString, PostageBatch, PostageBatchOptions } from '../types'
-import { http } from '../utils/http'
-
-const STAMPS_ENDPOINT = 'stamps'
-
-interface GetAllStampsResponse {
-  stamps: PostageBatch[]
-}
-
-interface CreateStampResponse {
-  batchID: BatchId
-}
-
-export async function getAllPostageBatches(ky: Ky): Promise<PostageBatch[]> {
-  const response = await http<GetAllStampsResponse>(ky, {
-    method: 'get',
-    path: `${STAMPS_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data.stamps || []
-}
-
-export async function getPostageBatch(ky: Ky, postageBatchId: BatchId): Promise<PostageBatch> {
-  const response = await http<PostageBatch>(ky, {
-    method: 'get',
-    path: `${STAMPS_ENDPOINT}/${postageBatchId}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function createPostageBatch(
-  ky: Ky,
-  amount: NumberString,
-  depth: number,
-  options?: PostageBatchOptions,
-): Promise<BatchId> {
-  const headers: Record<string, string> = {}
-
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString()
-  }
-
-  if (options?.immutableFlag !== undefined) {
-    headers.immutable = String(options.immutableFlag)
-  }
-
-  const response = await http<CreateStampResponse>(ky, {
-    method: 'post',
-    path: `${STAMPS_ENDPOINT}/${amount}/${depth}`,
-    responseType: 'json',
-    searchParams: { label: options?.label },
-    headers,
-  })
-
-  return response.data.batchID
-}

package/src/modules/status.ts

@@ -1,13 +0,0 @@
-import { http } from '../utils/http'
-import { Ky } from '../types'
-
-/**
- * Ping the base bee URL. If connection was not successful throw error
- *
- * @param ky Ky instance for given Bee class instance
- */
-export async function checkConnection(ky: Ky): Promise<void> | never {
-  await http<string>(ky, {
-    path: '',
-  })
-}

package/src/modules/stewardship.ts

@@ -1,32 +0,0 @@
-import type { Ky, Reference } from '../types'
-import { http } from '../utils/http'
-
-const stewardshipEndpoint = 'stewardship'
-
-/**
- * Reupload locally pinned data
- * @param ky Ky instance
- * @param reference
- * @param options
- * @throws BeeResponseError if not locally pinned or invalid data
- */
-export async function reupload(ky: Ky, reference: Reference): Promise<void> {
-  await http(ky, {
-    method: 'put',
-    path: `${stewardshipEndpoint}/${reference}`,
-  })
-}
-
-interface IsRetrievableResponse {
-  isRetrievable: boolean
-}
-
-export async function isRetrievable(ky: Ky, reference: Reference): Promise<boolean> {
-  const response = await http<IsRetrievableResponse>(ky, {
-    method: 'get',
-    responseType: 'json',
-    path: `${stewardshipEndpoint}/${reference}`,
-  })
-
-  return response.data.isRetrievable
-}

package/src/modules/tag.ts

@@ -1,83 +0,0 @@
-import { Ky, Reference, Tag } from '../types'
-import { http } from '../utils/http'
-
-const endpoint = 'tags'
-
-interface GetAllTagsResponse {
-  tags: Tag[]
-}
-
-/**
- * Create new tag on the Bee node
- *
- * @param url Bee tag URL
- */
-export async function createTag(ky: Ky): Promise<Tag> {
-  const response = await http<Tag>(ky, {
-    method: 'post',
-    path: endpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Retrieve tag information from Bee node
- *
- * @param url Bee tag URL
- * @param uid UID of tag to be retrieved
- */
-export async function retrieveTag(ky: Ky, uid: number): Promise<Tag> {
-  const response = await http<Tag>(ky, {
-    path: `${endpoint}/${uid}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get limited listing of all tags.
- *
- * @param url
- * @param offset
- * @param limit
- */
-export async function getAllTags(ky: Ky, offset?: number, limit?: number): Promise<Tag[]> {
-  const response = await http<GetAllTagsResponse>(ky, {
-    path: `${endpoint}`,
-    searchParams: { offset, limit },
-    responseType: 'json',
-  })
-
-  return response.data.tags
-}
-
-/**
- * Removes tag from the Bee node.
- * @param url
- * @param uid
- */
-export async function deleteTag(ky: Ky, uid: number): Promise<void> {
-  await http<void>(ky, {
-    method: 'delete',
-    path: `${endpoint}/${uid}`,
-  })
-}
-
-/**
- * Updates tag
- * @param url
- * @param uid
- * @param reference
- */
-export async function updateTag(ky: Ky, uid: number, reference: Reference): Promise<void> {
-  await http<void>(ky, {
-    method: 'patch',
-    path: `${endpoint}/${uid}`,
-    json: {
-      reference,
-    },
-  })
-}

package/src/types/debug.ts

@@ -1,204 +0,0 @@
-import { PublicKey, NumberString, Reference, TransactionHash, RequestOptions } from './index'
-import { HexEthAddress } from '../utils/eth'
-
-/**
- * Object that contains information about progress of upload of data to network.
- *
- * @see [Bee docs - Syncing / Tags](https://docs.ethswarm.org/docs/access-the-swarm/syncing)
- */
-export interface ExtendedTag {
-  /**
-   * Number of all chunks that the data will be split into.
-   */
-  total: number
-
-  /**
-   * Number of chunks already processed by splitter for hashing
-   */
-  split: number
-
-  /**
-   * Number of chunks already seen
-   */
-  seen: number
-
-  /**
-   * Number of chunks already stored locally
-   */
-  stored: number
-
-  /**
-   * Number of chunks sent for push syncing
-   */
-  sent: number
-
-  /**
-   * Number of chunks synced with proof
-   */
-  synced: number
-
-  /**
-   * Unique identifier
-   */
-  uid: number
-
-  /**
-   * The associated swarm hash for this tag
-   */
-  address: Reference
-
-  /**
-   * When the upload process started
-   */
-  startedAt: string
-}
-
-export interface Settlements {
-  peer: string
-  received: NumberString
-  sent: NumberString
-}
-
-export interface AllSettlements {
-  totalReceived: NumberString
-  totalSent: NumberString
-  settlements: Settlements[]
-}
-
-export interface NodeAddresses {
-  overlay: string
-  underlay: string[]
-  ethereum: HexEthAddress
-  publicKey: PublicKey
-  pssPublicKey: PublicKey
-}
-
-export interface Peer {
-  address: string
-}
-
-export interface ChequebookAddressResponse {
-  chequebookAddress: string
-}
-
-export interface ChequebookBalanceResponse {
-  totalBalance: NumberString
-  availableBalance: NumberString
-}
-
-export interface CashoutOptions extends RequestOptions {
-  /**
-   * Gas price for the cashout transaction in WEI
-   */
-  gasPrice?: NumberString
-
-  /**
-   * Gas limit for the cashout transaction in WEI
-   */
-  gasLimit?: NumberString
-}
-
-export interface CashoutResult {
-  recipient: string
-  lastPayout: NumberString
-  bounced: boolean
-}
-
-export interface LastCashoutActionResponse {
-  peer: string
-  uncashedAmount: NumberString
-  transactionHash: string | null
-  lastCashedCheque: Cheque | null
-  result: CashoutResult | null
-}
-
-export interface TransactionResponse {
-  transactionHash: TransactionHash
-}
-
-export interface Cheque {
-  beneficiary: string
-  chequebook: string
-  payout: NumberString
-}
-
-export interface LastChequesForPeerResponse {
-  peer: string
-  lastreceived: Cheque
-  lastsent: Cheque
-}
-
-export interface LastChequesResponse {
-  lastcheques: LastChequesForPeerResponse[]
-}
-
-export interface PeerBalance {
-  peer: string
-  balance: NumberString
-}
-
-export interface BalanceResponse {
-  balances: PeerBalance[]
-}
-
-export interface Health {
-  status: 'ok'
-  version: string
-}
-
-export interface RemovePeerResponse {
-  message: string
-  code: 0
-}
-
-export interface Bin {
-  population: number
-  connected: number
-  disconnectedPeers: Peer[] | null
-  connectedPeers: Peer[] | null
-}
-
-export interface Topology {
-  baseAddr: string
-  population: number
-  connected: number
-  timestamp: string
-  nnLowWatermark: number
-  depth: number
-  bins: {
-    bin_0: Bin
-    bin_1: Bin
-    bin_2: Bin
-    bin_3: Bin
-    bin_4: Bin
-    bin_5: Bin
-    bin_6: Bin
-    bin_7: Bin
-    bin_8: Bin
-    bin_9: Bin
-    bin_10: Bin
-    bin_11: Bin
-    bin_12: Bin
-    bin_13: Bin
-    bin_14: Bin
-    bin_15: Bin
-  }
-}
-
-export interface PingResponse {
-  rtt: string
-}
-
-export interface ReserveState {
-  radius: number
-  storageRadius: number
-  available: number
-  outer: NumberString
-  inner: NumberString
-}
-
-export interface ChainState {
-  block: number
-  totalAmount: NumberString
-  currentPrice: NumberString
-}