@ethersphere/bee-js 2.0.0 → 3.1.0

package/src/modules/debug/chequebook.ts

@@ -1,175 +0,0 @@
-import { http } from '../../utils/http'
-import type {
-  ChequebookAddressResponse,
-  ChequebookBalanceResponse,
-  LastCashoutActionResponse,
-  TransactionResponse,
-  LastChequesForPeerResponse,
-  LastChequesResponse,
-  NumberString,
-  Ky,
-  CashoutOptions,
-  TransactionHash,
-} from '../../types'
-
-const chequebookEndpoint = 'chequebook'
-
-/**
- * Get the address of the chequebook contract used
- *
- * @param ky Ky debug instance
- */
-export async function getChequebookAddress(ky: Ky): Promise<ChequebookAddressResponse> {
-  const response = await http<ChequebookAddressResponse>(ky, {
-    path: chequebookEndpoint + '/address',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get the balance of the chequebook
- *
- * @param ky Ky debug instance
- */
-export async function getChequebookBalance(ky: Ky): Promise<ChequebookBalanceResponse> {
-  const response = await http<ChequebookBalanceResponse>(ky, {
-    path: chequebookEndpoint + '/balance',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get last cashout action for the peer
- *
- * @param ky Ky debug instance
- * @param peer  Swarm address of peer
- */
-export async function getLastCashoutAction(ky: Ky, peer: string): Promise<LastCashoutActionResponse> {
-  const response = await http<LastCashoutActionResponse>(ky, {
-    path: chequebookEndpoint + `/cashout/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Cashout the last cheque for the peer
- *
- * @param ky Ky debug instance
- * @param peer  Swarm address of peer
- * @param options
- */
-export async function cashoutLastCheque(ky: Ky, peer: string, options?: CashoutOptions): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (options?.gasPrice) {
-    headers['gas-price'] = options.gasPrice.toString()
-  }
-
-  if (options?.gasLimit) {
-    headers['gas-limit'] = options.gasLimit.toString()
-  }
-
-  const response = await http<TransactionResponse>(ky, {
-    method: 'post',
-    path: chequebookEndpoint + `/cashout/${peer}`,
-    responseType: 'json',
-    headers,
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Get last cheques for the peer
- *
- * @param ky Ky debug instance
- * @param peer  Swarm address of peer
- */
-export async function getLastChequesForPeer(ky: Ky, peer: string): Promise<LastChequesForPeerResponse> {
-  const response = await http<LastChequesForPeerResponse>(ky, {
-    path: chequebookEndpoint + `/cheque/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get last cheques for all peers
- *
- * @param ky Ky debug instance
- */
-export async function getLastCheques(ky: Ky): Promise<LastChequesResponse> {
-  const response = await http<LastChequesResponse>(ky, {
-    path: chequebookEndpoint + '/cheque',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Deposit tokens from overlay address into chequebook
- *
- * @param ky Ky debug instance
- * @param amount   Amount of tokens to deposit
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-export async function depositTokens(
-  ky: Ky,
-  amount: number | NumberString,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice.toString()
-  }
-
-  const response = await http<TransactionResponse>(ky, {
-    method: 'post',
-    path: chequebookEndpoint + '/deposit',
-    responseType: 'json',
-    searchParams: { amount: amount.toString(10) },
-    headers,
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Withdraw tokens from the chequebook to the overlay address
- *
- * @param ky Ky debug instance
- * @param amount   Amount of tokens to withdraw
- * @param gasPrice Gas Price in WEI for the transaction call
- * @return string  Hash of the transaction
- */
-export async function withdrawTokens(
-  ky: Ky,
-  amount: number | NumberString,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice.toString()
-  }
-
-  const response = await http<TransactionResponse>(ky, {
-    method: 'post',
-    path: chequebookEndpoint + '/withdraw',
-    responseType: 'json',
-    searchParams: { amount: amount.toString(10) },
-    headers,
-  })
-
-  return response.data.transactionHash
-}

package/src/modules/debug/chunk.ts

@@ -1,39 +0,0 @@
-import type { BeeGenericResponse, Ky } from '../../types'
-import { http } from '../../utils/http'
-
-const endpoint = 'chunks'
-
-/**
- * Check if chunk at address exists locally
- *
- * @param ky Ky debug instance
- * @param address  Swarm address of chunk
- *
- * @returns BeeGenericResponse if chunk is found or throws an exception
- */
-export async function checkIfChunkExistsLocally(ky: Ky, address: string): Promise<BeeGenericResponse> {
-  const response = await http<BeeGenericResponse>(ky, {
-    path: endpoint + `/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Delete a chunk from local storage
- *
- * @param ky Ky debug instance
- * @param address  Swarm address of chunk
- *
- * @returns BeeGenericResponse if chunk was deleted or throws an exception
- */
-export async function deleteChunkFromLocalStorage(ky: Ky, address: string): Promise<BeeGenericResponse> {
-  const response = await http<BeeGenericResponse>(ky, {
-    method: 'delete',
-    path: endpoint + `/${address}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/connectivity.ts

@@ -1,61 +0,0 @@
-import { http } from '../../utils/http'
-import type { Ky, NodeAddresses, Peer, PingResponse, RemovePeerResponse, Topology } from '../../types'
-
-export async function getNodeAddresses(ky: Ky): Promise<NodeAddresses> {
-  const response = await http<NodeAddresses>(ky, {
-    path: 'addresses',
-    responseType: 'json',
-  })
-
-  return response.data
-}
-interface Peers {
-  peers: Peer[]
-}
-
-export async function getPeers(ky: Ky): Promise<Peer[]> {
-  const response = await http<Peers>(ky, {
-    path: 'peers',
-    responseType: 'json',
-  })
-
-  return response.data.peers || []
-}
-
-export async function getBlocklist(ky: Ky): Promise<Peer[]> {
-  const response = await http<Peers>(ky, {
-    path: 'blocklist',
-    responseType: 'json',
-  })
-
-  return response.data.peers || []
-}
-
-export async function removePeer(ky: Ky, peer: string): Promise<RemovePeerResponse> {
-  const response = await http<RemovePeerResponse>(ky, {
-    path: `peers/${peer}`,
-    responseType: 'json',
-    method: 'DELETE',
-  })
-
-  return response.data
-}
-
-export async function getTopology(ky: Ky): Promise<Topology> {
-  const response = await http<Topology>(ky, {
-    path: `topology`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function pingPeer(ky: Ky, peer: string): Promise<PingResponse> {
-  const response = await http<PingResponse>(ky, {
-    path: `pingpong/${peer}`,
-    responseType: 'json',
-    method: 'POST',
-  })
-
-  return response.data
-}

package/src/modules/debug/settlements.ts

@@ -1,33 +0,0 @@
-import { http } from '../../utils/http'
-import type { Settlements, AllSettlements, Ky } from '../../types'
-
-const settlementsEndpoint = 'settlements'
-
-/**
- * Get amount of sent and received from settlements with a peer
- *
- * @param ky Ky debug instance
- * @param peer  Swarm address of peer
- */
-export async function getSettlements(ky: Ky, peer: string): Promise<Settlements> {
-  const response = await http<Settlements>(ky, {
-    path: `${settlementsEndpoint}/${peer}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get settlements with all known peers and total amount sent or received
- *
- * @param ky Ky debug instance
- */
-export async function getAllSettlements(ky: Ky): Promise<AllSettlements> {
-  const response = await http<AllSettlements>(ky, {
-    path: settlementsEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/stamps.ts

@@ -1,76 +0,0 @@
-import type {
-  BatchId,
-  DebugPostageBatch,
-  Ky,
-  NumberString,
-  PostageBatchBuckets,
-  PostageBatchOptions,
-} from '../../types'
-import { http } from '../../utils/http'
-
-const STAMPS_ENDPOINT = 'stamps'
-
-interface GetAllStampsResponse {
-  stamps: DebugPostageBatch[]
-}
-
-interface CreateStampResponse {
-  batchID: BatchId
-}
-
-export async function getAllPostageBatches(ky: Ky): Promise<DebugPostageBatch[]> {
-  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<DebugPostageBatch> {
-  const response = await http<DebugPostageBatch>(ky, {
-    method: 'get',
-    path: `${STAMPS_ENDPOINT}/${postageBatchId}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-export async function getPostageBatchBuckets(ky: Ky, postageBatchId: BatchId): Promise<PostageBatchBuckets> {
-  const response = await http<PostageBatchBuckets>(ky, {
-    method: 'get',
-    path: `${STAMPS_ENDPOINT}/${postageBatchId}/buckets`,
-    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/debug/states.ts

@@ -1,35 +0,0 @@
-import { http } from '../../utils/http'
-import { ChainState, Ky, ReserveState } from '../../types'
-
-const RESERVE_STATE_ENDPOINT = 'reservestate'
-const CHAIN_STATE_ENDPOINT = 'chainstate'
-
-/**
- * Get state of reserve
- *
- * @param ky Ky debug instance
- */
-export async function getReserveState(ky: Ky): Promise<ReserveState> {
-  const response = await http<ReserveState>(ky, {
-    method: 'get',
-    path: `${RESERVE_STATE_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Get state of reserve
- *
- * @param ky Ky debug instance
- */
-export async function getChainState(ky: Ky): Promise<ChainState> {
-  const response = await http<ChainState>(ky, {
-    method: 'get',
-    path: `${CHAIN_STATE_ENDPOINT}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/status.ts

@@ -1,35 +0,0 @@
-import { http } from '../../utils/http'
-import type { Health } from '../../types/debug'
-import { engines } from '../../../package.json'
-import { Ky } from '../../types'
-export const SUPPORTED_BEE_VERSION_EXACT = engines.bee
-export const SUPPORTED_BEE_VERSION = engines.bee.substr(0, engines.bee.indexOf('-'))
-
-/**
- * Get health of node
- *
- * @param ky Ky debug instance
- */
-export async function getHealth(ky: Ky): Promise<Health> | never {
-  const response = await http<Health>(ky, {
-    method: 'get',
-    path: `health`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Connnects to a node and checks if it is a supported Bee version by the bee-js
- *
- * @param ky Ky debug instance
- *
- * @returns true if the Bee node version is supported
- */
-export async function isSupportedVersion(ky: Ky): Promise<boolean> | never {
-  const { version } = await getHealth(ky)
-
-  // TODO: Remove this workaround when new Bee version is out https://github.com/ethersphere/bee-js/issues/400
-  return version === SUPPORTED_BEE_VERSION_EXACT || version === '1.1.0-dev'
-}

package/src/modules/debug/tag.ts

@@ -1,19 +0,0 @@
-import { ExtendedTag, Ky } from '../../types'
-import { http } from '../../utils/http'
-
-const endpoint = 'tags'
-
-/**
- * Retrieve tag with extended information from Bee node
- *
- * @param ky Ky debug instance
- * @param uid UID of tag to be retrieved
- */
-export async function retrieveExtendedTag(ky: Ky, uid: number): Promise<ExtendedTag> {
-  const response = await http<ExtendedTag>(ky, {
-    path: `${endpoint}/${uid}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}

package/src/modules/debug/transactions.ts

@@ -1,79 +0,0 @@
-import { Ky, NumberString, TransactionHash, TransactionInfo } from '../../types'
-import { http } from '../../utils/http'
-
-const transactionsEndpoint = 'transactions'
-
-interface PendingTransactionsResponse {
-  pendingTransactions: TransactionInfo[]
-}
-
-interface TransactionResponse {
-  transactionHash: TransactionHash
-}
-
-/**
- * Get list of all pending transactions
- *
- * @param ky   Debug Ky instance
- */
-export async function getAllTransactions(ky: Ky): Promise<TransactionInfo[]> {
-  const response = await http<PendingTransactionsResponse>(ky, {
-    path: transactionsEndpoint,
-    responseType: 'json',
-  })
-
-  return response.data.pendingTransactions
-}
-
-/**
- * Get information for specific pending transactions
- *
- * @param ky   Debug Ky instance
- * @param transactionHash Hash of the transaction
- */
-export async function getTransaction(ky: Ky, transactionHash: TransactionHash): Promise<TransactionInfo> {
-  const response = await http<TransactionInfo>(ky, {
-    path: `${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data
-}
-
-/**
- * Rebroadcast existing transaction
- *
- * @param ky   Debug Ky instance
- * @param transactionHash Hash of the transaction
- */
-export async function rebroadcastTransaction(ky: Ky, transactionHash: TransactionHash): Promise<TransactionHash> {
-  const response = await http<TransactionResponse>(ky, {
-    method: 'post',
-    path: `${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data.transactionHash
-}
-
-/**
- * Cancel existing transaction
- *
- * @param ky   Debug Ky instance
- * @param transactionHash Hash of the transaction
- * @param gasPrice Optional gas price
- */
-export async function cancelTransaction(
-  ky: Ky,
-  transactionHash: TransactionHash,
-  gasPrice?: NumberString,
-): Promise<TransactionHash> {
-  const response = await http<TransactionResponse>(ky, {
-    method: 'delete',
-    headers: { 'gas-price': gasPrice },
-    path: `${transactionsEndpoint}/${transactionHash}`,
-    responseType: 'json',
-  })
-
-  return response.data.transactionHash
-}

package/src/modules/feed.ts

@@ -1,105 +0,0 @@
-import { BatchId, Ky, Reference, ReferenceResponse, Topic } from '../types'
-import { filterHeaders, http } from '../utils/http'
-import { FeedType } from '../feed/type'
-import { HexEthAddress } from '../utils/eth'
-import { extractUploadHeaders } from '../utils/headers'
-import { BeeError } from '../utils/error'
-
-const feedEndpoint = 'feeds'
-
-export interface CreateFeedOptions {
-  type?: FeedType
-}
-
-export interface FeedUpdateOptions {
-  /**
-   * Specifies the start date as unix time stamp
-   */
-  at?: number
-  /**
-   * Can be 'epoch' or 'sequence' (default: 'sequence')
-   */
-  type?: FeedType
-}
-
-interface FeedUpdateHeaders {
-  feedIndex: string
-  feedIndexNext: string
-}
-export interface FetchFeedUpdateResponse extends ReferenceResponse, FeedUpdateHeaders {}
-
-/**
- * Create an initial feed root manifest
- *
- * @param ky Ky instance
- * @param owner           Owner's ethereum address in hex
- * @param topic           Topic in hex
- * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
- * @param options         Additional options, like type (default: 'sequence')
- */
-export async function createFeedManifest(
-  ky: Ky,
-  owner: HexEthAddress,
-  topic: Topic,
-  postageBatchId: BatchId,
-  options?: CreateFeedOptions,
-): Promise<Reference> {
-  const response = await http<ReferenceResponse>(ky, {
-    method: 'post',
-    responseType: 'json',
-    path: `${feedEndpoint}/${owner}/${topic}`,
-    searchParams: filterHeaders(options),
-    headers: extractUploadHeaders(postageBatchId),
-  })
-
-  return response.data.reference
-}
-
-function readFeedUpdateHeaders(headers: Headers): FeedUpdateHeaders {
-  const feedIndex = headers.get('swarm-feed-index')
-  const feedIndexNext = headers.get('swarm-feed-index-next')
-
-  if (!feedIndex) {
-    throw new BeeError('Response did not contain expected swarm-feed-index!')
-  }
-
-  if (!feedIndexNext) {
-    throw new BeeError('Response did not contain expected swarm-feed-index-next!')
-  }
-
-  return {
-    feedIndex,
-    feedIndexNext,
-  }
-}
-
-/**
- * Find and retrieve feed update
- *
- * The feed consists of updates. This endpoint looks up an
- * update that matches the provided parameters and returns
- * the reference it contains along with its index and the
- * index of the subsequent update.
- *
- * @param ky Ky instance
- * @param owner       Owner's ethereum address in hex
- * @param topic       Topic in hex
- * @param options     Additional options, like index, at, type
- */
-export async function fetchFeedUpdate(
-  ky: Ky,
-  owner: HexEthAddress,
-  topic: Topic,
-  options?: FeedUpdateOptions,
-): Promise<FetchFeedUpdateResponse> {
-  const response = await http<ReferenceResponse>(ky, {
-    responseType: 'json',
-    path: `${feedEndpoint}/${owner}/${topic}`,
-    searchParams: filterHeaders(options),
-  })
-
-  return {
-    ...response.data,
-    ...readFeedUpdateHeaders(response.headers),
-  }
-}