@ethersphere/bee-js 1.2.1 → 3.0.0

package/src/modules/pinning.ts

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

package/src/modules/pss.ts

@@ -1,48 +0,0 @@
-import WebSocket from 'isomorphic-ws'
-
-import type { BatchId, BeeGenericResponse, PublicKey } from '../types'
-import { prepareData } from '../utils/data'
-import { safeAxios } from '../utils/safe-axios'
-import { extractUploadHeaders } from '../utils/headers'
-
-const endpoint = '/pss'
-
-/**
- * Send to recipient or target with Postal Service for Swarm
- *
- * @param url Bee url
- * @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(
-  url: string,
-  topic: string,
-  target: string,
-  data: string | Uint8Array,
-  postageBatchId: BatchId,
-  recipient?: PublicKey,
-): Promise<void> {
-  await safeAxios<BeeGenericResponse>({
-    method: 'post',
-    url: `${url}${endpoint}/send/${topic}/${target.slice(0, 4)}`,
-    data: await prepareData(data),
-    responseType: 'json',
-    params: { recipient },
-    headers: extractUploadHeaders(postageBatchId),
-  })
-}
-
-/**
- * Subscribe for messages on the given topic
- *
- * @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,41 +0,0 @@
-import { BatchId, Reference, ReferenceResponse, UploadOptions } from '../types'
-import { extractUploadHeaders } from '../utils/headers'
-import { safeAxios } from '../utils/safe-axios'
-
-const socEndpoint = '/soc'
-
-/**
- * Upload single owner chunk (SOC) to a Bee node
- *
- * @param url             Bee URL
- * @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(
-  url: string,
-  owner: string,
-  identifier: string,
-  signature: string,
-  data: Uint8Array,
-  postageBatchId: BatchId,
-  options?: UploadOptions,
-): Promise<Reference> {
-  const response = await safeAxios<ReferenceResponse>({
-    ...options?.axiosOptions,
-    method: 'post',
-    url: `${url}${socEndpoint}/${owner}/${identifier}`,
-    data,
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options),
-    },
-    responseType: 'json',
-    params: { sig: signature },
-  })
-
-  return response.data.reference
-}

package/src/modules/stamps.ts

@@ -1,59 +0,0 @@
-import { BatchId, NumberString, PostageBatch, PostageBatchOptions } from '../types'
-import { safeAxios } from '../utils/safe-axios'
-
-const STAMPS_ENDPOINT = '/stamps'
-
-interface GetAllStampsResponse {
-  stamps: PostageBatch[]
-}
-
-interface CreateStampResponse {
-  batchID: BatchId
-}
-
-export async function getAllPostageBatches(url: string): Promise<PostageBatch[]> {
-  const response = await safeAxios<GetAllStampsResponse>({
-    method: 'get',
-    url: `${url}${STAMPS_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data.stamps || []
-}
-
-export async function getPostageBatch(url: string, postageBatchId: BatchId): Promise<PostageBatch> {
-  const response = await safeAxios<PostageBatch>({
-    method: 'get',
-    url: `${url}${STAMPS_ENDPOINT}/${postageBatchId}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function createPostageBatch(
-  url: string,
-  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 safeAxios<CreateStampResponse>({
-    method: 'post',
-    url: `${url}${STAMPS_ENDPOINT}/${amount}/${depth}`,
-    responseType: 'json',
-    params: { label: options?.label },
-    headers,
-  })
-
-  return response.data.batchID
-}

package/src/modules/status.ts

@@ -1,13 +0,0 @@
-import { safeAxios } from '../utils/safe-axios'
-
-/**
- * Ping the base bee URL. If connection was not successful throw error
- *
- * @param url Bee URL
- */
-export async function checkConnection(url: string): Promise<void> | never {
-  await safeAxios<string>({
-    url: url,
-    responseType: 'json',
-  })
-}

package/src/modules/stewardship.ts

@@ -1,21 +0,0 @@
-import { Reference } from '../types'
-import { safeAxios } from '../utils/safe-axios'
-import { AxiosRequestConfig } from 'axios'
-
-const stewardshipEndpoint = '/stewardship'
-
-/**
- * Reupload locally pinned data
- * @param url
- * @param reference
- * @param options
- * @throws BeeResponseError if not locally pinned or invalid data
- */
-export async function reupload(url: string, reference: Reference, options?: AxiosRequestConfig): Promise<void> {
-  await safeAxios({
-    ...options,
-    method: 'put',
-    url: `${url}${stewardshipEndpoint}/${reference}`,
-    responseType: 'json',
-  })
-}

package/src/modules/tag.ts

@@ -1,83 +0,0 @@
-import { Reference, Tag } from '../types'
-import { safeAxios } from '../utils/safe-axios'
-
-const endpoint = '/tags'
-
-interface GetAllTagsResponse {
-  tags: Tag[]
-}
-
-/**
- * Create new tag on the Bee node
- *
- * @param url Bee tag URL
- */
-export async function createTag(url: string): Promise<Tag> {
-  const response = await safeAxios<Tag>({
-    method: 'post',
-    url: url + 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(url: string, uid: number): Promise<Tag> {
-  const response = await safeAxios<Tag>({
-    url: `${url}${endpoint}/${uid}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get limited listing of all tags.
- *
- * @param url
- * @param offset
- * @param limit
- */
-export async function getAllTags(url: string, offset?: number, limit?: number): Promise<Tag[]> {
-  const response = await safeAxios<GetAllTagsResponse>({
-    url: `${url}${endpoint}`,
-    params: { offset, limit },
-    responseType: 'json',
-  })
-
-  return response.data.tags
-}
-
-/**
- * Removes tag from the Bee node.
- * @param url
- * @param uid
- */
-export async function deleteTag(url: string, uid: number): Promise<void> {
-  await safeAxios<void>({
-    method: 'delete',
-    url: `${url}${endpoint}/${uid}`,
-  })
-}
-
-/**
- * Updates tag
- * @param url
- * @param uid
- * @param reference
- */
-export async function updateTag(url: string, uid: number, reference: Reference): Promise<void> {
-  await safeAxios<void>({
-    method: 'patch',
-    url: `${url}${endpoint}/${uid}`,
-    data: {
-      reference,
-    },
-  })
-}

package/src/types/axios/index.d.ts

@@ -1,18 +0,0 @@
-declare module 'axios/lib/helpers/normalizeHeaderName' {
-  export default function (headers: Record<string, unknown>, header: string): void
-}
-
-declare module 'axios/lib/utils' {
-  import ArrayBufferView = NodeJS.ArrayBufferView
-
-  export function isFormData(data: unknown): boolean
-  export function isArrayBuffer(data: unknown): boolean
-  export function isBuffer(data: unknown): boolean
-  export function isStream(data: unknown): boolean
-  export function isFile(data: unknown): boolean
-  export function isBlob(data: unknown): boolean
-  export function isArrayBufferView(data: unknown): data is ArrayBufferView
-  export function isURLSearchParams(data: unknown): data is URLSearchParams
-  export function isObject(data: unknown): boolean
-  export function isUndefined(data: unknown): boolean
-}

package/src/types/debug.ts

@@ -1,204 +0,0 @@
-import { PublicKey, NumberString, Reference, TransactionHash } 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 {
-  /**
-   * 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
-}